---
title: "Réamhrá ar thuairimí rangbhunaithe"
version: 6.1
locale: ga
source: https://docs.djangoproject.com/ga/6.1/topics/class-based-views/intro/
canonical: https://djangodocs.dev/ga/6.1/topics/class-based-views/intro/
---
# Réamhrá ar thuairimí rangbhunaithe

Soláthraíonn tuairimí rang-bhunaithe bealach malartach chun tuairimí a chur i bhfeidhm mar rudaí Python in ionad Ní chuireann siad in ionad tuairimí bunaithe ar fheidhm, ach tá difríochtaí agus buntáistí áirithe acu i gcomparáid le tuairimí feidhmion-

- Is féidir aghaidh a thabhairt ar eagrú cód a bhaineann le modhanna HTTP ar leith (GET\`, POST \`, srl.) trí mhodhanna ar leithligh in ionad brainse coinníollach.
- Is féidir teicnící dírithe ar réad mar mheascáin (oidhreacht iolrach) a úsáid chun cód a fhachtóireacht i gcomhpháirteanna in-athúsá

## Caidreamh agus stair tuairimí cineálacha, tuairimí rang-bhunaithe, agus tuairimí cineálacha aicmbunaithe

Sa tús ní raibh ach an conradh feidhme amharc ann, rith Django do fheidhm an:class: ~django.http.httpRequest agus bhíothas ag súil leis an:class: ~django.http.httpResponse. Ba é seo méid an méid a chuir Django ar fáil.

Go luath aithníodh go raibh nathanna agus patrúin choitianta le fáil i bhféachaint ar fhorbairt. Tugadh tuairimí cineálacha bunaithe ar fheidhm isteach chun na patrúin seo a thaibhriú agus chun forbairt radhairc a éascú

Is í an fhadhb le tuairimí cineálacha bunaithe ar fheidhm ná cé go gclúdaigh siad na cásanna simplí go maith, ní raibh aon bhealach ann iad a leathnú nó a shaincheapadh níos faide ná roinnt roghanna cumraíochta, ag teorannú lena n-úsáideacht i go leor feidhmchlár

Cruthaíodh tuairimí cineálacha rang-bhunaithe leis an gcuspóir céanna le tuairimí cineálacha feidhmiúbhunaithe, chun forbairt radhairc a dhéanamh níos Mar sin féin, soláthraíonn an bealach a chuirtear an réiteach i bhfeidhm, trí mheascáin a úsáid, foireann uirlisí a dtagann tuairimí cineálacha aicmbunaithe níos leathnaithe agus níos solúbtha ná a gcomhghleacaithe feidhmiúbhunaithe.

Má rinne tú triail as tuairimí cineálacha bunaithe ar fheidhm san am atá thart agus má fuair tú easpa iad, níor cheart duit smaoineamh ar thuairimí cineálacha aicmbunaithe mar choibhéis aicme-bhunaithe, ach mar chur chuige úr chun na fadhbanna bunaidh a bhí i gceist le tuairimí cineálacha a réiteach.

Tógtar an tacar uirlisí bunaicmí agus meascáin a úsáideann Django chun tuairimí cineálacha aicmbunaithe a thógáil chun an solúbthacht is mó, agus mar sin tá go leor crúcaí acu i bhfoirm cur i bhfeidhm agus tréithe modhanna réamhshocraithe nach dócha go mbeidh imní ort sna cásanna úsáide is simplí. Mar shampla, in ionad tú a theorannú do thréith rang-bhunaithe do form\_class\`, úsáideann an cur i bhfeidhm modh `get_form`, a ghlaonn modh `get_form_class`, a thugann tréith `form_class` ar ais ina chur i bhfeidhm réamhshocraithe tréith form\_class\`. Tugann sé seo roinnt roghanna duit chun an fhoirm atá le húsáid a shonrú, ó thréith, go crúca lán-dinimiciúil, inghlaonta. Is cosúil go gcuireann na roghanna seo castacht log le haghaidh cásanna simplí, ach gan iad, bheadh dearaí níos airde teoranta.

## Ag baint úsáide as tuairimí bunaithe

Ag croílár, ligeann radharc rang-bhunaithe duit freagairt a thabhairt do mhodhanna éagsúla iarratais HTTP le modhanna éagsúla scála ranga, in ionad le cód brainse coinníollach taobh istigh de fheidhm amharc amháin.

Mar sin, cá mbeadh cuma ar an gcód chun HTTP `GET` a láimhseáil i bhfeidhm amharc:

```
from django.http import HttpResponse

def my_view(request):
    if request.method == "GET":
        # <view logic>
        return HttpResponse("result")
```

I dtuairim rang-bhunaithe, bheadh sé seo mar seo a leanas:

```
from django.http import HttpResponse
from django.views import View

class MyView(View):
    def get(self, request):
        # <view logic>
        return HttpResponse("result")
```

Toisc go bhfuil réiteach URL Django ag súil leis an iarraidh agus na hargóintí gaolmhara a sheoladh chuig feidhm inghlaonta, ní rang, tá modh ranga ag tuairimí rang-bhunaithe: meth: ~django.views.generic.base.view.as\_view a thugann feidhm ar féidir a ghlaoch nuair a thagann iarratas ar URL a mheaitseann an patrún gaolmhar. Cruthaíonn an fheidhm sampla den rang, glaoirí:meth: ~django.views.generic.base.view.setup chun a thréithe a thionscnamh, agus ansin glaonn sé ai:meth: ~Django.Views.Generic.Base.View.Dispatch \`modh. Féachann \`\`seolach\` ar an iarratas chun a chinneadh an bhfuil sé `GET`, POST \`, srl., agus athsheachadann sé an t-iarratas chuig modh meaitseála má tá ceann sainmhínithe, nó ardaíonn sé: class: ~django.http.httpResponseNotAllowed mura bhfuil:

```
# urls.py
from django.urls import path
from myapp.views import MyView

urlpatterns = [
    path("about/", MyView.as_view()),
]
```

Is fiú a thabhairt faoi deara go bhfuil an méid a thugann do mhodh comhionann leis an méid a fhilleann tú ó radharc feidhmiúbhunaithe, eadhon cineál éigin de:class: ~django.http.httpResponse. Ciallaíonn sé seo go bhfuil rudaí:doc: http shortcuts nó:class: ~django.template.response.templateResponse \</topics/http/shortcuts\> bailí le húsáid taobh istigh de radharc rang-bhunaithe.

Cé nach dteastaíonn aon tréithe ranga ag teastáil ó radharc íosta bunaithe ar rang chun a phost a chomhlíonadh, tá tréithe ranga úsáideach i go leor dearaí rang-bhunaithe, agus tá dhá bhealach ann chun tréithe ranga a chumrú nó a shocrú.

Is é an chéad cheann an bealach caighdeánach Python chun tréithe agus modhanna a fho-aicmiú agus a shárú sa fho-rang. Mar sin má bhí tréith beannachtaí mar seo ag do rang tuismitheora:

```
from django.http import HttpResponse
from django.views import View

class GreetingView(View):
    greeting = "Good Day"

    def get(self, request):
        return HttpResponse(self.greeting)
```

Is féidir leat é sin a shárú i bhfo-aicme:

```
class MorningGreetingView(GreetingView):
    greeting = "Morning to ya"
```

Rogha eile is ea tréithe ranga a chumrú mar argóintí eochairfhocal chuig an nglao:meth: ~django.views.generic.base.view.as\_view sa urlConf:

```
urlpatterns = [
    path("about/", GreetingView.as_view(greeting="G'day")),
]
```

> **Note**
>
> Cé go ndéantar do rang le haghaidh gach iarratas a sheoltar chuige, ní chumraítear tréithe ranga trí:meth: ~django.views.generic.base.view.as\_view pointe iontrála ach uair amháin ag an am a allmhairítear d'URLanna.

## Meascáin a úsáid

Is cineál oidhreachta iolracha iad meascáin inar féidir iompraíochtaí agus tréithe ranganna ilthuismitheoirí a chomhcheangal.

Mar shampla, sna tuairimí cineálacha bunaithe ar rang tá meascán ar a dtugtar: class: ~django.views.generic.base.templateResponseMixin a bhfuil príomhchuspóir aige an modh a shainiú: meth: ~Django.Views.Generic.Base.TemplateResponsemixin.Render\_to\_Response. Nuair a dhéantar é a chomhcheangal le hiompar an aicme bonn:class: ~django.views.Generic.Base.View, is é an toradh: aicme ~Django.Views.Generic.Base.TemplateView a sheolfaidh iarratais chuig na modhanna meaitseála iomchuí (iompar atá sainmhínithe sa rang `View`), agus a bhfuil a:meth: ~Django.Views.Geners.Generic.Views.Generic.Views.Generic.Views.Generic.Views.Generic.Views.Generic.Views.Generic.Views.Generic.Views.Generic.Views.Generic.Views.Generic.Views.Modh.base.TemplateResponseMixin.Render\_to\_Response a úsáideann a:attr: ~Django.Views.Generic.Base.TemplateResponseMixin.Template\_Name tréith chun a:class: ~Django.Template.Response.TemplateResponse réad (iompar atá sainmhínithe sa \`\` TeimpléadResponseMixin ).

Is bealach den scoth iad Mixins chun cód a athúsáid ar fud ranganna éagsúla, ach tagann roinnt costas leo. An níos mó a scaiptear do chód i measc meascáin, is deacra a bheidh sé rang leanaí a léamh agus a fhios a fháil amach cad é go díreach atá á dhéanamh aige, agus is deacra a bheidh sé a fháil amach cé na modhanna as a bhfuil meascáin le frithsheasmhú má tá tú ag fo-aicmiú rud a bhfuil crann oidhreachta domhain aige.

Tabhair faoi deara freisin nach féidir leat oidhreacht ach ó dhearcadh cineálach amháin - is é sin, ní fhéadfaidh ach rang tuismitheora amháin oidhreacht ó:class: ~django.views.Generic.Base.View agus ba chóir go mbeadh an chuid eile (más ann) ina meascáin. Ag iarraidh oidhreacht a dhéanamh ó níos mó ná aicme amháin a fhaigheann oidhreacht ó `View` \- mar shampla, ag iarraidh foirm a úsáid ag barr liosta agus comhcheangail:class: ~django.views.list.Generic.Generic.Edit.ProcessFormView agus:class: ~Django.Views.Generic.ListView \- ní oibreoidh sé mar a bhíothas ag súil leis.

## Foirmeacha a láimhseáil le tuairimí rang-

D'fhéadfadh sé go mbeadh cuma mar seo ar dhearcadh bunúsach feidhmiúbhunaithe a láimhseálann

```
from django.http import HttpResponseRedirect
from django.shortcuts import render

from .forms import MyForm

def myview(request):
    if request.method == "POST":
        form = MyForm(request.POST)
        if form.is_valid():
            # <process form cleaned data>
            return HttpResponseRedirect("/success/")
    else:
        form = MyForm(initial={"key": "value"})

    return render(request, "form_template.html", {"form": form})
```

D'fhéadfadh cuma ar radharc den chineál céanna bunaithe ar rang:

```
from django.http import HttpResponseRedirect
from django.shortcuts import render
from django.views import View

from .forms import MyForm

class MyFormView(View):
    form_class = MyForm
    initial = {"key": "value"}
    template_name = "form_template.html"

    def get(self, request, *args, **kwargs):
        form = self.form_class(initial=self.initial)
        return render(request, self.template_name, {"form": form})

    def post(self, request, *args, **kwargs):
        form = self.form_class(request.POST)
        if form.is_valid():
            # <process form cleaned data>
            return HttpResponseRedirect("/success/")

        return render(request, self.template_name, {"form": form})
```

Is cás íosta é seo, ach is féidir leat a fheiceáil go mbeadh an rogha agat ansin an dearcadh seo a shaincheapadh trí aon cheann de na tréithe ranga a shárú, m.sh. `form_class`, trí chumraíocht URLConf, nó ceann amháin nó níos mó de na modhanna (nó an dá cheann!) a fho-aicmiú agus a shárú.

## Tuairimí rangbhunaithe a mhaisiú

Níl síneadh tuairimí rang-bhunaithe teoranta do mheascáin a úsáid. Is féidir leat maisitheoirí a úsáid freisin. Ós rud é nach feidhmeanna iad tuairimí rang-bhunaithe, oibríonn iad a mhaisiú go difriúil ag brath ar an bhfuil tú ag úsáid as\_view () nó ag cruthú fo-aicme.

### Maisiú i URLConf

Is féidir leat tuairimí rang-bhunaithe a choigeartú trí thoradh an modh:meth: ~Django.Views.Generic.Base.View.as\_View a mhaisiú. Is é an áit is éasca chun é seo a dhéanamh sa URLConf áit a n-úsáideann tú do thuairim:

```
from django.contrib.auth.decorators import login_required, permission_required
from django.views.generic import TemplateView

from .views import VoteView

urlpatterns = [
    path("about/", login_required(TemplateView.as_view(template_name="secret.html"))),
    path("vote/", permission_required("polls.can_vote")(VoteView.as_view())),
]
```

Cuireann an cur chuige seo an maisitheoir i bhfeidhm ar bhonn gach cás. Más mian leat gach cás de radharc a mhaisiú, ní mór duit cur chuige difriúil a ghlacadh.

### Maisiú an rang

Chun gach cás de radharc rangbhunaithe a mhaisiú, ní mór duit sainmhíniú an ranga féin a mhaisiú. Chun seo a dhéanamh cuireann tú an maisitheoir i bhfeidhm ar an modh:: ~Django.Views.Generic.Base.View.Dispatch den rang.

Níl modh ar rang mar an gcéanna le feidhm neamhspleách, mar sin ní féidir leat maisitheoir feidhme a chur i bhfeidhm ar an modh - ní mór duit é a athrú go maisitheoir modh ar dtús. Athraíonn an maisitheoir method\_decorator\` maisitheoir feidhme go maisitheoir modh ionas gur féidir é a úsáid ar mhodh sampla. Mar shampla:

```
from django.contrib.auth.decorators import login_required
from django.utils.decorators import method_decorator
from django.views.generic import TemplateView

class ProtectedView(TemplateView):
    template_name = "secret.html"

    @method_decorator(login_required)
    def dispatch(self, *args, **kwargs):
        return super().dispatch(*args, **kwargs)
```

Nó, níos gonta, is féidir leat an rang a mhaisiú ina ionad sin agus ainm an mhodha atá le maisiú a chur ar aghaidh mar an argóint eochairfhocal ainm :

```
@method_decorator(login_required, name="dispatch")
class ProtectedView(TemplateView):
    template_name = "secret.html"
```

Má tá tacar de mhaisitheoirí coitianta agat a úsáidtear i roinnt áiteanna, is féidir leat liosta nó tuple maisitheoirí a shainiú agus é seo a úsáid in ionad method\_decorator () a ghlaoch arís agus arís eile. Tá an dá rang seo coibhéiseach:

```
decorators = [never_cache, login_required]

@method_decorator(decorators, name="dispatch")
class ProtectedView(TemplateView):
    template_name = "secret.html"

@method_decorator(never_cache, name="dispatch")
@method_decorator(login_required, name="dispatch")
class ProtectedView(TemplateView):
    template_name = "secret.html"
```

Próiseálfaidh na maisitheoirí iarratas san ord a chuirtear chuig an maisitheoir iad. Sa sampla, próiseálfaidh ```never_cache () ``an t-iarratas roimh ``login_required ()```.

Sa sampla seo, beidh cosaint logála isteach ag gach cás de ```ProtectedView`. Úsáideann na samplaí seo ``login_required```, áfach, is féidir an t-iompar céanna a fháil trí:class: ~django.contrib.auth.mixins.loginrequiredMixin a úsáid.

> **Note**
>
> Téann `method_decorator` `*args` agus `**kwargs` mar pharaiméadair chuig an modh maisithe ar an rang. Mura nglacann do mhodh le tacar comhoiriúnach paraiméadair ardóidh sé eisceacht TypeError\`.