Vad är views i Django?

Question

Accepted Answer

En **view** är logiklagret i Django — en funktion eller klass som tar en HTTP-**request**, utför logik (hämtar modeller, bearbetar indata) och returnerar en HTTP-**response**. Views är där du hanterar vad som händer när en URL accessas.

## Funktionsbaserade 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 funktionsbaserad view tar emot `request` (plus eventuella URL-parametrar), gör sitt arbete och returnerar en response — `render()` för HTML, `JsonResponse` för JSON, `HttpResponse` för rå output.

## Hantering av olika HTTP-metoder och indata

```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 inspekterar `request.method` (GET, POST, osv.) och accessar indata via `request.POST`, `request.GET`, `request.user`, osv.

## Klassbaserade views (CBVs) — återanvändbar, 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 erbjuder även **klassbaserade views** — inklusive generiska views (`ListView`, `DetailView`, `CreateView`) som implementerar vanliga mönster (listning, detalj, CRUD) med väldigt lite kod, vilket minskar boilerplate.

## Viewns roll i request-flödet

```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.
```

## Varför det spelar roll

Views är logiklagret i Django ("V" i MVT, motsvarar MVC:s controller) — de är där du hanterar varje request, vilket gör dem fundamentala för att bygga någon Django-applikation.

Att förstå views är väsentligt eftersom de är orkestratörerna som knyter allt ihop: tar emot requesten, tillämpar affärslogik, hämtar data från modeller, bearbetar användarindata (formulär) och returnerar lämplig response (HTML via templates, eller JSON för API:er).

Att veta hur man skriver **funktionsbaserade views** (explicit, flexibel — bra för egen logik), hanterar olika HTTP-metoder och accessar request-data, och använder **klassbaserade/generiska views** (som dramatiskt minskar boilerplate för vanliga mönster som listning och CRUD) täcker det praktiska spektrumet för att bygga Django-endpoints.

Views är där majoriteten av en applikations request-hanteringlogik finns, så att behärska dem — request/response-cykeln, valet mellan funktionsbaserade och klassbaserade tillvägagångssätt, och hur views kopplar samman URL:er till modeller och templates — är central, daglig kunskap för alla Django-utvecklare och central för hur ramverket bearbetar requests.