---
title: "Creat taisce Django"
version: 6.1
locale: ga
source: https://docs.djangoproject.com/ga/6.1/topics/cache/
canonical: https://djangodocs.dev/ga/6.1/topics/cache/
---
# Creat taisce Django

Is é trádáil bhunúsach i láithreáin ghréasáin dinimiciúla, go maith, tá siad dinimiciúil. Gach uair a iarrann úsáideoir leathanach, déanann an freastalaí gréasáin gach cineál ríomhanna - ó cheisteanna bunachar sonraí go rindreáil teimpléad go loighic ghnó - chun an leathanach a fheiceann cuairteoir do shuíomh a chruthú. Tá sé seo i bhfad níos costasaí, ó pheirspictíocht las-phróiseála, ná do shocrú caighdeánach freastalaí freastalaí léamh comhad lasmuigh den chóras comhaid.

For most web applications, this overhead isn't a big deal. Most web
applications aren't `washingtonpost.com` or `slashdot.org`; they're
small-to medium-sized sites with so-so traffic. But for medium- to high-traffic
sites, it's essential to cut as much overhead as possible.

Sin an áit a dtagann caching isteach.

Is é rud éigin a thaisceadh ná toradh ríofa daor a shábháil ionas nach mbeidh ort an ríomh a dhéanamh an chéad uair eile. Seo roinnt pseudocode a mhíníonn conas a oibreodh sé seo le haghaidh leathanach gréasáin a ghintear go dinimiciúil:

```text
given a URL, try finding that page in the cache
if the page is in the cache:
    return the cached page
else:
    generate the page
    save the generated page in the cache (for next time)
    return the generated page
```

Tagann Django le córas taisce láidir a ligeann duit leathanaigh dhinimiciúla a shábháil ionas nach gá iad a ríomh do gach iarratas. Ar mhaithe le háisiúlacht, cuireann Django leibhéil éagsúla gráinneachta taisce ar fáil: Is féidir leat aschur radhairc ar leith a thaisceadh, ní féidir leat ach na píosaí atá deacair a tháirgeadh a thaisceadh, nó is féidir leat do shuíomh iomlán a thaisceadh.

Oibríonn Django go maith freisin le taiscí “íossrutha”, mar shampla Squid\`\< <http://www.squid-cache.org/>\> \_ agus taiscí brabhsálaí-bhunaithe. Is iad seo na cineálacha taiscí nach ndéanann tú rialú go díreach ach ar féidir leat leideanna a sholáthar dóibh (trí cheanntásca HTTP) faoi na codanna de do shuíomh ba chóir a stóráil, agus conas.

> **See also**
>
> Míníonn an:ref: Fealsúnacht dearaidh Cre \<cache-design-philosophy\>at Cache cúpla cinntí dearaidh an chreata.

## An taisce a chur ar bun

Éilíonn an córas taisce méid beag socraithe. Eadhon, caithfidh tú a insint dó cá háit ar chóir go gcónaíonn do shonraí taiscéadaithe - cibé acu i mbunachar sonraí, ar an gcóras comhaid nó go díreach i gcuimhne. Is cinneadh tábhachtach é seo a théann i bhfeidhm ar fheidhmíocht do taisce; sea, tá roinnt cineálacha taisce níos gasta ná a chéile.

Téann do rogha taisce sa socrú:setting: CACHES i do chomhad socruithe. Seo míniú ar na luachanna go léir atá ar fáil le haghaidh: socrú: CACHES.

### Memcached

Is freastalaí taisce go hiomlán bunaithe ar chuimhne é , a forbraíodh ar dtús chun ualaí arda a láimhseáil ag LiveJournal.com agus foinse oscailte ina dhiaidh sin ag Danga Interactive. Úsáideann suíomhanna mar Facebook agus Wikipedia é chun rochtain ar bhunachar sonraí a laghdú agus feidhmíocht an láithreáin a mhéadú go mór.

Ritheann Memcached mar démon agus leithdháiltear méid sonraithe RAM air. Níl le déanamh aige ach comhéadan tapa a sholáthar chun sonraí sa taisce a chur leis, a aisghabháil agus a scriosadh. Stóráiltear na sonraí go léir go díreach i gcuimhne, mar sin níl aon lasbhunachar sonraí nó úsáid chórais chomhad ann.

Tar éis duit Memcached féin a shuiteáil, beidh ort ceangailt Memcached a shuiteáil. Tá roinnt ceangail Python Memcached ar fáil; is iad an dá cheann a thacaíonn Django: pypi: pylibmc agus:pypi: pymemcache.

Chun Memcached a úsáid le Django:

- Socraigh: Socrú: BACKEND \`go \`\`Django.core.cache.backends.memcached.pymemcachecache\`\<CACHES-BACKEND\> nó `django.core.cache.backends.memcached.pylibmccache` (ag brath ar an gceangailt memcached roghnaithe agat)
- SOC:SET:SETING: LOCATION \<CACHES-LOCATION\>\`go luachanna \`\`ip: port \`, áit is é ip\` seoladh IP an daemon Memcached agus `port` an calafort ar a bhfuil Memcached ag rith, nó go luach `unix:path`, áit is é `path` an cosán chuig comhad soicéad Memcached Unix.

Sa sampla seo, tá Memcached ag rith ar chalafort localhost (127.0.0.1) 11211, ag baint úsáide as an cheangailteach pymemcache\`:

```
CACHES = {
    "default": {
        "BACKEND": "django.core.cache.backends.memcached.PyMemcacheCache",
        "LOCATION": "127.0.0.1:11211",
    }
}
```

Sa sampla seo, tá Memcached ar fáil trí chomhad soicéad áitiúil Unix: file: /tmp/memcached.sock ag baint úsáide as an ceangailt `pymemcache`:

```
CACHES = {
    "default": {
        "BACKEND": "django.core.cache.backends.memcached.PyMemcacheCache",
        "LOCATION": "unix:/tmp/memcached.sock",
    }
}
```

Gné den scoth amháin de Memcached is ea a chumas taisce a roinnt thar fhreastalaithe iolracha. Ciallaíonn sé seo gur féidir leat daemons Memcached a reáchtáil ar iliomad meaisíní, agus déileálfaidh an clár leis an ngrúpa meaisíní mar taisce\* aonair\*, gan gá luachanna taisce a dhúbailt ar gach meaisín. Ch \<CACHES-LOCATION\>un leas a bhaint as an ngné seo, cuir gach seoladh freastalaí san áireamh in:socrú: LOCATION , mar shreang teoranta leath-cholún nó camóg, nó mar liosta.

Sa sampla seo, roinntear an taisce thar chásanna Memcached atá ag rith ar sheoladh IP 172.19.26.240 agus 172.19.26.242, araon ar chalafort 11211:

```
CACHES = {
    "default": {
        "BACKEND": "django.core.cache.backends.memcached.PyMemcacheCache",
        "LOCATION": [
            "172.19.26.240:11211",
            "172.19.26.242:11211",
        ],
    }
}
```

Sa sampla seo a leanas, roinntear an taisce thar chásanna Memcached atá ag rith ar na seoltaí IP 172.19.26.240 (calafort 11211), 172.19.26.242 (calafort 11212), agus 172.19.26.244 (calafort 11213):

```
CACHES = {
    "default": {
        "BACKEND": "django.core.cache.backends.memcached.PyMemcacheCache",
        "LOCATION": [
            "172.19.26.240:11211",
            "172.19.26.242:11212",
            "172.19.26.244:11213",
        ],
    }
}
```

\<CACHES-OPTIONS\>De réir réamhshocraithe, socraíonn an cúltaca PymemCacheCache\` na roghanna seo a leanas (is féidir leat iad a shárú i d:setting: OPTIONS ):

```
"OPTIONS": {
    "allow_unicode_keys": True,
    "default_noreply": False,
    "serde": pymemcache.serde.pickle_serde,
}
```

Pointe deiridh faoi Memcached ná go bhfuil míbhuntáiste ag taiscáil cuimhne bunaithe: toisc go stóráiltear na sonraí taisceáilte i gcuimhne, caillfear na sonraí má thimpíonn do fhreastalaí. Is léir nach bhfuil cuimhne beartaithe le haghaidh stórála sonraí buan, mar sin ná bí ag brath ar chaching cuimhne mar an t-aon stóráil sonraí atá agat. Gan amhras, níor cheart *aon cheann* de na cúltaca caching Django a úsáid le haghaidh stórála buan - tá sé beartaithe go léir a bheith ina réitigh le haghaidh taiscéála, ní stóráil - ach cuirimid é seo in iúl anseo toisc go bhfuil caching bunaithe ar chuimhne go háirithe sealadach.

### Redis

Is bunachar sonraí in-chuimhne é  is féidir a úsáid le haghaidh taiscála. Chun tús a chur beidh freastalaí Redis ag teastáil uait ag rith go háitiúil nó ar mheaisín iargúlta.

Tar éis duit an freastalaí Redis a bhunú, beidh ort ceangail Python a shuiteáil do Redis. :pypi: Is é redis-py \<redis\>\`an ceangailt a thacaíonn Django go dúchasach. \<hiredis\>Moltar an pacáiste: pypi: hiredis-py a shuiteáil freisin.

Chun Redis a úsáid mar do chúltaca taisce le Django:

- \<CACHES-BACKEND\>Socraigh: socrú: BACKEND \`go \`\`Django.Core.Cache.Backends.Redis.RedisCache \`.
- Set [`LOCATION`](/ga/6.1/ref/settings/#std-setting-CACHES-LOCATION) to the URL pointing to your Redis
  instance, using the appropriate scheme. See the `redis-py` docs for
  [details on the available schemes](https://redis.readthedocs.io/en/stable/connections.html#redis.connection.ConnectionPool.from_url).

Mar shampla, má tá Redis ag rith ar chalafort localhost (127.0.0.1) 6379:

```
CACHES = {
    "default": {
        "BACKEND": "django.core.cache.backends.redis.RedisCache",
        "LOCATION": "redis://127.0.0.1:6379",
    }
}
```

Is minic a chosnaítear freastalaithe Redis le fíordheimhniú. D'fhonn ainm úsáideora agus pasfhocal a sholáthar, cuir iad sa SUÍOMH\` mar aon leis an URL:

```
CACHES = {
    "default": {
        "BACKEND": "django.core.cache.backends.redis.RedisCache",
        "LOCATION": "redis://username:password@127.0.0.1:6379",
    }
}
```

Má tá iolracha freastalaithe Redis curtha ar bun agat sa mhodh macasamhail, is féidir leat na freastalaithe a shonrú mar shreang teoranta leath-cholún nó camóg, nó mar liosta. Agus freastalaithe iolracha á úsáid agat, déantar oibríochtaí scríofa ar an gcéad fhreastalaí (ceannaire) Déantar oibríochtaí léite ar na freastalaithe eile (macasamhail) a roghnaítear go randamach:

```
CACHES = {
    "default": {
        "BACKEND": "django.core.cache.backends.redis.RedisCache",
        "LOCATION": [
            "redis://127.0.0.1:6379",  # leader
            "redis://127.0.0.1:6378",  # read-replica 1
            "redis://127.0.0.1:6377",  # read-replica 2
        ],
    }
}
```

### Cacháil bunachar sonraí

Is féidir le Django a chuid sonraí taiscéadaithe a stóráil i do bhunachar sonraí. Oibríonn sé seo is fearr má tá freastalaí bunachar sonraí tapa, innéacsaithe go maith agat.

Chun tábla bunachar sonraí a úsáid mar do chúltaca taisce:

- \<CACHES-BACKEND\>Socraigh: socrú: BACKEND \`go \`\`Django.core.cache.backends.db.databaseCache \`
- Socraigh: socrú: LOCATION \<CACHES-LOCATION\>\`go \`\`tablename\`, ainm an tábla bunachar sonraí. Is féidir leis an ainm seo a bheith cibé rud is mian leat, fad is ainm tábla bailí é nach bhfuil á úsáid cheana féin i do bhunachar sonraí.

Sa sampla seo, is é my\_cache\_table\` ainm an tábla taisce:

```
CACHES = {
    "default": {
        "BACKEND": "django.core.cache.backends.db.DatabaseCache",
        "LOCATION": "my_cache_table",
    }
}
```

Unlike other cache backends, the database cache does not support automatic
culling of expired entries at the database level. Instead, an expired cache
entry is deleted when evaluated by a `get()` request. Furthermore,
expired cache entries are culled when `add()`, `set()`, or `touch()`
is called and the number of entries exceeds `MAX_ENTRIES`.

#### An tábla taisce a chruthú

Sula n-úsáidtear taisce an bunachar sonraí, ní mór duit an tábla taisce a chruthú leis an ordú seo:

```shell
python manage.py createcachetable
```

Cruthaíonn sé seo tábla i do bhunachar sonraí atá san fhormáid cheart a bhfuil súil ag córas taisce bunachar sonraí Django. \<CACHES-LOCATION\>Tógtar ainm an tábla ó:socrú: SUÍOMH .

Má tá iolracha bunachar sonraí á úsáid agat, cruthaíonn: djadmin: createcachetable tábla amháin do gach taisce.

Má tá bunachar sonraí iolracha á úsáid agat, breathnaíonn: djadmin: createcachetable modh allow\_migration () ar do ródairí bunachar sonraí (féach thíos).

Mar shampla: Djadmin: migrate, :djadmin: ní dhéanfaidh createcachetable teagmháil le tábla atá ann cheana. Ní chruthóidh sé ach táblaí ar iarraidh.

Chun an SQL a reáchtálfaí a phriontáil, seachas é a reáchtáil, bain úsáid as an roghna:option: createcachetable --dry-run.

#### Bunachair sonraí iliom

Má úsáideann tú táscáil bunachar sonraí le bunachair sonraí iolracha, beidh ort treoracha ródaithe a chur ar bun do thábla taisce bunachar sonraí freisin. Chun críocha ródaithe, tá tábla taisce an bhunachar sonraí le feiceáil mar mhúnla darb ainm ```cacheentry`, i bhfeidhmchlár darb ainm ``django_cache```. Ní bheidh an tsamhail seo le feiceáil i taisce na samhlacha, ach is féidir sonraí an tsamhail a úsáid chun críocha ródaithe.

