---
title: "Próiseáil Amharc Coinníoll"
version: 6.1
locale: ga
source: https://docs.djangoproject.com/ga/6.1/topics/conditional-view-processing/
canonical: https://djangodocs.dev/ga/6.1/topics/conditional-view-processing/
---
# Próiseáil Amharc Coinníoll

Is féidir le cliaint HTTP roinnt ceanntásca a sheoladh chun insint don fhreastalaí faoi chóipeanna d'acmhainn a chonaic siad cheana féin. Úsáidtear é seo go coitianta agus leathanach gréasáin á aisghabháil (ag baint úsáide as iarratas HTTP ```GET ``) chun na sonraí go léir a sheachaint le haghaidh rud atá aisghabháilte an cliant cheana féin. Mar sin féin, is féidir na ceanntásca céanna a úsáid le haghaidh gach modh HTTP (`POST ``, `PUT```, DELETE\`, srl.).

I gcás gach leathanach (freagra) a sheolann Django ar ais ó radharc, d'fhéadfadh sé dhá cheannteideal HTTP a sholáthar: an ceannteideal `Etag` agus an ceannteideal `` `Last-Modified ``. Tá na ceanntásca seo roghnach ar fhreagairtí HTTP. Is féidir iad a shocrú le d'fheidhm amharc, nó is féidir leat brath ar an: class: ~django.middleware.http.ConditionalGetMiddleware middleware chun an ceannteideal `Etag` a shocrú.

