Hvad er views i Django?

Question

Accepted Answer

En **view** er logiklaget i Django — en funktion eller klasse, der tager en HTTP **request**, udfører logik (forespørger modeller, behandler input) og returnerer et HTTP **response**. Views er hvor du håndterer det, der sker, når en URL tilgås.

## Function-based views (FBVs)

```python
from django.shortcuts import render, get_object_or_404
from django.http import JsonResponse, HttpResponse

def article_list(request):
    articles = Article.objects.all()                    # query models
    return render(request, "articles.html", {"articles": articles})  # render a template

def article_detail(request, pk):
    article = get_object_or_404(Article, pk=pk)         # 404 if not found
    return render(request, "detail.html", {"article": article})

def api_articles(request):
    data = list(Article.objects.values("title", "body"))
    return JsonResponse(data, safe=False)               # return JSON instead of HTML
```

En function-based view modtager `request` (plus eventuelle URL-parametre), udfører sit arbejde og returnerer et response — `render()` for HTML, `JsonResponse` for JSON, `HttpResponse` for rå output.

## Håndtering af forskellige HTTP-metoder og input

```python
def create_article(request):
    if request.method == "POST":
        form = ArticleForm(request.POST)
        if form.is_valid():
            form.save()
            return redirect("article_list")             # redirect after a successful POST
    else:
        form = ArticleForm()
    return render(request, "create.html", {"form": form})
```

Views inspicerer `request.method` (GET, POST osv.) og får adgang til input via `request.POST`, `request.GET`, `request.user` osv.

## Class-based views (CBVs) — genbrugelige, mindre boilerplate

```python
from django.views.generic import ListView, DetailView

# generic CBVs handle common patterns with minimal code
class ArticleListView(ListView):
    model = Article                                     # automatically lists all articles
    template_name = "articles.html"

class ArticleDetailView(DetailView):
    model = Article
```

Django tilbyder også **class-based views** — herunder generic views (`ListView`, `DetailView`, `CreateView`), der implementerer almindelige mønstre (listing, detalje, CRUD) med meget lidt kode, hvilket reducerer boilerplate.

## Viewets rolle i request-flowet

```text
Request → URL routing → VIEW (logic) → queries models, renders template → Response
The view is the orchestrator: it connects the URL, the data (models), and the
presentation (template) to produce a response.
```

## Hvorfor det betyder noget

Views er logiklaget i Django ("V" i MVT, svarende til MVC's controller) — de er hvor du håndterer hver request, hvilket gør dem fundamentale for at bygge enhver Django-applikation.

At forstå views er væsentligt, fordi de er orkestratorer, der binder alt sammen: de modtager requesten, anvender forretningslogik, forespørger modeller for data, behandler brugerinput (formularer) og returnerer det passende response (HTML via templates eller JSON for API'er).

At kende **function-based views** (eksplicitte, fleksible — godt til custom logik), håndtering af forskellige HTTP-metoder og adgang til request-data, samt brug af **class-based/generic views** (som dramatisk reducerer boilerplate for almindelige mønstre som listing og CRUD) dækker det praktiske spektrum af opbygning af Django-endpoints.

Views er hvor det meste af en applikations request-håndteringslogik befinder sig, så at mestre dem — request/response-cyklus, valg mellem function-based og class-based tilgange, og hvordan views forbinder URL'er til modeller og templates — er kernekendskab til hverdag for enhver Django-udvikler og er centralt for, hvordan frameworket behandler requests.