Django માં views શું છે?

Question

Accepted Answer

એક **view** એ Django નો logic layer છે — એક ફંક્શન અથવા ક્લાસ જે 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
```

એક 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, વગેરે) inspect કરે છે અને input ને `request.POST`, `request.GET`, `request.user`, વગેરે દ્વારા access કરે છે.

## 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`) સમાવિષ્ટ છે જે common 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 layer છે (MVT નો "V", MVC ના controller ની સમાન) — તેઓ એ છે જ્યાં તમે દરેક request હેન્ડલ કરો, તેમને કોઈ પણ Django application બનાવવા માટે મૂળભૂત બનાવે છે.

Views સમજવું આવશ્યક છે કારણ કે તેઓ orchestrators છે જે બધું જ એકસાથે જોડે છે: request મેળવવું, business logic લાગુ કરવું, models માંથી data માટે query કરવું, user input (forms) process કરવું, અને appropriate response આપવું (templates દ્વારા HTML, અથવા APIs માટે JSON).

**Function-based views** (explicit, flexible — custom logic માટે સારું) કેવી રીતે લખવા છે, વિવિધ HTTP methods હેન્ડલ કરવા અને request data access કરવું, અને **class-based/generic views** (જે listing અને CRUD જેવી common patterns માટે boilerplate નાટકીય રીતે ઘટાવે છે) ઉપયોગ કરવું એ practical spectrum કવર કરે છે Django endpoints બનાવવા માટે.

Views એ છે જ્યાં application ના મોટા ભાગનો request-handling logic રહે છે, તેથી તેમાં માસ્ટર થવું — request/response cycle, function-based અને class-based approaches વચ્ચે પસંદગી, અને views કેવી રીતે URLs ને models અને templates સાથે જોડે છે — તે core, રોજ જ્ઞાન છે કોઈ પણ Django developer માટે અને Django framework કેવી રીતે requests process કરે છે તેનો કેન્દ્રીય છે.