வகுப்பு-அடிப்படையிலான மற்றும் பொதுவான காட்சிகள் என்றால் என்ன?

Question

Accepted Answer

**வகுப்பு-அடிப்படையிலான காட்சிகள் (CBVs)** கோப்புகளுக்குப் பதிலாக Python வகுப்புகளாக காட்சிகளைச் செயல்படுத்துகின்றன, பரம்பரை மற்றும் mixins மூலம் மீண்டும் பயன்படுத்துவதை செயல்படுத்துகின்றன. **பொதுவான காட்சிகள்** பொதுவான வடிவங்களைக் கையாளும் உள்நிறுவிய CBVs ஆகும் (பட்டியல், விவரம், உருவாக்கு/புதுப்பி/நீக்கு) குறைந்தபட்ச குறியீடுடன் — நிலையான CRUD க்கான மீண்டும் உள்ள குறியீட்டைக் கணிசமாகக் குறைக்கிறது.

## செயல்பாடு-அடிப்படையிலான மற்றும் வகுப்பு-அடிப்படையிலான

```python
# function-based view (FBV) — explicit, but repetitive for common patterns
def article_list(request):
    articles = Article.objects.all()
    return render(request, "articles.html", {"articles": articles})

# class-based equivalent using a GENERIC view — far less code
from django.views.generic import ListView
class ArticleListView(ListView):
    model = Article                      # Django handles fetching + rendering
    template_name = "articles.html"
    context_object_name = "articles"
```

பொதுவான `ListView` தானாகவே அனைத்து பொருட்களையும் பெறுகிறது, பக்க பிரிவு செய்கிறது, மற்றும் ஒரு டெம்பிலேட்டை வழங்குகிறது — கையேடு செயல்பாட்டை சில பண்புக்களுடன் மாற்றுகிறது.

## பொதுவான காட்சிகள் (CRUD தொகுப்பு)

```python
from django.views.generic import ListView, DetailView, CreateView, UpdateView, DeleteView

class ArticleListView(ListView):     model = Article   # list all
class ArticleDetailView(DetailView): model = Article   # show one
class ArticleCreateView(CreateView):                    # a create form + save
    model = Article
    fields = ["title", "body"]
    success_url = "/articles/"
class ArticleUpdateView(UpdateView):                    # edit form + save
    model = Article
    fields = ["title", "body"]
class ArticleDeleteView(DeleteView):                    # confirm + delete
    model = Article
    success_url = "/articles/"
```

இந்த ஐந்து பொதுவான காட்சிகள் முழு CRUD வாழ்க்கை சுழற்சியையும் உள்ளடக்குகின்றன — பட்டியல், விவரம், உருவாக்கு, புதுப்பி, நீக்கு — ஒவ்வொன்றும் மிகக் குறைந்த குறியீடுடன். Django வடிவ உருவாக்கம், சரிபார்ப்பு, சேமிப்பு, மற்றும் வழங்குதலை கையாளுகிறது.

## முறை மேலெழுதல் மற்றும் mixins மூலம் தனிப்பயனாக்குதல்

```python
class ArticleListView(ListView):
    model = Article

def get_queryset(self):                          # override to customize the query
        return Article.objects.filter(published=True).order_by("-created_at")

def get_context_data(self, **kwargs):            # add extra context
        context = super().get_context_data(**kwargs)
        context["categories"] = Category.objects.all()
        return context

# MIXINS add reusable behavior across views
from django.contrib.auth.mixins import LoginRequiredMixin
class ArticleCreateView(LoginRequiredMixin, CreateView):   # require login
    model = Article
    fields = ["title", "body"]
```

CBVs குறிப்பிட்ட முறைகளை மேலெழுதுவதன் மூலம் தனிப்பயனாக்கப்படுகிறது (`get_queryset`, `get_context_data`, `form_valid`) மற்றும் **mixins** உடன் உட்சேர்க்கப்படுகிறது (எ.கா. `LoginRequiredMixin`) மீண்டும் பயன்படுத்தக்கூடிய குறுக்கு-வெட்டு நடத்தைக்கு — செயல்பாடுகளை விட முக்கிய மீண்டும் பயன்படுத்துவதன் நன்மை.

