Kaj so pogledi (views) v Django-ju?

Question

Accepted Answer

**Pogled** je plast logike v Django-ju — funkcija ali razred, ki sprejme HTTP **zahtevo** (request), izvede logiko (poizvedovanje modelov, obdelava vnosa) in vrne HTTP **odgovor** (response). Pogledi so mesto, kjer obravnavate, kaj se zgodi, ko je dostopana URL naslov.

## Funkcijski pogledi (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
```

Funkcijski pogled sprejme `request` (plus morebitne parametre iz URL-ja), opravi svoje delo in vrne odgovor — `render()` za HTML, `JsonResponse` za JSON, `HttpResponse` za surove podatke.

## Obravnava različnih HTTP metod in vnosa

```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})
```

Pogledi pregledajo `request.method` (GET, POST, itd.) in dostopajo do vnosa prek `request.POST`, `request.GET`, `request.user`, itd.

## Razredni pogledi (CBVs) — ponovno uporabni, manj boilerplate kode

```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 nudi tudi **razredne poglede** — vključno s splošnimi pogledi (`ListView`, `DetailView`, `CreateView`), ki izvedejo pogoste vzorce (seznamski prikaz, podrobni prikaz, CRUD) z zelo malo kode, kar zmanjša boilerplate kodo.

## Vloga pogleda v toku zahteve

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

## Zakaj je to pomembno

Pogledi so plast logike Django-ja ("V" v MVT, enakovredno krmilniku v MVC-ju) — to je mesto, kjer obravnavate vsako zahtevo, zato so temeljni za gradnjo katere koli Django aplikacije.

Razumevanje pogledov je bistveno, ker so to orchesteratorji, ki vse skupaj povezujejo: sprejemajo zahtevo, uporabljajo poslovno logiko, poizvedujejo modele za podatke, obdelujejo uporabniški vnos (obrazce) in vrnejo ustrezni odgovor (HTML prek predlog ali JSON za API-je).

Znanje, kako napisati **funkcijske poglede** (eksplicitne, fleksibilne — dobri za lastno logiko), obravnavati različne HTTP metode in dostopati do podatkov zahteve ter uporabiti **razredne/splošne poglede** (ki dramatično zmanjšajo boilerplate za pogoste vzorce, kot so seznamski prikaz in CRUD), pokriva praktičen spekter gradnje Django končnih točk.

Pogledi so mesto, kjer se večina logike aplikacije za obravnavo zahtev nahaja, zato je obvladovanje njih — ciklusa zahteve/odgovora, izbire med funkcijskim in razrednim pristopom ter kako se pogledi povezujejo z URL-ji, modeli in predlogami — temeljno, vsakdansko znanje za katerega koli Django razvijalca in je osrednjega pomena za to, kako ogrodjem obdeluje zahteve.