Django-ல் views என்றால் என்ன?

Question

Accepted Answer

**view** என்பது Django-ன் logic layer ஆகும் — ஒரு function அல்லது class ஆகியது HTTP **request**-ஐ பெற்று, logic-ஐ செயல்படுத்தி (models-ஐ query செய்யும், input-ஐ process செய்யும்), மற்றும் HTTP **response**-ஐ return செய்கிறது. URLs-ஐ access செய்யும்போது என்ன நடக்கிறது என்பதை handle செய்வதற்கு views உள்ளன.

## 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)-ஐ பெற்று, அதன் work-ஐ செய்து, response-ஐ return செய்கிறது — 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`-ஐ inspect செய்கின்றன (GET, POST, etc.) மற்றும் `request.POST`, `request.GET`, `request.user`, etc. மூலம் 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-ஐ implement செய்கின்றன (listing, detail, CRUD) மிகக் குறைவான code-க்கு, boilerplate-ஐ குறைக்கிறது.

## Request flow-ல் view-ன் role

```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 application-ஐ build செய்வதற்கு fundamental ஆகும்.

Views-ஐ புரிந்து கொள்வது essential ஆகும், ஏனெனில் அவை orchestrators ஆகும், அவை everything-ஐ ஒன்றாக tie செய்கின்றன: request-ஐ பெறுதல், business logic-ஐ apply செய்தல், data-க்கான models-ஐ query செய்தல், user input (forms)-ஐ process செய்தல், மற்றும் appropriate response-ஐ return செய்தல் (templates மூலம் HTML, அல்லது APIs-க்கான JSON).

**Function-based views**-ஐ எப்படி write செய்யவேண்டும் என்பதை தெரிந்து கொள்ளுதல் (explicit, flexible — custom logic-க்கு நல்லது), வெவ்வேறு HTTP methods-ஐ handle செய்தல் மற்றும் request data-ஐ access செய்தல், மற்றும் **class-based/generic views**-ஐ பயன்படுத்துதல் (listing மற்றும் CRUD போன்ற common patterns-க்கான boilerplate-ஐ dramatically குறைக்கிறது) Django endpoints-ஐ build செய்வதற்கான practical spectrum-ஐ cover செய்கிறது.

Views என்பது ஒரு application-ன் request-handling logic-ன் பெரும்பாலானவை இருக்கும் இடம், எனவே அவற்றை master செய்தல் — request/response cycle, function-based மற்றும் class-based approaches-க்கு இடையேயான choice, மற்றும் views எப்படி URLs-ஐ models மற்றும் templates-க்கு connect செய்கின்றன — core, everyday knowledge ஆகும் যেকொनো Django developer-க்கு மற்றும் framework-ல் requests-ஐ process செய்வதற்கு central ஆகும்.