## CBV மற்றும் FBV ஒப்பந்தம்

```text
Generic CBVs → minimal code for STANDARD CRUD patterns; reusable via inheritance/mixins
FBVs         → more explicit and readable for CUSTOM/complex logic; easier for beginners
→ Use generic CBVs for standard cases; FBVs (or detailed CBVs) for unusual logic.
  Many teams use both depending on the situation.
```

## இது ஏன் முக்கியமானது

வகுப்பு-அடிப்படையிலான மற்றும் பொதுவான காட்சிகள் மீண்டும் உள்ள குறியீடைக் குறைப்பதற்கும் மீண்டும் பயன்படுத்துவதை ஊக்குவிப்பதற்கும் ஒரு முக்கியமான Django அம்சம், குறிப்பாக மிகவும் பொதுவான CRUD செயல்பாடுகளுக்கு பெரும்பாலான வலை பயன்பாடுகளுக்கு தேவை.

அவற்றைப் புரிந்துகொள்வது மூல்யமானது কாரணம் **பொதுவான காட்சிகள்** (`ListView`, `DetailView`, `CreateView`, `UpdateView`, `DeleteView`) நிலையான வடிவங்களைச் செயல்படுத்துகின்றன — பதிவுகளைப் பட்டியலிடுதல், விவரங்களைக் காட்டுதல், மற்றும் உருவாக்கு/புதுப்பி/நீக்கு வடிவங்களைக் கையாளுதல் — ஒவ்வொன்றிலும் சில வரிகளுடன், இதில் ஒரு செயல்பாடு-அடிப்படையிலான காட்சி மிகப்பெரிய மீண்டும் உள்ள குறியீடு தேவைப்படும் (பொருட்களைப் பெறுதல், வடிவங்களை உருவாக்குதல், சரிபார்ப்பு, சேமிப்பு, வழங்குதல்).

இது பெரும்பாலான பொதுவான Django பயன்பாடுகளை உருவாக்கும் ரொட்டி-மற்றும்-வெண்ணெய் CRUD திரைக்களுக்கான ஒரு முக்கிய உৎপাদনத்திறன் வெற்றி.

வகுப்பு-அடிப்படையிலான அணுகுமுறை **பரம்பரை மற்றும் mixins மூலம் மீண்டும் பயன்படுத்துவதையும்** செயல்படுத்துகிறது — குறிப்பிட்ட முறைகளை மேலெழுதுவதன் மூலம் நடத்தையை தனிப்பயனாக்குகிறீர்கள் (`get_queryset`, `get_context_data`) மற்றும் mixins மூலம் குறுக்கு-வெட்டு கவலைகளை உட்சேர்க்குகிறீர்கள் (நிச்சயிக்கு `LoginRequiredMixin` அங்கீகாரத்தின் மீது), பொதுவான தர্க்கத்தை காட்சிகள் முழுவதும் DRY ஆக வைத்திருக்கிறீர்கள்.

பொதுவான காட்சி தொகுப்பு, CBVs ஐ எவ்வாறு தனிப்பயனாக்குவது, mixins எவ்வாறு செயல்படுகிறது, மற்றும் — முக்கியமாக — **CBVs மற்றும் FBVs இடையே ஒப்பந்தம்** (நிலையான வடிவங்களுக்கு பொதுவான CBVs; தனிப்பயனாக அல்லது சிக்கலான தர্க்கத்திற்கு செயல்பாடு-அடிப்படையிலான காட்சிகள் இதில் தெளிவுத்திற்கு தேற்றிற்று) என்பது Django பயன்பாடுகளை திறம்பட உருவாக்க கடைப்பிடிக்கக்கூடிய அறிவு.

ஒவ்வொரு சூழ்நிலைக்கும் சரியான அணுகுமுறையைத் தேர்ந்தெடுப்பது, மற்றும் பொதுவான காட்சிகளை CRUD ஐ மீண்டும் கண்டுபிடிக்க வேண்டாதவாறு பயன்படுத்துவது, உৎপাদக Django வளர்ச்சியின் ஒரு பண்பு மற்றும் நிஜ திட்டங்களில் அடிக்கடி-பொருந்தக்கூடிய விஷயம்.