Django ਵਿੱਚ views ਕੀ ਹਨ?

Question

Accepted Answer

A **view** Django ਦੀ logic layer ਹੈ — ਇੱਕ function ਜਾਂ class ਜੋ HTTP **request** ਲੈਂਦਾ ਹੈ, logic ਲਾਗੂ ਕਰਦਾ ਹੈ (models ਨੂੰ query ਕਰਨਾ, input ਨੂੰ process ਕਰਨਾ), ਅਤੇ HTTP **response** ਵਾਪਸ ਕਰਦਾ ਹੈ। Views ਉਹ ਥਾਂ ਹਨ ਜਿੱਥੇ ਤੁਸੀਂ ਸੰਭਾਲਦੇ ਹੋ ਕਿ URL ਨੂੰ access ਕਰਨ ਸਮੇਂ ਕੀ ਹੁੰਦਾ ਹੈ।

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

Eک function-based view `request` (ਅਤੇ ਕਿਸੇ ਵੀ URL parameters) ਨੂੰ receive ਕਰਦਾ ਹੈ, ਆਪਣਾ ਕਾਮ ਕਰਦਾ ਹੈ, ਅਤੇ ਇੱਕ response ਵਾਪਸ ਕਰਦਾ ਹੈ — HTML ਲਈ `render()`, JSON ਲਈ `JsonResponse`, raw output ਲਈ `HttpResponse`।

## ਵੱਖ-ਵੱਖ HTTP methods ਅਤੇ input ਨੂੰ handle ਕਰਨਾ

```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, ਆਦਿ) ਨੂੰ inspect ਕਰਦੇ ਹਨ ਅਤੇ `request.POST`, `request.GET`, `request.user`, ਆਦਿ ਦੁਆਰਾ input ਨੂੰ access ਕਰਦੇ ਹਨ।

## Class-based views (CBVs) — reusable, کم 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`) ਸਮੇਤ ਜੋ common patterns (listing, detail, CRUD) ਨੂੰ ਬਹੁਤ ਹੀ ਥੋੜੇ ਕੋਡ ਦੇ ਨਾਲ implement ਕਰਦੇ ਹਨ, ਬਹੁਤ ਸਾਰੇ 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 layer ਹਨ (MVT ਵਿੱਚ "V", MVC ਦੇ controller ਦੇ ਬਰਾਬਰ) — ਇਹ ਉਹ ਥਾਂ ਹਨ ਜਿੱਥੇ ਤੁਸੀਂ ਹਰ request ਨੂੰ handle ਕਰਦੇ ਹੋ, ਜਿਸ ਨਾਲ ਉਹ ਕਿਸੇ ਵੀ Django ਐਪਲੀਕੇਸ਼ਨ ਬਣਾਉਣ ਲਈ ਬੁਨਿਆਦੀ ਹਨ।

Views ਨੂੰ ਸਮਝਣਾ ਜ਼ਰੂਰੀ ਹੈ ਕਿਉਂਕਿ ਉਹ orchestrators ਹਨ ਜੋ ਸਭ ਕੁਝ ਨੂੰ ਜੋੜਦੇ ਹਨ: request ਨੂੰ receive ਕਰਨਾ, business logic ਨੂੰ apply ਕਰਨਾ, data ਲਈ models ਨੂੰ query ਕਰਨਾ, user input (forms) ਨੂੰ process ਕਰਨਾ, ਅਤੇ appropriate response ਨੂੰ return ਕਰਨਾ (templates ਦੁਆਰਾ HTML, ਜਾਂ APIs ਲਈ JSON)।

ਜਾਣਨਾ ਕਿ **function-based views** ਕਿਵੇਂ ਲਿਖਣੇ ਹਨ (explicit, flexible — custom logic ਲਈ ਚੰਗਾ), ਵੱਖ-ਵੱਖ HTTP methods ਨੂੰ handle ਕਰਨਾ ਅਤੇ request data ਨੂੰ access ਕਰਨਾ, ਅਤੇ **class-based/generic views** ਦੀ ਵਰਤੋਂ ਕਰਨਾ (ਜੋ common patterns ਜਿਵੇਂ listing ਅਤੇ CRUD ਲਈ boilerplate ਨੂੰ ਨਾਟਕੀ ਤਰੀਕੇ ਨਾਲ ਘਟਾਉਂਦੇ ਹਨ) Django endpoints ਬਣਾਉਣ ਦੇ practical spectrum ਨੂੰ cover ਕਰਦਾ ਹੈ।

Views ਉਹ ਥਾਂ ਹਨ ਜਿੱਥੇ ਜ਼ਿਆਦਾਤਰ ਐਪਲੀਕੇਸ਼ਨ ਦੀ request-handling logic ਰਹਿੰਦੀ ਹੈ, ਇਸਲਈ ਉਹਨਾਂ ਨੂੰ master ਕਰਨਾ — request/response cycle, function-based ਅਤੇ class-based approaches ਦੇ ਵਿੱਚ ਚੋਣ, ਅਤੇ ਕਿਵੇਂ views URLs ਨੂੰ models ਅਤੇ templates ਨਾਲ ਜੋੜਦੇ ਹਨ — core, ਰੋਜ਼ਾਨਾ ਦੀ ਜਾਣਕਾਰੀ ਹੈ ਕਿਸੇ ਵੀ Django developer ਲਈ ਅਤੇ ਇਹ ਉਸ ਤਰੀਕੇ ਦਾ ਕੇਂਦਰੀ ਹੈ ਜਿਸ ਵਿੱਚ framework requests ਨੂੰ process ਕਰਦਾ ਹੈ।