When the client next requests the same resource, it might send along a header
such as either [**If-Modified-Since**](https://datatracker.ietf.org/doc/html/rfc9110.html#section-13.1.3) or
[**If-Unmodified-Since**](https://datatracker.ietf.org/doc/html/rfc9110.html#section-13.1.4), containing the date of the
last modification time it was sent, or either [**If-Match**](https://datatracker.ietf.org/doc/html/rfc9110.html#section-13.1.1) or [**If-None-Match**](https://datatracker.ietf.org/doc/html/rfc9110.html#section-13.1.2),
containing the last `ETag` it was sent. If the current version of the page
matches the `ETag` sent by the client, or if the resource has not been
modified, a 304 status code can be sent back, instead of a full response,
telling the client that nothing has changed. Depending on the header, if the
page has been modified or does not match the `ETag` sent by the client, a 412
status code (Precondition Failed) may be returned.

Nuair a theastaíonn rialú níos mionghráite uait féadfaidh tú feidhmeanna próiseála coinníollach in aghaidh amharc a úsáid.

## An maisitheoir `coinníoll`

Uaireanta (i ndáiríre, go minic) is féidir leat feidhmeanna a chruthú chun an luach: rfc: EtaG \<9110 #section -8.8.3\> nó an t-am deireanach modhnaithe d'acmhainn a ríomh go tapa, gan gá duit na ríomhanna go léir a theastaíonn chun an radharc iomlán a thógáil. Is féidir le Django na feidhmeanna seo a úsáid ansin chun rogha “fóirithint luath” a sholáthar don phróiseáil amharc. Ag rá leis an gcliant nár modhnaíodh an t-ábhar ón iarratas deireanach, b'fhéidir.

Cuirtear an dá fheidhm seo ar aghaidh mar pharaiméadair chuig an maisitheoir django.views.decorators.http.condition\`. Úsáideann an maisitheoir seo an dá fheidhm (ní gá duit ach ceann amháin a sholáthar, mura féidir leat an dá chainníocht a ríomh go héasca agus go tapa) chun oibriú amach má mheaitseálann na ceannteidil san iarratas HTTP iad siúd ar an acmhainn. Mura n-oireann siad, caithfear cóip nua den acmhainn a ríomh agus glaoch ar do ghnáthradharc.

Tá cuma seo ar shíniú an maisitheora `coinníoll`:

```
condition(etag_func=None, last_modified_func=None)
```

Cuirfear an dá fheidhm, chun an eTag agus an t-am modhnaithe deireanach a ríomh, ar an réad ```iarraidh` atá ag teacht isteach agus na paraiméadair chéanna, san ord céanna, mar an fheidhm amharc atá á gcabhrú leo a fhilleadh. Ba chóir don fheidhm a rith ``last_modified_func``` luach caighdeánach dáta-ama a thabhairt ar ais ag sonrú an uair dheireanach a mhodhnaíodh an acmhainn, nó `None` mura bhfuil an acmhainn ann. \<9110 #section -8.8.3\>Ba chóir don fheidhm a chuirtear chuig an maisitheoir `etag` sreang a thabhairt ar ais a léiríonn na:rfc: Etag don acmhainn, nó None mura bhfuil sé ann.

Socraíonn an maisitheoir na ceannteidil `Etag` agus `Last-Modified` ar an bhfreagra mura bhfuil siad socraithe ag an dearcadh cheana féin agus má tá modh an iarratais sábháilte (GET\` nó HEAD\`).

Is dócha gur fearr a mhíniú le sampla an ghné seo a úsáid go húsáideach. Cuir i gcás go bhfuil an péire samhlacha seo agat, a léiríonn córas blag beag:

```
import datetime
from django.db import models

class Blog(models.Model): ...

class Entry(models.Model):
    blog = models.ForeignKey(Blog, on_delete=models.CASCADE)
    published = models.DateTimeField(default=datetime.datetime.now)
    ...
```

Mura n-athraíonn an leathanach tosaigh, ag taispeáint na hiontrálacha blag is déanaí, ach nuair a chuireann tú iontráil nua blag leis, is féidir leat an t-am deireanach modhnaithe a ríomh go han-tapa. Teastaíonn an dáta foilsithe is déanaí uait do gach iontráil a bhaineann leis an bhlag sin. Bealach amháin chun é seo a dhéanamh ná:

```
def latest_entry(request, blog_id):
    return Entry.objects.filter(blog=blog_id).latest("published").published
```

Is féidir leat an fheidhm seo a úsáid ansin chun leathanach gan athrú a bhrath go luath do d'amharc leathanaigh tosaigh:

```
from django.views.decorators.http import condition

@condition(last_modified_func=latest_entry)
def front_page(request, blog_id): ...
```

> **Bí cúramach le hord na mhaisitheoirí**
>
> Nuair a fhilleann coinníoll () freagra coinníollach, scipeánfar aon mhaisitheoirí faoin bhfois agus ní bheidh feidhm acu leis an bhfreagra. Dá bhrí sin, caithfidh aon mhaisitheoirí a gcaithfidh iarratas a dhéanamh ar an bhfreagra radharc rialta agus ar fhreagra coinníollach a bheith os cionn \`\`coinníoll () \`. \<9110 #section -15.4.5\>Go háirithe, ba chóir go dtiocfadh :func: ~django.views.decorators.vary.vary\_on\_cookie, :func: ~django.views.decorators.vary.vary\_on\_headers, agus:func: ~django.views.decorators.cache.cache\_control toisc: 110RFC 'éilíonn sé go mbeidh na ceanntásca a leagann siad i láthair ar 304 freagra.

## Aicearraí chun luach amháin a ríomh

Mar riail ghinearálta, más féidir leat feidhmeanna a sholáthar chun \* an eTag agus an t-am deireanach modhnaithe a ríomh, ba cheart duit é sin a dhéanamh. Níl a fhios agat cé na ceanntásca a sheolfaidh aon chliant HTTP ar leith chugat, mar sin bí réidh chun an dá rud a láimhseáil. Mar sin féin, uaireanta ní furasta ach luach amháin a ríomh agus soláthraíonn Django maisiúcháin nach ndéanann ach eTag nó ríomhanna modhnaithe deiridh amháin.

Rinne na maisitheoirí `django.views.decorators.http.etag` agus `django.views.decorators.http.last_modified` an cineál céanna feidhmeanna leis an maisitheoir condition\`. Is iad seo a gcuid sínithe:

```
etag(etag_func)
last_modified(last_modified_func)
```

D'fhéadfaimis an sampla níos luaithe a scríobh, nach n-úsáideann ach feidhm modhnaithe deireanach, ag baint úsáide as ceann de na maisitheoirí seo:

```
@last_modified(latest_entry)
def front_page(request, blog_id): ...
```

... nó:

```
def front_page(request, blog_id): ...

front_page = last_modified(latest_entry)(front_page)
```

### Úsáid `coinníoll` agus an dá choinníoll á thástáil

D'fhéadfadh go mbeadh cuma níos deise ag daoine áirithe triail a bhaint as na maisitheoirí `etag` agus last\_modified a shlánú más mian leat an dá réamhchoinníoll a thástáil. Mar sin féin, bheadh iompar mícheart mar thoradh air seo.

```
# Bad code. Don't do this!
@etag(etag_func)
@last_modified(last_modified_func)
def my_view(request): ...

# End of bad code.
```

Níl a fhios ag an gcéad maisitheoir aon rud faoin dara ceann agus d'fhéadfadh sé freagra a thabhairt nach ndéantar an freagra a mhodhnú fiú má chinnfeadh an dara maisitheoirí a mhalairt. Úsáideann an maisitheoir `coinníoll` an dá fheidhm aisghlaonna ag an am céanna chun an gníomh ceart atá le déanamh a oibriú amach.

## Ag baint úsáide as na maisitheoirí le modhanna HTTP eile

Tá an maisitheoir `coinníoll` úsáideach le haghaidh níos mó ná iarratais `GET` agus HEAD\` amháin (tá iarratais `HEAD` mar an gcéanna le `GET` sa chás seo). Is féidir é a úsáid freisin chun seiceáil a sholáthar d'iarratais ```POST ``, `PUT``` agus `DELETE`. Sna cásanna seo, ní é an smaoineamh freagra “neamh-mhodhnaithe” a thabhairt ar ais, ach a rá don chliant gur athraíodh an acmhainn atá siad ag iarraidh a athrú idir an dá linn.

Mar shampla, smaoinigh ar an malartú seo a leanas idir an cliant agus an freastalaí:

1. Iarratann cliant `/foo/`.
2. Freagraíonn freastalaí le ábhar áirithe le ETag de "abcd1234".
3. Seolann cliant iarratas HTTP `PUT` chuig `/foo/` chun an acmhainn a nuashonrú. Seolann sé ceanntásc If-Match: “abcd1234" freisin chun an leagan atá á iarraidh a nuashonrú a shonrú.
4. Seiceálann freastalaí chun a fháil amach an bhfuil an acmhainn athraithe, tríd an eTag a ríomh ar an mbealach céanna a dhéanann sé d'iarratas GET (ag baint úsáide as an bhfeidhm chéanna). Má athraíodh an acmhainne\*\*, cuirfidh sé cód stádais 412 ar ais, rud a chiallaíonn “theip ar réamhchoinníoll”.
5. Seolann an cliant iarratas ```GET ``chuig `/foo/```, tar éis freagra 412 a fháil, leagan nuashonraithe den ábhar a aisghabháil sula ndéantar é a nuashonrú.

Is é an rud tábhachtach a thaispeánann an sampla seo ná gur féidir na feidhmeanna céanna a úsáid chun luachanna eTag agus modhnú deireanacha a ríomh i ngach cás. Déanta na fírinne, ba cheart duit\*\* na feidhmeanna céanna a úsáid, ionas go gcuirfear na luachanna céanna ar ais gach uair.

> **Ceanntásca bailíochtaithe le modhanna iarratais neamhshábhá**
>
> Ní shocraíonn an maisitheoir `coinníoll` ach ceannteidil bailíochtaithe (`Etag` agus `Last-Modified`) le haghaidh modhanna HTTP sábháilte, ie `GET` agus `HEAD`. Más mian leat iad a thabhairt ar ais i gcásanna eile, socraigh iad i do thuairim. Féach: RFC: 9110 #section -9.3.4 chun foghlaim faoin idirdhealú idir ceanntásc bailíochtaithe a shocrú mar fhreagra ar iarratais a rinneadh le PUT\` i gcoinne POST .

## Comparáid le próiseáil choinníollach middleware

Soláthraíonn Django láimhseáil coinníollach `GET` via: class: django.middleware.http.conditionalGetMiddleware. Cé go bhfuil sé oiriúnach do go leor cásanna, tá teorainneacha ag an middleware maidir le hardúsáid:

- Cuirtear i bhfeidhm go domhanda ar gach tuairim i do thionscadal.
- Ní shábhálann sé tú ón bhfreagra a ghiniúint, rud a d'fhéadfadh a bheith daor.
- Níl sé oiriúnach ach le haghaidh iarratais HTTP `GET`.

Ba chóir duit an uirlis is oiriúnaí a roghnú do d'fhadhb ar leith anseo. Má tá bealach agat chun eTags agus amanna modhnaithe a ríomh go tapa agus má thógann dearcadh éigin tamall an t-ábhar a ghiniúint, ba cheart duit smaoineamh ar an maisitheoir `coinníoll` a thuairiscítear sa doiciméad seo a úsáid. Má ritheann gach rud go gasta cheana féin, cloí leis an meán-earraí a úsáid agus laghdófar méid tráchta líonra a sheoltar ar ais chuig na cliaint fós mura bhfuil an dearcadh athraithe.