Django में views क्या होते हैं?

Question

Accepted Answer

एक **view** Django की logic परत है — एक function या class जो एक HTTP **request** लेता है, logic करता है (models को query करना, input को process करना), और एक HTTP **response** लौटाता है। Views वह जगह हैं जहाँ आप यह संभालते हैं कि किसी URL तक पहुँचने पर क्या होता है।

## Function-based 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
```

एक function-based view `request` (साथ ही कोई भी URL parameters) प्राप्त करता है, अपना काम करता है, और एक response लौटाता है — HTML के लिए `render()`, JSON के लिए `JsonResponse`, raw output के लिए `HttpResponse`।

## विभिन्न HTTP methods और input को संभालना

```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 `request.method` (GET, POST, आदि) का निरीक्षण करते हैं और `request.POST`, `request.GET`, `request.user`, आदि के माध्यम से input तक पहुँचते हैं।

## Class-based views (CBVs) — पुनः-प्रयोज्य, कम 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 **class-based views** भी प्रदान करता है — जिनमें generic views (`ListView`, `DetailView`, `CreateView`) शामिल हैं जो सामान्य patterns (listing, detail, CRUD) को बहुत कम code के साथ लागू करते हैं, boilerplate को घटाते हैं।

## request flow में view की भूमिका

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

## यह क्यों महत्वपूर्ण है

Views Django की logic परत हैं (MVT में "V", MVC के controller के समतुल्य) — ये वह जगह हैं जहाँ आप प्रत्येक request को संभालते हैं, जिससे ये किसी भी Django application बनाने के लिए मूलभूत बन जाते हैं।

Views को समझना आवश्यक है क्योंकि ये वे orchestrators हैं जो सब कुछ आपस में बाँधते हैं: request प्राप्त करना, business logic लागू करना, data के लिए models को query करना, user input (forms) को process करना, और उपयुक्त response लौटाना (templates के माध्यम से HTML, या APIs के लिए JSON)।

**function-based views** लिखना जानना (स्पष्ट, लचीले — custom logic के लिए अच्छे), विभिन्न HTTP methods को संभालना और request data तक पहुँचना, और **class-based/generic views** का उपयोग करना (जो listing और CRUD जैसे सामान्य patterns के लिए boilerplate को नाटकीय रूप से घटाते हैं) Django endpoints बनाने के व्यावहारिक दायरे को कवर करता है।

Views वह जगह हैं जहाँ किसी application का अधिकांश request-handling logic रहता है, इसलिए इन्हें निपुण करना — request/response चक्र, function-based और class-based दृष्टिकोणों के बीच चुनाव, और views URLs को models और templates से कैसे जोड़ते हैं — किसी भी Django developer के लिए मूल, रोज़मर्रा का ज्ञान है और framework requests को कैसे process करता है, इसके केंद्र में है।