Que sont les vues dans Django ?

Question

Accepted Answer

Une **vue** est la couche logique de Django — une fonction ou classe qui prend une **requête** HTTP, exécute de la logique (interroge les modèles, traite les entrées) et retourne une **réponse** HTTP. Les vues sont l'endroit où vous gérez ce qui se passe quand une URL est accédée.

## Vues basées sur des fonctions (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
```

Une vue basée sur une fonction reçoit la `request` (plus tous les paramètres d'URL), fait son travail et retourne une réponse — `render()` pour HTML, `JsonResponse` pour JSON, `HttpResponse` pour une sortie brute.

## Gérer différentes méthodes HTTP et entrées

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

Les vues inspectent `request.method` (GET, POST, etc.) et accèdent aux entrées via `request.POST`, `request.GET`, `request.user`, etc.

## Vues basées sur des classes (CBVs) — réutilisables, moins de code répétitif

```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 offre aussi des **vues basées sur des classes** — y compris des vues génériques (`ListView`, `DetailView`, `CreateView`) qui implémentent des motifs courants (listage, détail, CRUD) avec très peu de code, réduisant le code répétitif.

## Le rôle de la vue dans le flux de requête

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

## Pourquoi c'est important

Les vues sont la couche logique de Django (le "V" dans MVT, équivalent au contrôleur dans MVC) — c'est là où vous gérez chaque requête, ce qui les rend fondamentales pour construire toute application Django.

Comprendre les vues est essentiel car ce sont elles qui orchestrent et attachent tout ensemble : recevoir la requête, appliquer la logique métier, interroger les modèles pour les données, traiter les entrées utilisateur (formulaires) et retourner la réponse appropriée (HTML via les templates ou JSON pour les APIs).

Savoir écrire des **vues basées sur des fonctions** (explicites, flexibles — bonnes pour la logique personnalisée), gérer différentes méthodes HTTP et accéder aux données de requête, et utiliser des **vues basées sur des classes/vues génériques** (qui réduisent dramatiquement le code répétitif pour des motifs courants comme le listage et CRUD) couvre l'ensemble pratique de la construction d'endpoints Django.

Les vues sont l'endroit où vit la majorité de la logique de gestion des requêtes d'une application, donc les maîtriser — le cycle requête/réponse, le choix entre les approches basées sur des fonctions et basées sur des classes, et comment les vues connectent les URLs aux modèles et templates — est une connaissance fondamentale et quotidienne pour tout développeur Django et est au cœur de la manière dont le framework traite les requêtes.