Django मध्ये views म्हणजे काय?

Question

Accepted Answer

**view** हा Django चा लॉजिक लेयर आहे — एक फंक्शन किंवा क्लास जो HTTP **request** घेतो, लॉजिक (मॉडेल्सचा प्रश्न विचारणे, इनपुटचे प्रक्रिया) करतो आणि 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
```

फंक्शन-बेस्ड व्यू `request` (अतिरिक्त URL पॅरामीटर्ससह) घेतो, त्याचे काम करतो आणि response परत करतो — HTML साठी `render()`, JSON साठी `JsonResponse`, कच्च्या आउटपुटसाठी `HttpResponse`.

## विविध HTTP पद्धती आणि इनपुट हाताळणे

```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`, इ. द्वारे इनपुट अ‍ॅक्सेस करतात.

## 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`) सह जे सामान्य पॅटर्न (listing, detail, CRUD) अत्यंत कमी कोडने लागू करतात, boilerplate कमी करतात.

## Request प्रवाहात 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 चा लॉजिक लेयर आहे (MVT मधील "V", MVC च्या नियंत्रकक्षाशी समतुल्य) — असे स्थान जेथे तुम्ही प्रत्येक request हाताळता, त्यांना कोणताही Django अॅप्लिकेशन तयार करण्यासाठी मूलभूत बनवतात.

Views समजणे आवश्यक आहे कारण ते orchestrator आहेत जे सर्वकाही जोडतात: request घेणे, व्यावसायिक लॉजिक लागू करणे, डेटासाठी मॉडेल्सचा प्रश्न विचारणे, वापरकर्ता इनपुट (forms) प्रक्रिया करणे आणि योग्य response (templates द्वारे HTML किंवा APIs साठी JSON) परत करणे.

**function-based views** कसे लिहायचे हे जाणून घेणे (स्पष्ट, लवकार — कस्टम लॉजिकसाठी चांगले), विविध HTTP पद्धती हाताळणे आणि request डेटा अ‍ॅक्सेस करणे, आणि **class-based/generic views** (जे सामान्य पॅटर्नसाठी boilerplate नाटकीयपणे कमी करतात जसे की listing आणि CRUD) वापरणे Django endpoints बांधण्याचा व्यावहारिक स्पेक्ट्रम कव्हर करतात.

Views असे स्थान आहे जेथे अॅप्लिकेशनचा बहुतांश request-handling लॉजिक राहतो, त्यामुळे त्यांना मास्टर करणे — request/response चक्र, function-based आणि class-based दृष्टिकोनांमधील निवड, आणि views कसे URLs, models आणि templates जोडतात हे — कोणत्याही Django डेव्हलपरसाठी मुख्य, दैनिक ज्ञान आहे आणि framework कसे requests प्रक्रिया करते याचे केंद्र आहे.