¿Qué son las vistas en Django?

Question

Accepted Answer

Una **vista** es la capa de lógica de Django — una función o clase que toma una **solicitud** HTTP, realiza lógica (consultando modelos, procesando entrada), y devuelve una **respuesta** HTTP. Las vistas son donde manejas qué sucede cuando se accede a una URL.

## Vistas basadas en funciones (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
```

Una vista basada en función recibe la `request` (más cualquier parámetro de URL), realiza su trabajo, y devuelve una respuesta — `render()` para HTML, `JsonResponse` para JSON, `HttpResponse` para salida sin procesar.

## Manejo de diferentes métodos HTTP y entrada

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

Las vistas inspeccionan `request.method` (GET, POST, etc.) y acceden a la entrada vía `request.POST`, `request.GET`, `request.user`, etc.

## Vistas basadas en clases (CBVs) — reutilizables, menos código repetitivo

```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 también ofrece **vistas basadas en clases** — incluyendo vistas genéricas (`ListView`, `DetailView`, `CreateView`) que implementan patrones comunes (listado, detalle, CRUD) con muy poco código, reduciendo el código repetitivo.

## El rol de la vista en el flujo de solicitud

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

## Por qué es importante

Las vistas son la capa de lógica de Django (la "V" en MVT, equivalente al controlador en MVC) — son donde manejas cada solicitud, haciéndolas fundamentales para construir cualquier aplicación Django.

Comprender las vistas es esencial porque son los orquestadores que unen todo: recibiendo la solicitud, aplicando lógica de negocio, consultando modelos para obtener datos, procesando entrada de usuario (formularios), y devolviendo la respuesta apropiada (HTML vía plantillas, o JSON para APIs).

Saber escribir **vistas basadas en funciones** (explícitas, flexibles — buenas para lógica personalizada), manejar diferentes métodos HTTP y acceder a datos de solicitud, y usar **vistas basadas en clases/genéricas** (que reducen dramáticamente el código repetitivo para patrones comunes como listado y CRUD) cubre el espectro práctico de construir endpoints Django.

Las vistas son donde vive la mayoría de la lógica de manejo de solicitudes de una aplicación, así que dominarlas — el ciclo solicitud/respuesta, la elección entre enfoques basados en funciones y basados en clases, y cómo las vistas conectan URLs con modelos y plantillas — es conocimiento central y cotidiano para cualquier desarrollador Django y central a cómo el framework procesa solicitudes.