Co jsou views v Django?

Question

Accepted Answer

**View** je vrstva logiky v Django — funkce nebo třída, která přijímá HTTP **request**, provádí logiku (dotazy na modely, zpracování vstupu) a vrací HTTP **response**. Views jsou místem, kde se řeší, co se stane při přístupu na URL.

## Funkční 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
```

Funkční view obdrží `request` (plus všechny parametry z URL), provede svou práci a vrátí response — `render()` pro HTML, `JsonResponse` pro JSON, `HttpResponse` pro surový výstup.

## Zpracování různých HTTP metod a vstupu

```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 kontrolují `request.method` (GET, POST, atd.) a přistupují ke vstupu přes `request.POST`, `request.GET`, `request.user`, atd.

## Class-based views (CBVs) — znovupoužitelné, méně 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 také nabízí **class-based views** — včetně generic views (`ListView`, `DetailView`, `CreateView`), které implementují běžné vzory (výpis, detaily, CRUD) s velmi málo kódu, čímž snižují boilerplate.

## Role view v toku requestu

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

## Proč je to důležité

Views jsou vrstva logiky Django ("V" v MVT, ekvivalent kontroleru v MVC) — jsou místem, kde řešíte každý request, což je fundamentální pro stavbu jakékoli Django aplikace.

Rozmívění views je nezbytné, protože jsou orchestrátory, které spojují vše dohromady: přijímají request, aplikují business logiku, dotazují se modely na data, zpracovávají vstup od uživatele (formuláře) a vracejí příslušný response (HTML přes šablony nebo JSON pro API).

Znalost psaní **function-based views** (explicitní, flexibilní — vhodné pro vlastní logiku), zpracování různých HTTP metod a přístupu k datům requestu a používání **class-based/generic views** (které dramaticky snižují boilerplate pro běžné vzory jako výpis a CRUD) pokrývá praktické spektrum budování Django endpointů.

Views jsou místem, kde žije většina logiky aplikace pro zpracování requestů, takže jejich zvládnutí — cyklus request/response, volba mezi function-based a class-based přístupy a způsob, jak views propojují URL s modely a šablonami — je základní, každodenní znalostí pro jakéhokoli Django vývojáře a je to ústředný prvek toho, jak framework zpracovává requesty.