Što su prikazi (views) u Django-u?

Question

Accepted Answer

**Prikaz** (view) je logički sloj Django-a — funkcija ili klasa koja prima HTTP **zahtjev**, izvršava logiku (pretražuje modele, obrađuje unos) i vraća HTTP **odgovor**. Prikazi su mjesto gdje upravljate onim što se događa kada se pristupi URL-u.

## Funkcijski prikazi (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 prikaz prima `request` (plus sve parametre iz URL-a), obavlja svoj posao i vraća odgovor — `render()` za HTML, `JsonResponse` za JSON, `HttpResponse` za raw izlaz.

## Rukovanje različitim HTTP metodama i unoseom

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

Prikazi provjeravaju `request.method` (GET, POST, itd.) i pristupaju unosu putem `request.POST`, `request.GET`, `request.user`, itd.

## Klasni prikazi (CBVs) — ponovno iskoristivi, manje šablonskog koda

```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 također nudi **klasne prikaze** — uključujući generičke prikaze (`ListView`, `DetailView`, `CreateView`) koji implementiraju česte obrasce (popis, detalj, CRUD) s vrlo malo koda, smanjujući šablonski kod.

## Uloga prikaza u toku zahtjeva

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

## Zašto je to važno

Prikazi su logički sloj Django-a ("V" u MVT-u, ekvivalentno kontroleru u MVC-u) — to je mjesto gdje rukovodite svakim zahtjevom, čineći ih temeljnima za izgradnju bilo koje Django aplikacije.

Razumijevanje prikaza je bitno jer su oni orkestratoli koji sve povezuju: primaju zahtjev, primjenjuju poslovnu logiku, pretražuju modele za podatke, obrađuju korisnikov unos (obrasce) i vraćaju odgovarajući odgovor (HTML putem šablona ili JSON za API-je).

Znanje kako napisati **funkcijske prikaze** (eksplicitne, fleksibilne — dobri za prilagođenu logiku), rukovati različitim HTTP metodama i pristupiti podacima zahtjeva, te koristiti **klasne/generičke prikaze** (koji dramatično smanjuju šablonski kod za česte obrasce kao popis i CRUD) pokriva praktičan spektar izgradnje Django krajnjih točaka.

Prikazi su gdje većina logike rukovanja zahtjevima u aplikaciji živi, pa njihovo savladavanje — ciklus zahtjeva/odgovora, izbor između funkcijskih i klasnih pristupa, te kako prikazi povezuju URL-e s modelima i šablonima — je temeljna, svakodnevna znanja za svakog Django razvojnog inženjera i centralna je za to kako okvir obrađuje zahtjeve.