Hva er views i Django?

Question

Accepted Answer

En **view** er logikklaget i Django — en funksjon eller klasse som mottar en HTTP-**request**, utfører logikk (spør modeller, prosesserer input), og returnerer en HTTP-**response**. Views er der du håndterer hva som skjer når en URL blir aksessert.

## Funksjonsbaserte 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 funksjonsbasert view mottar `request` (pluss eventuelle URL-parametere), gjør sitt arbeid, og returnerer en response — `render()` for HTML, `JsonResponse` for JSON, `HttpResponse` for råutput.

## Håndtering av ulike 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 inspiserer `request.method` (GET, POST, osv.) og aksesserer input via `request.POST`, `request.GET`, `request.user`, osv.

## Klassebaserte views (CBVs) — gjenbrukbare, 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 tilbyr også **klassebaserte views** — inkludert generiske views (`ListView`, `DetailView`, `CreateView`) som implementerer vanlige mønstre (listing, detaljer, CRUD) med veldig lite kode, noe som reduserer boilerplate.

## Viewens rolle i request-flyten

```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 betyr noe

Views er logikklaget i Django ("V" i MVT, tilsvarende MVCs controller) — de er der du håndterer hver request, noe som gjør dem fundamentale for å bygge enhver Django-applikasjon.

Å forstå views er essensielt fordi de er orkestratørene som knytter alt sammen: mottar requesten, bruker forretningslogikk, spør modeller for data, prosesserer brukerinput (skjemaer), og returnerer den riktige responsen (HTML via templates, eller JSON for APIer).

Å vite hvordan man skriver **funksjonsbaserte views** (eksplisitt, fleksibel — bra for egendefinert logikk), håndtere ulike HTTP-metoder og aksessere request-data, og bruke **klassebaserte/generiske views** (som dramatisk reduserer boilerplate for vanlige mønstre som listing og CRUD) dekker det praktiske spekteret av å bygge Django-endepunkter.

Views er der mesteparten av en applikasjons request-håndteringslogikk bor, så å kunne mestre dem — request/response-syklusen, valget mellom funksjonsbaserte og klassebasierte tilnærminger, og hvordan views knytter URLer til modeller og templates — er kjernekunnskap i det daglige for enhver Django-utvikler og sentral for hvordan rammeverket prosesserer requests.