Mar shampla, threoródh an ródaire seo a leanas gach oibríocht léite taisce chuig `cache_replica`, agus scríobhfadh gach oibríocht chuig cache\_primary\`. Ní dhéanfar an tábla taisce a shioncronú ach ar cache\_primary\`:

```
class CacheRouter:
    """A router to control all database cache operations"""

    def db_for_read(self, model, **hints):
        "All cache read operations go to the replica"
        if model._meta.app_label == "django_cache":
            return "cache_replica"
        return None

    def db_for_write(self, model, **hints):
        "All cache write operations go to primary"
        if model._meta.app_label == "django_cache":
            return "cache_primary"
        return None

    def allow_migrate(self, db, app_label, model_name=None, **hints):
        "Only install the cache model on primary"
        if app_label == "django_cache":
            return db == "cache_primary"
        return None
```

Mura sonraíonn tú treoracha ródaithe don tsamhail taisce bunachar sonraí, úsáidfidh an cúltaca taisce an bunachar sonraí `réamhshocraithe`.

Agus mura n-úsáideann tú cúltaca taisce an bhunachar sonraí, ní gá duit a bheith buartha faoi threoracha ródaithe a sholáthar don tsamhail taisce bunachar sonraí.

### Caching chórais comhaid

Déanann an cúltaca comhad-bhunaithe gach luach taisce a shraitheadh agus a stóráil mar chomhad ar leithligh. \<CACHES-LOCATION\>Chun an tacar cúltaca seo a úsáid: socrú: BACKEND \`go \`\`\<CACHES-BACKEND\>"django.core.cache.backends.fileBasedCache"\` agus:setting: LOCATION chuig eolaire oiriúnach. Mar shampla, chun sonraí taisceáilte a stóráil i `/var/tmp/django_cache`, bain úsáid as an socrú seo:

```
CACHES = {
    "default": {
        "BACKEND": "django.core.cache.backends.filebased.FileBasedCache",
        "LOCATION": "/var/tmp/django_cache",
    }
}
```

Má tá tú ar Windows, cuir an litir tiomána ag tús an chosáin, mar seo:

```
CACHES = {
    "default": {
        "BACKEND": "django.core.cache.backends.filebased.FileBasedCache",
        "LOCATION": "c:/foo/bar",
    }
}
```

Ba chóir go mbeadh an cosán eolaire iomlán - is é sin, ba chóir go dtosódh sé ag fréamh do chóras comhaid. Is cuma an gcuireann tú slash ag deireadh an shocraithe.

Déan cinnte go bhfuil an eolaire a luaitear ag an socrú seo ann agus go bhfuil sé inléite agus inscríofa, nó gur féidir le húsáideoir an chórais faoina ritheann do fhreastalaí gréasáin é a chruthú. Ag leanúint leis an sampla thuas, má ritheann do fhreastalaí mar an úsáideoir `apache`, déan cinnte go bhfuil an eolaire `/var/tmp/django_cache` ann agus go bhfuil sé inléite agus inscríofa ag an úsáideoir `apache`, nó gur féidir leis an úsáideoir `apache` é a chruthú.

> **Warning**
>
> Nuair a bhíonn an cache:setting: LOCATION \`laistigh de: setting: \<CACHES-LOCATION\>MEDIA\_ROOT\`, :setting: STATIC\_ROOT, nó: setting: STATICFILES\_FINDERS, féadfar sonraí íogaire a nochtadh.
>
> Ní amháin gur féidir le hionsaitheoir a fhaigheann rochtain ar an gcomhad taisce ábhar HTML a fhalsú, a mbeidh muinín ag do shuíomh, ach cód treallach a fhorghníomhú go cianda freisin, toisc go ndéantar na sonraí a shraitheadh ag baint úsáide:mod: pickle.

> **Warning**
>
> D'fhéadfadh go mbeadh cúisceáil chórais chomhad mall nuair a stóráiltear líon mór comhaid. Má théann tú isteach sa fhadhb seo, smaoinigh ar mheicníocht caching difriúil a úsáid. \<django/core/cache/backends/filebased.py\>Is féidir leat fo-aicme freisin: source: FileBasedCache agus an straitéis chailliúcháin a fheabhsú.

### Cacháil cuimhne áitiúil

Is é seo an taisce réamhshocraithe mura sonraítear ceann eile i do chomhad socruithe. Más mian leat na buntáistí luais a bhaineann le caching in-chuimhne ach nach bhfuil an cumas agat Memcached a reáchtáil, smaoinigh ar an gcúltaca taisce cuimhne áitiúil. Tá an taisce seo in aghaidh an phróisis (féach thíos) agus sábháilte ó snáithe. \<CACHES-BACKEND\>Chun é a úsáid, socraí:setting: BACKEND \`go \`"django.core.cache.backends.locmem.locmemcache". Mar shampla:

```
CACHES = {
    "default": {
        "BACKEND": "django.core.cache.backends.locmem.LocMemCache",
        "LOCATION": "unique-snowflake",
    }
}
```

Úsáidtear an cache:setting: LOCATION \<CACHES-LOCATION\>\`chun siopaí cuimhne aonair a aithint. Mura bhfuil ach taisce \`\`locmem\` amháin agat, is féidir leat an:setting: LOCATION a fhágáil\<CACHES-LOCATION\>; áfach, má tá níos mó ná taisce cuimhne áitiúil amháin agat, beidh ort ainm a shannadh do cheann acu ar a laghad d'fhonn iad a choinneáil ar leithligh.

Úsáideann an taisce straitéis díothaithe is lú a úsáidtear le déanaí (LRU).

Tabhair faoi deara go mbeidh a shampla taisce príobháideach féin ag gach próiseas, rud a chiallaíonn nach féidir aon chaching trasphróisis a dhéanamh. Ciallaíonn sé seo freisin nach bhfuil an taisce cuimhne áitiúil go háirithe éifeachtach ó chuimhne, mar sin is dócha nach rogha maith é do thimpeallachtaí táirgeachta. Tá sé go deas le haghaidh forbartha.

### Caching dummy (le haghaidh forbartha)

Faoi dheireadh, tagann Django le taisce “dummy” nach ndéanann taisce i ndáiríre - ní chuireann sé ach an comhéadan taisce i bhfeidhm gan aon rud a dhéanamh.

Tá sé seo úsáideach má tá suíomh táirgeachta agat a úsáideann taiscáil tromshaothair in áiteanna éagsúla ach timpeallacht forbarta/tástála nach dteastaíonn uait taisce a dhéanamh agus nach dteastaíonn uait do chód a athrú go speisialta an dara ceann. \<CACHES-BACKEND\>Chun caching dummy a ghníomhachtú, socraí:setting: BACKEND mar sin:

```
CACHES = {
    "default": {
        "BACKEND": "django.core.cache.backends.dummy.DummyCache",
    }
}
```

### Úsáid cúltaca taisce saincheaptha

Cé go gcuimsíonn Django tacaíocht do roinnt cúltaca taisce lasmuigh den bhosca, uaireanta b'fhéidir gur mhaith leat cúltaca taisce saincheaptha a úsáid. Chun cúltaca taisce seachtrach a úsáid le Django, bain úsáid as an gcosán allmhairithe Python mar an:setting: BACKEND \`den socrú: \`CACHES\<CACHES-BACKEND\>, mar shampla:

```
CACHES = {
    "default": {
        "BACKEND": "path.to.backend",
    }
}
```

Má tá do chúlcheann féin á thógáil agat, is féidir leat na cúltaca caighdeánacha taisce a úsáid mar chur i bhfeidhm tagartha. Gheobhaidh tú an cód san eolaire: source: django/core/cache/backends/ foinse Django.

Nóta: Gan cúis an-láidir, mar óstach nach dtacaíonn leo, ba chóir duit cloí leis na cúltaca taisce atá san áireamh le Django. Rinneadh tástáil mhaith orthu agus tá siad doiciméadaithe go maith.

### Argóintí taisce

Is féidir argóintí breise a thabhairt do gach cúltaca taisce chun iompar taisce a rialú. Cuirtear na hargóintí seo ar fáil mar eochracha breise sa socrú: socrú: CACHES. Is iad seo a leanas argóintí bailí:

- [`TIMEOUT`](/ga/6.1/ref/settings/#std-setting-CACHES-TIMEOUT): The default timeout, in
  seconds, to use for the cache. This argument defaults to `300` seconds
  (5 minutes). You can set `TIMEOUT` to `None` so that, by default, cache
  keys never expire. A value of `0` causes keys to immediately expire
  (effectively "don't cache").
- [`OPTIONS`](/ga/6.1/ref/settings/#std-setting-CACHES-OPTIONS): Any options that should be
  passed to the cache backend. The list of valid options will vary
  with each backend, and cache backends backed by a third-party library
  will pass their options directly to the underlying cache library.

  Déanfaidh cúltaca taisce a chuireann a straitéis díothaithe féin i bhfeidhm (ie, na cúltaca `locmem`, ```córas comhad ``agus ``bunachar sonraí```) onóir na roghanna seo a leanas:

  - `MAX_ENTRIES`: An líon uasta na n-iontrálacha a cheadaítear sa taisce sula scriostar seanluachanna. Tá an argóint seo réamhshocraithe go `300`.
  - `CULL_FREQUENCY`: An codán na n-iontrálacha a dhíothaítear nuair a shroichtear `MAX_ENTRIES`. Is é an cóimheas iarbhír ná `1/CULL_FREQUENCY`, mar sin socraigh `CULL_FREQUENCY` go `2` chun leath na n-iontrálacha a scriosadh nuair a shroichtear ```MAX_ENTRIES ``. Ba chóir go mbeadh an argóint seo ina shláimhir agus réamhshocraithe go ``3```.

    Ciallaíonn luach `0` do CULL\_FREQUENCY\` go ndéanfar an taisce iomlán a dumpáil nuair a shroichfear `MAX_ENTRIES`. Ar roinnt cúltaca (bunachar sonraí go háirithe) déanann sé seo go gcaithfeach\* i bhfad níos gasta ar chostas níos mó caitheamh taisce.

  Cuireann cúltaca Memcached agus Redis ábhar: socrú: OPTIONS \<CACHES-OPTIONS\>\`mar argóintí eochairfhocal chuig tógálaí na gcliant, rud a cheadaíonn rialú níos airde ar iompar cliant. Mar shampla úsáid, féach thíos.
- [`KEY_PREFIX`](/ga/6.1/ref/settings/#std-setting-CACHES-KEY_PREFIX): A string that will be
  automatically included (prepended by default) to all cache keys
  used by the Django server.

  Féach na:ref: cáipéisíocht taiscéala \<cache\_key\_prefixing\>\`le haghaidh tuilleadh faisnéise.
- [`VERSION`](/ga/6.1/ref/settings/#std-setting-CACHES-VERSION): The default version number
  for cache keys generated by the Django server.

  Féach na:ref: cáipéisíocht taiscéala \<cache\_versioning\>\`le haghaidh tuilleadh faisnéise.
- [`KEY_FUNCTION`](/ga/6.1/ref/settings/#std-setting-CACHES-KEY_FUNCTION)
  A string containing a dotted path to a function that defines how
  to compose a prefix, version and key into a final cache key.

  Féach na:ref: cáipéisíocht taiscéala \<cache\_key\_transformation\>\`le haghaidh tuilleadh faisnéise.

Sa sampla seo, tá cúltaca córas comhaid á chumrú le haon ama 60 soicind, agus cumas uasta 1000 mír:

```
CACHES = {
    "default": {
        "BACKEND": "django.core.cache.backends.filebased.FileBasedCache",
        "LOCATION": "/var/tmp/django_cache",
        "TIMEOUT": 60,
        "OPTIONS": {"MAX_ENTRIES": 1000},
    }
}
```

Seo cumraíocht shampla le haghaidh cúltaca bunaithe ar pylibmc a chumasaíonn an prótacal dénártha, fíordheimhniú SASL, agus an modh iompraíochta ketama:

```
CACHES = {
    "default": {
        "BACKEND": "django.core.cache.backends.memcached.PyLibMCCache",
        "LOCATION": "127.0.0.1:11211",
        "OPTIONS": {
            "binary": True,
            "username": "user",
            "password": "pass",
            "behaviors": {
                "ketama": True,
            },
        },
    }
}
```

Seo cumraíocht shamplach le haghaidh cúltaca bunaithe ar pymemcache a chuireann ar chumas comhdhlúthú cliant (a d'fhéadfadh feidhmíocht a fheabhsú trí chliaint a choinneáil ceangailte), déileálann sé le hearráidí memcache/líonra mar chailleann taisce, agus socraíonn an bratach `TCP_NODELAY` ar soicéad an nasc:

```
CACHES = {
    "default": {
        "BACKEND": "django.core.cache.backends.memcached.PyMemcacheCache",
        "LOCATION": "127.0.0.1:11211",
        "OPTIONS": {
            "no_delay": True,
            "ignore_exc": True,
            "max_pool_size": 4,
            "use_pooling": True,
        },
    }
}
```

Seo cumraíocht shampla le haghaidh cúltaca bunaithe ar `redis` a roghnaíonn bunachar sonraí `` `10 `` (de réir réamhshocraithe loingíonn Redis le 16 bhunachar sonraí loighciúla), agus a leagann saincheaptha [rang linn nasc](https://github.com/redis/redis-py#connection-pools) (`Redis.connectionPool` úsáidtear de réir réamhshocraithe):

```
CACHES = {
    "default": {
        "BACKEND": "django.core.cache.backends.redis.RedisCache",
        "LOCATION": "redis://127.0.0.1:6379",
        "OPTIONS": {
            "db": "10",
            "pool_class": "redis.BlockingConnectionPool",
        },
    }
}
```

## An taisce in aghaidh an láithreáin

Nuair a bheidh an taisce curtha ar bun, is é an bealach is simplí chun caching a úsáid ná do shuíomh iomlán a thaisceadh. Beidh ort django.middleware.cache.UpdateCacheMiddleware'\` agus django.middleware.cache.fetchfromCacheMiddleware'\` a chur le do shuíomh: MIDDLEWARE, mar atá sa sampla seo:

```
MIDDLEWARE = [
    "django.middleware.cache.UpdateCacheMiddleware",
    "django.middleware.common.CommonMiddleware",
    "django.middleware.cache.FetchFromCacheMiddleware",
]
```

> **Note**
>
> Níl, ní clóscríobh é sin: caithfidh an middleware “nuashonrú” a bheith ar dtús ar an liosta, agus caithfidh an middleware “faigh” a bheith deireanach. Tá na sonraí beagán doiléir, ach féach [Ordú MIDDLEWARE](#order-of-middleware) thíos más mian leat an scéal iomlán.

Ansin, cuir na socruithe riachtanacha seo a leanas le do chomhad socruithe Django:

- [`CACHE_MIDDLEWARE_ALIAS`](/ga/6.1/ref/settings/#std-setting-CACHE_MIDDLEWARE_ALIAS) -- The cache alias to use for storage.
- [`CACHE_MIDDLEWARE_SECONDS`](/ga/6.1/ref/settings/#std-setting-CACHE_MIDDLEWARE_SECONDS) -- The integer number of seconds each
  page should be cached.
- [`CACHE_MIDDLEWARE_KEY_PREFIX`](/ga/6.1/ref/settings/#std-setting-CACHE_MIDDLEWARE_KEY_PREFIX) -- If the cache is shared across
  multiple sites using the same Django installation, set this to the name of
  the site, or some other string that is unique to this Django instance, to
  prevent key collisions. Use an empty string if you don't care.

Tugann `Fetchfromcachemiddleware` freagraí GET agus HEAD le stádas 200, nuair a cheadaíonn na ceannteidil iarratais agus freagartha. Meastar gur leathanaigh uathúla iad freagraí ar iarratais ar an URL céanna le paraiméadair cheisteanna éagsúla agus cuirtear iad a chosc ar leithligh Tá an middleware seo ag súil go bhfreagraítear iarratas HEAD leis na ceannteidil freagartha céanna leis an iarratas GET comhfhreagrach; sa chás sin féadfaidh sé freagra GET a chosaithe ar iarratas HEAD a thabhairt ar ais.

\<downstream-caches\>Ina theannta sin, socraíonn `UpdateCacheMiddleware` cúpla ceannteideal go huathoibríoch i ngach:class: ~django.http.httpResponse a théann i bhfeidh:ref: caches downstream :

- Socraíonn an ceannteideal `Expires` go dtí an dáta/am reatha móide an sainmhínithe:setting: CACHE\_MIDDLEWARE\_SECONDS.
- Socraíonn sé an ceanntásc `Cache-Control` chun aoise uasta a thabhairt don leathanach -- arís, ón socrú:setting: CACHE\_MIDDLEWARE\_SECONDS.

Féach: doc: /topics/http/middleware le haghaidh tuilleadh ar middleware.

Má shocraíonn amharc a chuid ama éaga taisce féin (ie tá rannán `max-aos` aige ina cheanntásc `Cache-Control`) ansin déanfar an leathanach a stóráil go dtí an t-am éaga, seach:setting: CACHE\_MIDDLEWARE\_SECONDS. Ag baint úsáide as na maisitheoirí i django.views.decorators.cache\` is féidir leat am éaga amharc a shocrú go héasca (ag baint úsáide as:func: ~django.views.decorators.cache.cache\_control decorator) nó díchumasú a chaching le haghaidh amharc (ag baint úsáide as an: func: ~django.decorators.cache.neverator \_cache). Féach an chuid ceannteidil eile a úsáid \_\_ le haghaidh tuilleadh eolais faoi na maisitheoirí seo.

If [`USE_I18N`](/ga/6.1/ref/settings/#std-setting-USE_I18N) is set to `True` then the generated cache key will
include the name of the active [language](/ga/6.1/topics/i18n/#term-language-code) (see also
[How Django discovers language preference](/ga/6.1/topics/i18n/translation/#how-django-discovers-language-preference)). This allows you to easily
cache multilingual sites without having to create the cache key yourself.

Cuimsíonn eochracha taisce an: ref: crios ama reatha \`nuai:setting: \`USE \<default-current-time-zone\>\_TZ socraithe go `True`.

## An taisce in aghaidh an amharc

#### `django.views.decorators.cache.cache_page(timeout, * (Keyword-only parameters separator (PEP 3102)), cache=None, key_prefix=None)`

Bealach níos gráinneach chun an creat taiscéála a úsáid ná aschur tuairimí aonair a chaitheamh. Sainmhíníonn `django.views.decorators.cache` maisitheoir `cache_page` a thaisceoidh freagra an amharc duit go huathoibríoch:

```
from django.views.decorators.cache import cache_page

@cache_page(60 * 15)
def my_view(request): ...
```

Tógann `cache_page` argóint amháin: an t-am taisce, i soicindí. Sa sampla thuas, déanfar toradh an radharc ``my_view () `a stóráil ar feadh 15 nóiméad. (Tabhair faoi deara go bhfuil sé scríofa againn mar `60* 15`` chun críche inléiteachta. Meastófar `60* 15` go 900\` \- is é sin, 15 nóiméad iolraithe le 60 soicind in aghaidh an nóiméid.)

Tá tosaíocht ag an am taisce atá leagtha síos ag cache\_page\` thar an treoir ```max-aois ``ón gceannteideal ``Cache-Control```.

Cuirtear an taisce in aghaidh an amharc, cosúil leis an taisce in aghaidh an láithreáin, as an URL. Má thaispeánann URLanna iolracha ar an radharc céanna, déanfar gach URL a stóráil ar leithligh. Ag leanúint leis an sampla `my_view`, má tá cuma seo ar do URLConf:

```
urlpatterns = [
    path("foo/<int:code>/", my_view),
]
```

ansin cuirfear iarratais ar `/foo/1/` agus `/foo/23/` a chosc ar leithligh, mar a d'fhéadfá a bheith ag súil leis. Ach nuair a iarrtar URL áirithe (m.sh., `/foo/23/`), úsáidfidh iarratais ina dhiaidh sin chuig an URL sin an taisce.

Is féidir le `cache_page` argóint eochairfhocal roghnach a ghlacadh freisin, cache\`, a threoraíonn don mhaisitheoir taisce ar leith a úsáid (ó do shuíomh: SETING: \`CACHES) agus torthaí amharc á chaitheamh agat. De réir réamhshocraithe, úsáidfear an taisce `default`, ach is féidir leat aon taisce a theastaíonn uait a shonrú:

```
@cache_page(60 * 15, cache="special_cache")
def my_view(request): ...
```

You can also override the cache prefix on a per-view basis. `cache_page`
takes an optional keyword argument, `key_prefix`,
which works in the same way as the [`CACHE_MIDDLEWARE_KEY_PREFIX`](/ga/6.1/ref/settings/#std-setting-CACHE_MIDDLEWARE_KEY_PREFIX)
setting for the middleware. It can be used like this:

```
@cache_page(60 * 15, key_prefix="site1")
def my_view(request): ...
```

Is féidir na hargóintí `key_prefix` agus `cache` a shonrú le chéile. \<CACHES-KEY\_PREFIX\>Déanfar an argóint `key_prefix` agus an:setting: KEY\_PREFIX a shonraítear fao:setting: CACHES a chomhcheangal.

\<downstream-caches\>Ina theannta sin, socraíonn `cache_page` ceannteidil `Cache-Control` agus `Expires` go huathoibríoch sa fhreagra a théann i bhfeidh:ref: caches downstream .

> **Responses are cached before response middleware runs**
>
> `cache_page` is intended for content that is safe to reuse for requests
> to the same URL. It does not automatically vary by authentication,
> sessions, cookies, or other request-specific state.
>
> As a decorator wrapping the view directly, responses are cached before
> response middleware runs. If cache variation depends on response
> middleware, ensure it runs before the response is cached. For example, when
> caching views containing CSRF-protected forms, follow
> [Cosaint CSRF a úsáid le caching](/ga/6.1/howto/csrf/#csrf-cache-page) to ensure the `Vary` header is set first.

### Taisce in aghaidh an amharc a shonrú sa URLConf

The examples in the previous section have hardcoded the fact that the view is
cached, because `cache_page` alters the `my_view` function in place. This
approach couples your view to the cache system, which is not ideal for several
reasons. For instance, you might want to reuse the view functions on another,
cache-less site, or you might want to distribute the views to people who might
want to use them without being cached. The solution to these problems is to
specify the per-view cache in the URLconf rather than next to the view
functions themselves.

Is féidir leat é sin a dhéanamh tríd an bhfeidhm amharc a fhilleadh le cache\_page\` nuair a thagann tú tagairt dó sa URLConf. Seo an sean-URLConf ó níos luaithe:

```
urlpatterns = [
    path("foo/<int:code>/", my_view),
]
```

Seo an rud céanna, le `my_view` fillte i `cache_page`:

```
from django.views.decorators.cache import cache_page

urlpatterns = [
    path("foo/<int:code>/", cache_page(60 * 15)(my_view)),
]
```

## Caching bhrúin teimpléad

Má tá tú tar éis níos mó smachta fós, is féidir leat blúirí teimpléad a thaiscáil ag baint úsáide as an gclib teimpléad ```cache`. Chun rochtain a thabhairt do do theimpléad ar an gclib seo, cuir ``{% load cache%}``` in aice le barr do theimpléad.

Cuireann an chlib teimpléid `{% cache%}` ábhar an bhloc a chosc ar feadh méid áirithe ama. Tógann sé dhá argóint ar a laghad: an t-am taisce, i soicindí, agus an t-ainm chun an blúire taisce a thabhairt. Déantar an blúire a stóráil go deo má tá an t-am amach None . Glacfar an t-ainm mar atá, ná húsáid athróg. Mar shampla:

```html+django
{% load cache %}
{% cache 500 sidebar %}
    .. sidebar ..
{% endcache %}
```

Sometimes you might want to cache multiple copies of a fragment depending on
some dynamic data that appears inside the fragment. For example, you might want
a separate cached copy of the sidebar used in the previous example for every
user of your site. Do this by passing one or more additional arguments, which
may be variables with or without filters, to the `{% cache %}` template tag
that will uniquely identify the cache fragment when those values are converted
to strings:

```html+django
{% load cache %}
{% cache 500 sidebar request.user.username %}
    .. sidebar for logged-in user ..
{% endcache %}
```

> **Argument values converted to strings**
>
> Because argument values are converted to strings when creating the cache
> key, consider uniqueness carefully to avoid serving one fragment for two
> distinct values that share a string representation, such as `None` and
> `"None"`. Avoid supplying a model instance, since its `__str__()` is
> not guaranteed to be unique. Conveniently, in the example above,
> `request.user.username` is unique for the default `User` model.

\<i18n-cache-key\>Má tá: SETTING: USE\_I18N socraithe go `True`, beidh taisce meán-earraí in aghaidh an láithreáin: ref: meas a thabhairt don teanga ghníomhach. \<template-translation-vars\>Maidir leis an gclib teimpléad `cache` d'fhéadfá ceann de na hathróga:ref: aistriúcháin-shonracha atá ar fáil i dteimpléid a úsáid chun an toradh céanna a bhaint amach:

```html+django
{% load i18n %}
{% load cache %}

{% get_current_language as LANGUAGE_CODE %}

{% cache 600 welcome LANGUAGE_CODE %}
    {% translate "Welcome to example.com" %}
{% endcache %}
```

Is féidir leis an t-am taisce a bheith ina athróg teimpléad, chomh fada agus a réitíonn an t-athróg teimpléad ar luach slámhshláir. Mar shampla, má tá an t-athróg teimpléad `my_timeout` socraithe go luach `600`, ansin tá an dá shampla seo a leanas coibhéiseach:

```html+django
{% cache 600 sidebar %} ... {% endcache %}
{% cache my_timeout sidebar %} ... {% endcache %}
```

Tá an ghné seo úsáideach chun athdhéanamh i dteimpléid a sheachaint. Is féidir leat an t-am a shocrú in athróg, in aon áit amháin, agus an luach sin a athúsáid.

De réir réamhshocraithe, déanfaidh an clib taisce iarracht an taisce ar a dtugtar “template\_fragments” a úsáid. Mura bhfuil taisce den sórt sin ann, tiocfaidh sé ar ais chun an taisce réamhshocraithe a úsáid. Féadfaidh tú cúltaca taisce malartach a roghnú le húsáid leis an argóint eochairfhocal úsáid , nach mór gurb é an argóint deireanach don chlib.

```html+django
{% cache 300 local-thing ...  using="localcache" %}
```

Meastar gur earráid é ainm taisce nach bhfuil cumraithe a shonrú.

#### `django.core.cache.utils.make_template_fragment_key(fragment_name, vary_on=None)`

If you want to obtain the cache key used for a cached fragment, you can use
`make_template_fragment_key`. `fragment_name` is the same as the second
argument to the `cache` template tag; `vary_on` is a list of all additional
arguments passed to the tag. This function can be useful for invalidating or
overwriting a cached item, for example:

```pycon
>>> from django.core.cache import cache
>>> from django.core.cache.utils import make_template_fragment_key
# cache key for {% cache 500 sidebar username %}
>>> key = make_template_fragment_key("sidebar", [username])
>>> cache.delete(key)  # invalidates cached template fragment
True
```

## An API taisce leibhéal íseal

Uaireanta, ní ghnóthaíonn sé go mór duit a chaitheamh ar leathanach iomlán rindreáilte agus bíonn sé, i ndáiríre, ró-dhochaoithiúil.

B'fhéidir, mar shampla, tá radharc ar do shuíomh ag brath a thorthaí ar roinnt ceisteanna daor, a n-athraíonn a dtorthaí ag eatraimh éagsúla. Sa chás seo, ní bheadh sé oiriúnach an taisce leathanaigh lán-leathanaigh a thairgeann na straitéisí taisce in aghaidh an láithreáin nó in aghaidh an amharc a úsáid, toisc nach mbeadh tú ag iarraidh an toradh iomlán a thaisceadh (ós rud é go n-athraíonn cuid de na sonraí go minic), ach ba mhaith leat fós na torthaí a athraíonn.

For cases like this, Django exposes a low-level cache API. You can use this API
to store objects in the cache with any level of granularity you like. You can
cache any Python object that can be pickled safely: strings, dictionaries,
lists of model objects, and so forth. (Most common Python objects can be
pickled; refer to the [`Python documentation`](https://docs.python.org/3/library/pickle.html#module-pickle) for more information
about pickling.)

### Rochtain a fháil ar an taisce

#### `django.core.cache.caches`

Is féidir leat rochtain a fháil ar na táscáin atá cumraithe sa socrú:: CACHES trí réad cosúil le dict: `django.core.cache.caches`. Tabharfaidh iarratais arís agus arís eile ar an alias céanna sa snáithe céanna ar ais an réad céanna.

```pycon
>>> from django.core.cache import caches
>>> cache1 = caches["myalias"]
>>> cache2 = caches["myalias"]
>>> cache1 is cache2
True
```

Mura bhfuil an eochair ainmnithe ann, ardófar `InvalidCacheBackendError`.

Chun sábháilteacht snáithe a sholáthar, cuirfear sampla difriúil den chúltaca taisce ar ais do gach snáithe.

#### `django.core.cache.cache`

Mar aicearra, tá an taisce réamhshocraithe ar fáil mar `django.core.cache.cache`:

```pycon
>>> from django.core.cache import cache
```

Tá an réad seo comhionann le caches \['réamhshocraithe'\] .

### Úsáid bunúsach

Is é an comhéadan bunúsach:

#### `cache.set(key, value, timeout=DEFAULT_TIMEOUT, version=None)`

```pycon
>>> cache.set("my_key", "hello, world!", 30)
```

#### `cache.get(key, default=None, version=None)`

```pycon
>>> cache.get("my_key")
'hello, world!'
```

Ba chóir go mbeadh `eochair` ina str\`, agus is féidir `luach` a bheith ina aon rud Python inpictilte.

Tá an argóint `timeout` roghnach agus réamhshocraíonn sé ar an argóint `timeout` den chúltaca cuí sa socrúit:setting: CACHES (mínithe thuas). Is é líon na soicind ba chóir an luach a stóráil sa taisce. Ag dul isteach `None` le haghaidh `timeout`, beidh an luach a thaisceadh go deo. Ní dhéanfaidh `timeout` de `0` a thaisceadh an luach.

Mura bhfuil an réad ann sa taisce, filleann `````cache.get () ````None`````:

```pycon
>>> # Wait 30 seconds for 'my_key' to expire...
>>> cache.get("my_key")
None
```

Más gá duit a chinneadh an bhfuil an réad sa taisce agus go bhfuil luach litriúil “None” stóráilte agat, bain úsáid as réad sentinel mar réamhshocraithe:

```pycon
>>> sentinel = object()
>>> cache.get("my_key", sentinel) is sentinel
False
>>> # Wait 30 seconds for 'my_key' to expire...
>>> cache.get("my_key", sentinel) is sentinel
True
```

Is féidir le ```cache.get () ``argóint ``default``` a ghlacadh. Sonraíonn sé seo cén luach atá le filleadh mura bhfuil an réad ann sa taisce:

```pycon
>>> cache.get("my_key", "has expired")
'has expired'
```

#### `cache.add(key, value, timeout=DEFAULT_TIMEOUT, version=None)`

Chun eochair a chur leis ach amháin mura bhfuil sé ann cheana féin, bain úsáid as an modh add () . Tógann sé na paraiméadair chéanna le set () , ach ní dhéanfaidh sé iarracht an taisce a nuashonrú má tá an eochair a shonraítear i láthair cheana féin:

```pycon
>>> cache.set("add_key", "Initial value")
>>> cache.add("add_key", "New value")
>>> cache.get("add_key")
'Initial value'
```

Más gá duit fios a bheith agat an stóráil ```add () ``luach sa taisce, is féidir leat an luach tuairisceáin a sheiceáil. Tabharfaidh sé ar ais ``True``` má stóráilíodh an luach, `False` ar shlí eile.

#### `cache.get_or_set(key, default, timeout=DEFAULT_TIMEOUT, version=None)`

Más mian leat luach eochair a fháil nó luach a shocrú mura bhfuil an eochair sa taisce, tá an modh get\_or\_set () ann. Tógann sé na paraiméadair chéanna le get () ach socraítear an réamhshocrú mar an luach taisce nua don eochair sin, seachas a thabhairt ar ais:

```pycon
>>> cache.get("my_new_key")  # returns None
>>> cache.get_or_set("my_new_key", "my new value", 100)
'my new value'
```

Is féidir leat aon ghlaoch a chur ar aghaidh mar luach\*réamhshocraithe\*:

```pycon
>>> import datetime
>>> cache.get_or_set("some-timestamp-key", datetime.datetime.now)
datetime.datetime(2014, 12, 11, 0, 15, 49, 457920)
```

#### `cache.get_many(keys, version=None)`

Tá comhéadan get\_many () ann freisin nach mbuaileann an taisce ach uair amháin. Tugann get\_many () foclóir ar ais leis na heochracha go léir a d'iarr tú orthu atá ann i ndáiríre sa taisce (agus níor éag):

```pycon
>>> cache.set("a", 1)
>>> cache.set("b", 2)
>>> cache.set("c", 3)
>>> cache.get_many(["a", "b", "c"])
{'a': 1, 'b': 2, 'c': 3}
```

#### `cache.set_many(dict, timeout)`

Chun luachanna iolracha a shocrú níos éifeachtaí, bain úsáid as set\_many () chun foclóir péirí eochairluacha a rith:

```pycon
>>> cache.set_many({"a": 1, "b": 2, "c": 3})
>>> cache.get_many(["a", "b", "c"])
{'a': 1, 'b': 2, 'c': 3}
```

Cosúil le ```cache.set () ``, glacann ``set_many ()``` paraiméadar roghnach `timeout`.

Ar chúltaca tacaithe (memcached), filleann set\_many () liosta eochracha ar theip orthu a chur isteach.

#### `cache.delete(key, version=None)`

Is féidir leat eochracha a scriosadh go sainráite le delete () chun an taisce do réad áirithe a ghlanadh:

```pycon
>>> cache.delete("a")
True
```

Tugann ```delete () ``filleadh ``True``` má scriosadh an eochair go rathúil, `False` ar shlí eile.

#### `cache.delete_many(keys, version=None)`

Más mian leat dornán eochracha a ghlanadh ag an am céanna, is féidir le delete\_many () liosta eochracha atá le glanadh a ghlanadh:

```pycon
>>> cache.delete_many(["a", "b", "c"])
```

#### `cache.clear()`

Finally, if you want to delete all the keys in the cache, use
`cache.clear()`. Be careful with this; `clear()` will remove *everything*
from the cache, not just the keys set by your application:

```pycon
>>> cache.clear()
```

#### `cache.touch(key, timeout=DEFAULT_TIMEOUT, version=None)`

Socraíonn cache.touch () éag nua le haghaidh eochair. Mar shampla, chun eochair a nuashonrú chun dul in éag 10 soicind as seo:

```pycon
>>> cache.touch("a", 10)
True
```

Cosúil le modhanna eile, tá an argóint `timeout` roghnach agus réamhshocraíonn sé ar an rogha `TIMEOUT` den chúltaca cuí sa socrúit:setting: CACHES.

Filleann ````touch () ```True```` má rinneadh teagmháil leis an eochair go rathúil, `False` ar shlí eile.

#### `cache.incr(key, delta=1, version=None)`

#### `cache.decr(key, delta=1, version=None)`

Is féidir leat eochair atá ann cheana féin a mhéadú nó a laghdú ag baint úsáide as na modhanna ```incr () ``nó `decr ()```, faoi seach. De réir réamhshocraithe, déanfar an luach taisce atá ann cheana a mhéadú nó a laghdú faoi 1. Is féidir luachanna fáis/laghdaithe eile a shonrú trí argóint a sholáthar don ghlao fáis/laghdaithe. Ardófar ValueError má dhéanann tú iarracht eochair taisce nach bhfuil ann a mhéadú nó a laghdú:

```pycon
>>> cache.set("num", 1)
>>> cache.incr("num")
2
>>> cache.incr("num", 10)
12
>>> cache.decr("num")
11
>>> cache.decr("num", 5)
6
```

> **Note**
>
> Ní ráthaítear go mbeidh modhanna `` incr () ` ``/decr () adamhacha. Ar na cúltacaí sin a thacaíonn le fhás/laghdú adamhach (go háirithe, an cúltaca memcached), beidh oibríochtaí increimeádaithe agus laghdaithe adamhacha. Mar sin féin, mura soláthraíonn an cúltaca oibríocht fhásai/laghdaithe go dúchasach, cuirfear i bhfeidhm é ag baint úsáide as aisghabhálaí/nuashonrú dhá chéim.

#### `cache.close()`

Is féidir leat an nasc le do taisce a dhúnadh le close () má chuireann an cúltaca taisce i bhfeidhm.

```pycon
>>> cache.close()
```

> **Note**
>
> Maidir le tuairisceáin nach gcuireann modhanna dúnta i bhfeidhm is neamh-op é.

> **Note**
>
> Tá na leaganacha async de mhodhanna bonn réamhshocraithe le `a`, m.sh. cache.aadd () \`\`nó \`\`cache.adelete\_many ()\`. Féach [Tacaíocht asincrónaithe](#id16) le haghaidh tuilleadh sonraí.

### Réamhshocrú eochair taisce

Má tá sampla taisce á roinnt agat idir freastalaithe, nó idir do thimpeallachtaí táirgeachta agus forbartha, is féidir go n-úsáidfidh freastalaí eile sonraí a chuimsíonn freastalaí amháin. Má tá formáid na sonraí taisceáilte difriúil idir freastalaithe, d'fhéadfadh fadhbanna an-deacair a dhiagnóisiú a bheith mar thoradh air seo.

Chun é seo a chosc, soláthraíonn Django an cumas na heochracha taisce go léir a úsáideann freastalaí a réamhú \<CACHES-KEY\_PREFIX\>Nuair a shábháiltear eochair taisce áirithe nó a aisghabháil, déanfaidh Django réamh-eochair an taisce go huathoibríoch le luach an socrú taisce: socrú: KEY\_PREFIX.

Trí chinntiú go bhfuil difri:setting: KEY\_PREFIX \<CACHES-KEY\_PREFIX\>\`ag gach cás Django, is féidir leat a chinntiú nach mbeidh aon imbhuailtí i luachanna taisce.

### Leagán taisce

Nuair a athraíonn tú cód reatha a úsáideann luachanna taiscthe, b'fhéidir go mbeidh ort aon luachanna taiscéadaithe atá ann cheana a ghlanadh. Is é an bealach is éasca le seo a dhéanamh ná an taisce iomlán a shruthlú, ach d'fhéadfadh sé seo go gcaillfear luachanna taisce atá fós bailí agus úsáideach.

Soláthraíonn Django bealach níos fearr chun luachanna taisce aonair a dhíriú. \<CACHES-VERSION\>Tá aitheantóir leagan ar fud an chórais ag creat taisce Django, sonraithe ag baint úsáide as an socrú taisce: leagan: VERSION. Déantar luach an socraithe seo a chomhcheangal go huathoibríoch leis an réimír taisce agus leis an eochair taisce a sholáthraíonn an úsáideoir chun an eochair taisce de

De réir réamhshocraithe, áireofar leagan eochair taisce réamhshocraithe an láithreáin go huathoibríoch Mar sin féin, tá argóint leagan sa fheidhmeanna taisce príomha uile, ionas gur féidir leat eochrleagan taisce áirithe a shonrú le socrú nó a fháil. Mar shampla:

```pycon
>>> # Set version 2 of a cache key
>>> cache.set("my_key", "hello world!", version=2)
>>> # Get the default version (assuming version=1)
>>> cache.get("my_key")
None
>>> # Get version 2 of the same key
>>> cache.get("my_key", version=2)
'hello world!'
```

Is féidir leagan eochair shonrach a mhéadú agus a shocrú ag baint úsáide as na modhanna ```incr_version () ``agus `decr_version ()```. Cuireann sé seo ar chumas eochracha ar leith a chur chuig leagan nua, rud a fhágann gan tionchar ar eochracha eile. Leanúint lenár sampla roimhe seo:

```pycon
>>> # Increment the version of 'my_key'
>>> cache.incr_version("my_key")
>>> # The default version still isn't available
>>> cache.get("my_key")
None
# Version 2 isn't available, either
>>> cache.get("my_key", version=2)
None
>>> # But version 3 *is* available
>>> cache.get("my_key", version=3)
'hello world!'
```

### Eochair claochlú taisce

Mar a thuairiscítear sa dá chuid roimhe seo, ní úsáidtear an eochair taisce a sholáthraíonn úsáideoir focal focal - déantar é a chomhcheangal leis an réimír taisce agus an leagan eochair chun eochair taisce deiridh a sholáthar. De réir réamhshocraithe, ceanglaítear na trí chuid ag baint úsáide as colons chun sreang deiridh a tháirgeadh:

```
def make_key(key, key_prefix, version):
    return "%s:%s:%s" % (key_prefix, version, key)
```

Más mian leat na codanna a chur le chéile ar bhealaí éagsúla, nó próiseáil eile a chur i bhfeidhm ar an eochair dheiridh (m.sh., díleá hash de na príomhchodanna a thógáil), is féidir leat eochairfheidhm saincheaptha a sholáthar.

Sonraíonn an socrú taisce: KEY\_FUNCTION \<CACHES-KEY\_FUNCTION\>\`cosán poncair chuig feidhm a mheaitseann le fréamhshamhail make\_key () thuas. Má chuirtear ar fáil, úsáidfear an eochrfheidhm saincheaptha seo in ionad na feidhme comhcheangailte eochair réamhshocrai

### Príomhrabhaidh taisce

Ní cheadaíonn Memcached, an cúltaca taisce táirgeachta is coitianta a úsáidtear, eochracha taisce níos faide ná 250 carachtar nó ina bhfuil spás bán nó carachtair rialaithe, agus beidh eisceacht ina chúis le heochracha den sórt sin a úsáid. Chun cód taisce iniompartha a spreagadh agus iontas míthaitneamhach a íoslaghdú, eisíonn na cúltaca taisce ionsuite eile rabhadh (`django.core.cache.backends.base.cachekeyWarning`) má úsáidtear eochair a chuirfeadh earráid ar memcached.

Má tá cúltaca táirgeachta á úsáid agat ar féidir leat glacadh le raon níos leithne eochracha (cúltaca saincheaptha, nó ceann de na cúltaca neamh-mheasta), agus gur mhaith leat an raon níos leithne seo a úsáid gan rabhaidh, is féidir leat CachekeyWarning\` a thostú leis an gcód seo sa mhodúl bainistí\` de cheann de do:

```
import warnings

from django.core.cache import CacheKeyWarning

warnings.simplefilter("ignore", CacheKeyWarning)
```

Más mian leat loighic bailíochtaithe eochair saincheaptha a sholáthar ina ionad sin do cheann de na cúltaca ionsuite, is féidir leat é a fho-aicmiú, díreach an modh validate\_key a shárú, agus na treoracha chun cúltaca taisce saincheaptha a úsáid \`\_ a leanúint. Mar shampla, chun é seo a dhéanamh don chúltaca \`\`locmem\`, cuir an cód seo i modúl:

```
from django.core.cache.backends.locmem import LocMemCache

class CustomLocMemCache(LocMemCache):
    def validate_key(self, key):
        """Custom validation, raising exceptions or warnings as needed."""
        ...
```

... agus bain úsáid as an gcosán poncaigh Python chuig an rang seo sa chuid: setting: BACKEND \`de do shuíomh: \<CACHES-BACKEND\>CACHES\`.

## Tacaíocht asincrónach

Tá tacaíocht ag forbairt ag Django do chúltaca taisce asincrónacha, ach ní thacaíonn sé le caching asincrónach fós. Beidh sé ag teacht i scaoileadh amach anseo.

\<cache-basic-interface\>Tá leaganacha async ag `django.core.cache.backends.base.baseCache` de:ref: gach modh bonn \`. De réir choinbhinsiúin, tá na leaganacha asincrónacha de na modhanna go léir réamhshocraithe le \`a \`. De réir réamhshocraithe, tá na hargóintí don dá leagan mar an gcéanna:

```pycon
>>> await cache.aset("num", 1)
>>> await cache.ahas_key("num")
True
```

## Caches downstream

Go dtí seo, dhírigh an doiciméad seo ar do shonraí\* díniú\* a chaitheamh. Ach tá cineál eile caighdeáin ábhartha d'fhorbairt gréasáin freisin: caistriú arna ndéanamh ag taiscí “downstream”. Is córais iad seo a dhéanann taisce leathanaigh d'úsáideoirí fiú sula sroicheann an t-iarratas do shuíomh Gréasáin.

Seo cúpla sampla de chaches iarshrutha:

- Agus HTTP á úsáid agat, féadfaidh do: abbr: ISP (Soláthraí Seirbhíse Idirlín) \`leathanaigh áirithe a thaisceadh, mar sin má d'iarr tú leathanach ó \`\`http://example.com/\`, chuirfeadh do ISP an leathanach chugat gan rochtain a fháil go díreach ar example.com. Níl aon eolas ag cothabhálaí example.com ar an gcaistriú seo; suíonn an ISP idir example.com agus do bhrabhsálaí gréasáin, ag láimhseáil an caistriú go léir go trédhearcach. Ní féidir a chaiteáil den sórt sin indéanta faoi HTTPS toisc gur ionsaí fear sa lár a bheadh ann.
- D'fhéadfadh go mbeadh do shuíomh Gréasáin Django taobh thiar de\*cache\* seachfhreastalaí\*, mar shampla Squid Web Proxy Cache (<http://www.squid-cache.org/>), a choscann leathanaigh le haghaidh feidhmíochta. Sa chás seo, déanfadh an seachfhreastalaí gach iarratas a láimhseáil ar dtús, agus ní chuirfeadh sé chuig d'iarratas ach amháin más gá.
- Coscann do bhrabhsálaí gréasáin leathanaigh, freisin. Má sheolann leathanach gréasáin na ceanntála cuí amach, úsáidfidh do bhrabhsálaí an chóip thaisceáilte áitiúil le haghaidh iarratais ina dhiaidh sin chuig an leathanach sin, gan teagmháil a dhéanamh leis an leathanach gréasáin arís chun a fheiceáil an bhfuil athrú aige.

Is borradh deas éifeachtúlachta é an chaching anuas, ach tá contúirt ann dó: Tá difríocht idir ábhar go leor leathanaigh ghréasáin bunaithe ar fhíordheimhniú agus go leor athróg eile, agus d'fhéadfadh córais taisce a shábháil leathanaigh atá bunaithe go dall ar URLanna sonraí míchearta nó íogair a nochtadh do chuairteoirí ina dhiaidh sin ar na leathanaigh sin.

For example, if you operate a web email system, then the contents of the
"inbox" page depend on which user is logged in. If an ISP blindly cached your
site, then the first user who logged in through that ISP would have their
user-specific inbox page cached for subsequent visitors to the site. That's
not cool.

Ar ámharaí an tsaoil, soláthraíonn HTTP réiteach don fhadhb seo. Tá roinnt ceanntásca HTTP ann chun treoir a thabhairt do chaches iarshrutha a n-ábhar taisce a dhifriú ag brath ar athróga ainmnithe, agus chun meicníochtaí taiscéála a insint gan leathanaigh áirithe a thaisceadh. Breathnóimid ar chuid de na ceanntásca seo sna codanna a leanann.

## Ag baint úsáide as ceanntásca `Vary`

Sainmhíníonn an ceannteideal Vary cén ceannteideal iarratais ba chóir do mheicníocht taisce a chur san áireamh agus a eochair taisce á thógáil. Mar shampla, má bhraitheann ábhar leathanaigh ghréasáin ar rogha teanga úsáideora, deirtear go n-athraíonn an leathanach ar an teanga.

De réir réamhshocraithe, cruthaíonn córas taisce Django a heochracha taisce ag baint úsáide as an URL láncháilithe a iarrtar - m.sh., `” https://www.example.com/stories/2005/?order_by=author “`. Ciallaíonn sé seo go n-úsáidfidh gach iarratas ar an URL sin an leagan taisceáilte céanna, beag beann ar dhifríochtaí gníomhaire úsáideora amhail fianáin nó roghanna teanga. Mar sin féin, má tháirgeann an leathanach seo ábhar éagsúil bunaithe ar dhifríocht éigin i gceanntásca iarratais - mar shampla fianán, nó teanga, nó gníomhaire úsáideora - beidh ort an ceannteideal `Vary` a úsáid chun meicníochtaí caching a insint go mbraitheann aschur an leathanaigh ar na rudaí sin.

Chun é seo a dhéanamh i Django, bain úsáid as an maisitheoir amharc áisiú:func: django.views.decorators.vary.vary\_on\_headers, mar sin:

```
from django.views.decorators.vary import vary_on_headers

@vary_on_headers("User-Agent")
def my_view(request): ...
```

Sa chás seo, déanfaidh meicníocht caching (mar shampla middleware taisce Django féin) leagan ar leithligh den leathanach a thaisceadh do gach gníomhaire úsáideora uathúil.

Is é an buntáiste a bhaineann leis an maisitheoir vary\_on\_headers\` a úsáid seachas an ceannteideal `Vary` a shocrú de láimh (ag baint úsáide as response.heads \['Vary'\] = 'user-agent' \`) ná go gcuireann an maisitheoir \*\* leis an gceannteideal Vary\` (a d'fhéadfadh a bheith ann cheana féin).

Is féidir leat ceanntásca iolracha a chur chuig vary\_on\_heads () :

```
@vary_on_headers("User-Agent", "Cookie")
def my_view(request): ...
```

Insíonn sé seo do chaisceanna iarshrutha go n-athróidh ar\*an bheath\*, rud a chiallaíonn go bhfaighidh gach teaglaim de ghníomhaire úsáideora agus fianán a luach taisce féin. Mar shampla, measfar iarratas leis an ngníomhaire úsáideora `Mozilla` agus an luach fianáin `foo=bar` difriúil ó iarratas leis an ngníomhaire úsáideora `Mozilla` agus an luach fianáin `foo=ham`.

Toisc go bhfuil éagsúlacht ar fhianán chomh coitianta, tá a: func: django.views.decorators.vary.vary\_on\_cookie maisitheoir ann. Tá an dá thuairim seo coibhéiseach:

```
@vary_on_cookie
def my_view(request): ...

@vary_on_headers("Cookie")
def my_view(request): ...
```

Níl na ceanntásca a chuireann tú chuig vary\_on\_headers\` íogair do chásanna; "Gníomhaireacht úsáideora” an rud céanna le "úsáideach-gníomhaireaí".

Is féidir leat feidhm chúntóra a úsáid freisin, :func: django.utils.cache.patch\_vary\_headers, go díreach. Socraíonn an fheidhm seo, nó cuireann sé leis an “Ceannteideal éagsúla”. Mar shampla:

```
from django.shortcuts import render
from django.utils.cache import patch_vary_headers

def my_view(request):
    ...
    response = render(request, "template_name", context)
    patch_vary_headers(response, ["Cookie"])
    return response
```

Glacann `patch_vary_headers` an:class: ~django.http.http.httpResponse mar an chéad argóint agus liosta/tiúpla d'ainmneacha ceanntásc cás-neamh-íogair mar an dara argóint.

\<9110 #section -12.5.5\>Le haghaidh tuilleadh eolais faoi cheanntásca Vary, féach an:rfc: official Vary spec.

> **CacheMiddleware varies on Authorization automatically**
>
> Although varying on `Authorization` is not strictly necessary given that
> [**RFC 9111 Section 3.5**](https://datatracker.ietf.org/doc/html/rfc9111.html#section-3.5) allows caches to avoid reusing authenticated
> responses, Django's `CacheMiddleware` adds `Authorization` to the
> `Vary` header to simplify construction of cache keys.

> **Changed in Django 6.0.6**
>
> Previously, `UpdateCacheMiddleware` did not vary on `Authorization` for
> requests bearing that header.

## Taisce a rialú: Ceannteidil eile a úsáid

Is iad fadhbanna eile a bhaineann le caistriú ná príobháideacht sonraí agus an cheist cá háit ar chóir sonraí a stóráil i gcaitheamh taiscí.

De ghnáth bíonn dhá chineál taisce ag úsáideoir: taisce a bhrabhsálaí féin (taisce príobháideach) agus taisce a sholáthraí (taisce poiblí). Úsáideann iolrúsáideoirí taisce poiblí agus tá sé á rialú ag duine eile. Cuireann sé seo fadhbanna le sonraí íogair - níl tú ag iarraidh, abair, d'uimhir chuntais bhainc a stóráiltear i taisce poiblí. Mar sin teastaíonn bealach ó fheidhmchláir ghréasáin chun na sonraí atá príobháideach agus na sonraí atá poiblí a insint

Is é an réiteach ná a chur in iúl gur chóir go mbeadh taisce leathanaigh “príobháideach.” Chun é seo a dhéanamh i Django, bain úsáid as an maisitheoir amharc: :func: ~django.views.decorators.cache.cache\_control. Sampla:

```
from django.views.decorators.cache import cache_control

@cache_control(private=True)
def my_view(request): ...
```

Tugann an maisitheoir seo aire don cheannteideal HTTP cuí a sheoladh amach taobh thiar de na radhairc.

Tabhair faoi deara go bhfuil na socruithe rialaithe taisce “príobháideach” agus “poiblí” go comhpháirteach. Cinntíonn an maisitheoir go mbaintear an treoir “phoiblí” más chóir “príobháideach” a shocrú (agus a mhalairt). Bheadh úsáid samplach den dá threoir ná suíomh blag a thairgeann iontrálacha príobháideacha agus poiblí araon. Féadfar iontrálacha poiblí a stóráil ar aon taisce roinnte. Úsáideann an cód seo a leanas: func: ~django.utils.cache.patch\_cache\_control, an bealach láimhe chun an ceannteideal rialaithe taisce a mhodhnú (tugtar air go hinmheánach ag an maisitheoir:: ~django.views.decorators.cache.cache\_control):

```
from django.views.decorators.cache import patch_cache_control
from django.views.decorators.vary import vary_on_cookie

@vary_on_cookie
def list_blog_entries_view(request):
    if request.user.is_anonymous:
        response = render_only_public_entries()
        patch_cache_control(response, public=True)
    else:
        response = render_private_and_public_entries(request.user)
        patch_cache_control(response, private=True)

    return response
```

Is féidir leat taiscí iarshrutha a rialú ar bhealaí eile freisin (féach: rfc: 9111 le haghaidh sonraí faoi chaching HTTP). \<9111 #section -5.2.2.1\>Mar shampla, fiú mura n-úsáideann tú creat taisce taobh freastalaí Django, is féidir leat a rá fós do chliaint radharc a thaisceadh ar feadh méid áirithe ama leis an treor:rfc: max-age:

```
from django.views.decorators.cache import cache_control

@cache_control(max_age=3600)
def my_view(request): ...
```

(Má úsáideann t\* an middleware caching, socraíonn sé an max-aois \`\`luach an socruithe: \`CACHE\_MIDDLEWARE\_SECONDS cheana féin. Sa chás sin, beidh tosaíocht ag an maisitheoir saincheaptha max\_age óna:func: ~django.views.decorators.cache.cache\_control, agus cumasófar na luachanna ceanntásc i gceart.)

Tá aon treoir bhailí freagartha `Cache-Control` bailí i cache\_control () . Seo roinnt samplaí eile:

- `no_transform=True`
- `must_revalidate=True`
- `stale_while_revalidate=uimh_soicind`
- `no_cache=True`

Is féidir liosta iomlán na dtreoracha ar eolas a fháil sa chlárlann IANA\`\_ (tabhair faoi deara nach mbaineann gach ceann acu le freagraí).

Más mian leat ceanntásca a úsáid chun cúisceáin a dhíchumasú ar fad, is maisitheoir amharc é: :func: ~django.views.decorators.cache.never\_cache a chuireann ceanntásc leis chun a chinntiú nach ndéanfaidh brabhsálaithe nó caches eile an freagra a stóráil. Sampla:

```
from django.views.decorators.cache import never_cache

@never_cache
def myview(request): ...
```

## Ordú `MIDDLEWARE`

Má úsáideann tú middleware caching, tá sé tábhachtach gach leath a chur san áit cheart laistigh den socrú: setting: MIDDLEWARE. Sin toisc go gcaithfidh an middleware taisce a bheith ar an eolas faoi na ceannteidil trína ndéanfaidh an stóráil taisce a athrú. Cuireann Middleware rud éigin i gcónaí leis an gceannteideal freagartha Vary\` nuair is féidir leis.

Ritheann `UpdateCacheMiddleware` le linn na céime freagartha, áit a reáchtáiltear middleware in ord droim, mar sin ritheann mír ag barr an liosta\*deireana\* le linn na céime freagartha. Mar sin, ní mór duit a chinntiú go bhfeictear `UpdateCacheMiddleware` *roimh* aon mheán-earraí eile a d'fhéadfadh rud éigin a chur leis an gceannteideal `Vary`. Déanann na modúil middleware seo a leanas amhlaidh:

- Cuireann `SessionMiddleware` leis `Cookie`
- Cuireann `GZipMiddleWare` `Accept-Encoding`
- Cuireann `Localemiddleware` leis `Accept-Language`

Ar an láimh eile, ritheann `fetchfromcachemiddleware` le linn na céime iarratais, áit a gcuirtear meán-earraí i bhfeidhm den chéad uair go deireanach, mar sin ritheann mír ag barr an liosta\*an chéad\* le linn na céime iarratais. Caithfidh an `FetchFromCacheMiddleware` rith freisin tar éis lár earraí eile an ceannteideal `Vary` a nuashonrú, mar sin caithfidh `FetchfromCacheMiddleware` a bheith aith\* tar éis aon earra a dhéanann amhlaidh.