---
title: "Clibeanna teimpléad ionsuite agus scagair"
version: 6.1
locale: ga
source: https://docs.djangoproject.com/ga/6.1/ref/templates/builtins/
canonical: https://djangodocs.dev/ga/6.1/ref/templates/builtins/
---
# Clibeanna teimpléad ionsuite agus scagair

Déanann an doiciméad seo cur síos ar chlibeanna agus scagairí teimpléad ion Moltar duit an doiciméadú uathoibríoch: doc: a úsáid, má tá sé ar fáil, mar beidh cáipéisíocht ann freisin le haghaidh aon chlibeanna nó scagairí saincheaptha atá suiteáilte \</ref/contrib/admin/admindocs\>.

## Tagairt clibeanna ionsuite

### `autoescape`

Rialaíonn sé an t-iompar uathoibríoch reatha. Tógann an chlib seo `on` nó ```off ``mar argóint agus cinneann sé sin an bhfuil éalú uathoibríoch i bhfeidhm taobh istigh den bhloc. Tá an bloc dúnta le clib deireadh ``endautoescape```.

Úsáid samplach:

```html+django
{% autoescape on %}
    {{ body }}
{% endautoescape %}
```

Nuair a bhíonn éalú uathoibríoch i bhfeidhm, tá éalú HTML i bhfeidhm ag gach ábhar a dhíorthaítear ó athróga sula gcuirtear an toradh isteach san aschur (ach tar éis aon scagairí a chur i bhfeidhm). Tá sé seo comhionann leis an scagaire: tfilter: escape a chur i bhfeidhm de láimh ar gach athróg.

Is iad na heisceachtaí amháin ná athróga atá marcáilte cheana féin mar “sábháilte” ó éalú. D'fhéadfaí athróga a mharcáil mar “sábháilte” leis an gcód a rinne an athróg, tríd na scagairí:tfilter: safe nó: tfilter: escape a chur i bhfeidhm, nó toisc gurb é toradh scagaire roimhe seo a mharcálaigh an sreang mar “sábháilte”.

Laistigh de raon feidhme an éalaithe uathoibríoch faoi mhíchumas, d'fhéadfadh torthaí gan choinne (ach doiciméadaithe) mar an méid seo a leanas a bheith ina chúis le scagairí slabhraithe, lena n-áirítear: tfilter: éalú \`

```html+django
{% autoescape off %}
    {{ my_list|join:", "|escape }}
{% endautoescape %}
```

Aschróidh an cód thuas na heilimintí ceangailte de `my_list` gan éalú. Tá sé seo toisc go bhfeidhmíonn seicheamh slabhraí an scagaire ar dtús: tfilter: join ar `my_list` (gan éalú a chur i bhfeidhm ar gach mír ós rud é go bhfuil `autoescape` off ), ag marcáil an toradh mar shábháilte. Ina dhiaidh sin, cuirfear an toradh sábháilte seo chuig scagaire: tfilter: escape, nach gcuireann an dara babhta éalaithe i bhfeidhm.

D'fhonn éalú i gceart gach eilimint i seicheamh, bain úsáid as an scagair:tfilter: escapeseq:

```html+django
{% autoescape off %}
    {{ my_list|escapeseq|join:", " }}
{% endautoescape %}
```

### Bloc \`\`

Sainmhíníonn bloc is féidir le teimpléid leanaí a shárú. Féach:ref: Oidhreacht teimpléad \<template-inheritance\>\`le haghaidh tuilleadh faisnéise.

### `` `Tráchtaire ``

Déanann sé neamhaird ar gach rud idir `{% comment%}` agus `{% endcomment%}`. Féadfar nóta roghnach a chur isteach sa chéad chlib. Mar shampla, tá sé seo úsáideach agus tú ag trácht amach cód chun doiciméadú cén fáth a raibh an cód faoi dhíchumasú.

Úsáid samplach:

```html+django
<p>Rendered text with {{ pub_date|date:"c" }}</p>
{% comment "Optional note" %}
    <p>Commented out text with {{ create_date|date:"c" }}</p>
{% endcomment %}
```

Ní féidir clibeanna `tráchtaire` a neadú.

### `csrf_token`

Úsáidtear an chlib seo le haghaidh cosaint CSRF, mar a thuairiscítear sa dhoiciméadú daga:doc: Iarratas Cross Site For\</ref/csrf\> geries.

### `csp_nonce_attr`

> **New in Django 6.1**

When called without arguments, renders a `nonce="<value>"` HTML attribute
when the [`csp()`](/ga/6.1/ref/templates/api/#django.template.context_processors.csp) context processor is
configured, and an empty string otherwise. Use it in `<script>` or
`<link>` elements to allow them under a nonce-based Content Security Policy:

```html+django
<script src="/path/to/script.js" {% csp_nonce_attr %}></script>
<link rel="stylesheet" href="/path/to/style.css" {% csp_nonce_attr %}>
```

When called with a [`Media`](/ga/6.1/topics/forms/media/#django.forms.Media) object as the argument,
renders its assets with the CSP nonce applied to each `<script>` and
`<link>` element:

```html+django
{% csp_nonce_attr form.media %}
```

In both forms, if the context processor is not configured, assets are rendered
without a nonce attribute.

See [Nonce usage](/ga/6.1/ref/csp/#csp-nonce) for full configuration details.

### `rotha`

Táirgeann sé ceann dá argóintí gach uair a thagann an chlib seo. Cuirtear an chéad argóint ar an gcéad teagmháil, an dara argóint ar an dara teagmháil, agus mar sin de. Nuair a bheidh na hargóintí go léir ídithe, timthriallann an chlib go dtí an chéad argóint agus táirgeann sé ar

Tá an clib seo úsáideach go háirithe i lúb:

```html+django
{% for o in some_list %}
    <tr class="{% cycle 'row1' 'row2' %}">
        ...
    </tr>
{% endfor %}
```

Táirgeann an chéad athrú HTML a thagraíonn d'aicme `row1`, an dara ceann go `row2`, an tríú go `row1` arís, agus mar sin de do gach athrú den lúb.

Is féidir leat athróga a úsáid freisin. Mar shampla, má tá dhá athróg teimpléad agat, `rowvalue1` agus `rowvalue2`, is féidir leat a gcuid luachanna mar seo a mhalartú:

```html+django
{% for o in some_list %}
    <tr class="{% cycle rowvalue1 rowvalue2 %}">
        ...
    </tr>
{% endfor %}
```

Variables included in the cycle will be escaped. You can disable auto-escaping
with:

```html+django
{% for o in some_list %}
    <tr class="{% autoescape off %}{% cycle rowvalue1 rowvalue2 %}{% endautoescape %}">
        ...
    </tr>
{% endfor %}
```

Is féidir leat athróga agus teaghráin a mheascadh:

```html+django
{% for o in some_list %}
    <tr class="{% cycle 'row1' rowvalue2 'row3' %}">
        ...
    </tr>
{% endfor %}
```

I roinnt cásanna b'fhéidir gur mhaith leat tagairt a dhéanamh do luach reatha timthrialla gan dul chun cinn go dtí an chéad luach eile. Chun seo a dhéanamh, tabhair ainm don chlib `{% timthriall%}`, ag baint úsáide as “mar”, mar seo:

```html+django
{% cycle 'row1' 'row2' as rowcolors %}
```

Ón sin ar aghaidh, is féidir leat luach reatha an timthriall a chur isteach cibé áit ar mhaith leat i do theimpléad trí thagairt a dhéanamh ar ainm an timthriall mar athróg comhthéacs. Más mian leat an timthriall a bhogadh go dtí an chéad luach eile go neamhspleách ar an gclib “timthriall” bunaidh, is féidir leat clib timthriall\` eile a úsáid agus ainm an athróg a shonrú. Mar sin, an teimpléad seo a leanas:

```html+django
<tr>
    <td class="{% cycle 'row1' 'row2' as rowcolors %}">...</td>
    <td class="{{ rowcolors }}">...</td>
</tr>
<tr>
    <td class="{% cycle rowcolors %}">...</td>
    <td class="{{ rowcolors }}">...</td>
</tr>
```

bheadh aschur:

```html+django
<tr>
    <td class="row1">...</td>
    <td class="row1">...</td>
</tr>
<tr>
    <td class="row2">...</td>
    <td class="row2">...</td>
</tr>
```

Is féidir leat aon líon luachanna a úsáid i gclib ```` timthriall`, atá scartha le spásanna. Déileáltar le luachanna atá iargúlta i luachana aonair (``` ````) nó i luachana dúbailte (`` ` ``) mar litríochtaí teaghrán, agus déileáltar le luachanna gan luachanna mar athróga teimpléid.

De réir réamhshocraithe, nuair a úsáideann tú an eochairfhocal ```as ``leis an gclib timthriall, táirgfidh úsáid``` {% timthriall%} ```a thosaíonn an timthriall an chéad luach sa timthriall féin. D'fhéadfadh sé seo a bheith ina fhadhb más mian leat an luach a úsáid i lúb neadaithe nó teimpléad san áireamh. Mura dteastaíonn uait ach an timthriall a dhearbhú ach gan an chéad luach a tháirgeadh, is féidir leat eochairfhocal ``ciúna``` a chur leis mar an eochairfhocal deireanach sa chlib. Mar shampla:

```html+django
{% for obj in some_list %}
    {% cycle 'row1' 'row2' as rowcolors silent %}
    <tr class="{{ rowcolors }}">{% include "subtemplate.html" %}</tr>
{% endfor %}
```

Aschróidh sé seo liosta d'eilimintí \`\` le `aic <tr>me` malartach idir `sraith 1` agus `row2`. \<tr\>Beidh rochtain ag an bhfotheimpléad ar ``` rowdats' ina chomhthéacs agus meaitneoidh an luach le rang an `` ``` a chuimsíonn sé. \<tr\>Dá ndéanfaí an eochairfhocal `ciúna` a fhágáil, astófaí `sraith 1` agus `row2` mar ghnáththéacs, lasmuigh den eilimint .

Nuair a úsáidtear an eochairfhocal ciúin ar shainiú timthriall, baineann an tost go huathoibríoch le gach úsáid ina dhiaidh sin den chlib timthriall sonrach sin. Ní chuirfeadh an teimpléad seo a leanas aschuir\* rud ar bith, cé nach sonraíonn an dara glao chuig `{% timthriall%}` `ciúna`:

```html+django
{% cycle 'row1' 'row2' as rowcolors silent %}
{% cycle rowcolors %}
```

Is féidir leat an clibe:ttag: resetcycle a úsáid chun clib `{% cycle%}` a atosú óna chéad luach nuair a bhíonn sé amach romhainn.

### `Debug`

Aisíonn sé ualach iomlán faisnéise dífhabhtaithe, lena n-áirítear an comhthéacs reatha agus modúil allmhairithe. ``{% debug%} `ní aschuireann`` {% debug%} ``aon rud nuair is é an socrú:setting: `DEBUG` `False``.

### `síneamh`

Comharthaíonn sé go leathnaíonn an teimpléad seo teimpléad

Is féidir an chlib seo a úsáid ar dhá bhealach:

- ``{% leathnaíonn "base.html"%} `(le luachana) úsáideann an luach liteartha``” base.html “mar ainm an teimpléad tuismitheora le leathnú.
- ```{% leathnaíonn athróg%} `úsáideann luach ``inathraithe```. Má dhéanann an t-athróg meastóireacht ar shreang, úsáidfidh Django an sreang sin mar ainm an teimpléid tuismitheora. Má dhéanann an t-athróg meastóireacht ar réad Teimpléad\`, úsáidfidh Django an réad sin mar an teimpléad tuismitheora.

Féach:ref: template-heritance le haghaidh tuilleadh faisnéise.

De ghnáth bíonn ainm an teimpléid i gcoibhneas le eolaire fréimhe an lódóra Féadfaidh argóint teaghrán a bheith ina cosán coibhneasta freisin ag tosú le ./\` nó `.. /`. Mar shampla, glacadh leis an struchtúr eolaire seo a leanas:

```text
dir1/
    template.html
    base2.html
    my/
        base3.html
base1.html
```

I template.html\`, bheadh na cosáin seo a leanas bailí:

```html+django
{% extends "./base2.html" %}
{% extends "../base1.html" %}
{% extends "./my/base3.html" %}
```

### `Scagair`

Scagann ábhar an bhloc trí scagaire amháin nó níos mó. Is féidir scagairí iolracha a shonrú le píopaí agus is féidir argóintí a bheith ag scagairí, díreach mar atá i gcomhré

Tabhair faoi deara go gcuimsíonn an bloc *uach* an téacs idir na clibeanna `filter` agus `endfilter`.

Úsáid samplach:

```html+django
{% filter force_escape|lower %}
    This text will be HTML-escaped, and will appear in all lowercase.
{% endfilter %}
```

> **Note**
>
> Ní argóintí inghlactha iad scagairí:tfilter: escape agus:tfilter: safe. Ina áit sin, bain úsáid as an clibe:ttag: autoescape chun autoescaping a bhainistiú le haghaidh bloic cód teimpléad.

### `Firstoff`

Aschur an chéad athróg argóint nach bhfuil “bréagach” (ie ann, níl folamh, ní luach bréagach boolean é, agus ní luach uimhriúil nialasach é). Ní aschur aon rud mura bhfuil na hathróga rithaithe go léir “bréagach”.

Úsáid samplach:

```html+django
{% firstof var1 var2 var3 %}
```

Tá sé seo coibhéiseach le:

```html+django
{% if var1 %}
    {{ var1 }}
{% elif var2 %}
    {{ var2 }}
{% elif var3 %}
    {{ var3 }}
{% endif %}
```

Is féidir leat teaghrán litriúil a úsáid freisin mar luach titim i gcás go bhfuil gach athróg rith bréagach:

```html+django
{% firstof var1 var2 var3 "fallback value" %}
```

Éalaíonn an chlib seo luachanna athraitheacha go huathoibr Is féidir leat éalú uathoibríoch a dhíchumasú le

```html+django
{% autoescape off %}
    {% firstof var1 var2 var3 "<strong>fallback value</strong>" %}
{% endautoescape %}
```

Nó mura chóir ach roinnt athróg a éalú, is féidir leat úsáid a bhaint as:

```html+django
{% firstof var1 var2|safe var3 "<strong>fallback value</strong>"|safe %}
```

Is féidir leat an comhréir `{% firstof var1 var2 var3 a úsáid mar luach%}` chun an t-aschur a stóráil taobh istigh d'athróg.

### Invalid section title or transition marker.

Lúbanna thar gach mír in eagar, rud a fhágann go bhfuil an mír ar fáil in athróg comhthéacs. Mar shampla, chun liosta lúthchleasaithe a chuirtear ar fáil in athlete\_list\` a thaispeáint:

```html+django
<ul>
{% for athlete in athlete_list %}
    <li>{{ athlete.name }}</li>
{% endfor %}
</ul>
```

Is féidir leat lúb thar liosta ar ais trí úsáid a bhaint as `{% le haghaidh obj i liosta aisiompthe%}`.

Más gá duit lúb a dhéanamh thar liosta liostaí, is féidir leat na luachanna i ngach suliosta a dhíphacáil in athróga aonair. Mar shampla, má tá liosta de chomhordanáidí (x, y) ar a dtugtar pointí i do chomhthéacs, d'fhéadfá an méid seo a leanas a úsáid chun an liosta pointí a aschur:

```html+django
{% for x, y in points %}
    There is a point at {{ x }},{{ y }}
{% endfor %}
```

Is féidir leis seo a bheith úsáideach freisin más gá duit rochtain a fháil ar na míreanna i bhfoclóir. Mar shampla, dá mbeadh foclóir sonraí i do chomhthéacs, taispeánfaí eochracha agus luachanna an fhoclóra seo a leanas:

```html+django
{% for key, value in data.items %}
    {{ key }}: {{ value }}
{% endfor %}
```

Coinnigh i gcuimhne go bhfuil tosaíocht ag cuardach eochair foclóra maidir leis an oibreoir ponc seachas cuardach modhanna. Dá bhrí sin má tá eochair darb ainm ```'items' sa fhoclóir ``sonra```, cuirfidh data.items\` ar ais ```data ['items'] ``in ionad ``data.items ()```. Seachain eochracha a ainmnítear cosúil le modhanna foclóra a chur leis más mian leat na modhanna sin a úsáid i dteimpléad (earraí \`, luacha\`, eochair\`, srl.). \<template-variables\>Léigh tuilleadh faoi ord cuardaigh an oibreora ponc in:ref: doiciméadú athróga teimpléad.

Socraíonn an lúb for roinnt athróg atá ar fáil laistigh den lúb:

| Athraitheach | Cur síos |
| --- | --- |
| `forloop.counter` | Athraitheadh reatha an lúb (1-innéacsaithe) |
| `forloop.counter0` | An t-athrú reatha ar an lúb (0-innéacsaithe) |
| `forloop.revcounter` | Líon na n-athrá ó dheireadh an lúb (1-innéacsaithe) |
| `forloop.revcounter0` | Líon na n-athrá ó dheireadh an lúb (0-innéacsaithe) |
| `forloop.first` | Fíor más é seo an chéad uair tríd an lúb |
| forloop.last \`\` | Fíor más é seo an uair dheireanach tríd an lúb |
| `forloop.length` | The length of the loop |
| `forloop.parentloop` | Maidir le lúb neadaithe, is é seo an lúb timpeall leis an gceann reatha |

> **Changed in Django 6.0**
>
> The variable `forloop.length` was added.

### ``` `` ```... `folam`

Is féidir leis an gclib `for` clásal roghnach `{% folamh%}` a thógáil a thaispeántar a théacs má tá an eagar tugtha folamh nó mura bhféadfaí é a aimsiú:

```html+django
<ul>
{% for athlete in athlete_list %}
    <li>{{ athlete.name }}</li>
{% empty %}
    <li>Sorry, no athletes in this list.</li>
{% endfor %}
</ul>
```

Tá an méid thuas comhionann le - ach níos giorra, níos glaine, agus b'fhéidir níos gasta ná - an méid seo a leanas:

```html+django
<ul>
  {% if athlete_list %}
    {% for athlete in athlete_list %}
      <li>{{ athlete.name }}</li>
    {% endfor %}
  {% else %}
    <li>Sorry, no athletes in this list.</li>
  {% endif %}
</ul>
```

### má \`

Déanann an chlib `{% if%}` meastóireacht ar athróg, agus má tá an athróg sin “fíor” (ie ann, níl sé folamh, agus ní luach boolean bréagach é) tá ábhar an bhloc aschur:

```html+django
{% if athlete_list %}
    Number of athletes: {{ athlete_list|length }}
{% elif athlete_in_locker_room_list %}
    Athletes should be out of the locker room soon!
{% else %}
    No athletes.
{% endif %}
```

Sa mhéid thuas, mura bhfuil `athlete_list` folamh, taispeánfar líon na lúthchleasaithe ag an athróg `{{athlete_list|length}}`.

Mar a fheiceann tú, féadfaidh clásal ``{% elif%} `amháin nó roinnt clásal`` {% elif%} `a thógáil, chomh maith le clásal` {% else%} a thaispeánfar má theipeann ar gach coinníoll roimhe seo. Tá na clásail seo roghnach.

#### Oibreoirí Boolean

[`if`](#std-templatetag-if) tags may use `and`, `or` or `not` to test a number of
variables or to negate a given variable:

```html+django
{% if athlete_list and coach_list %}
    Both athletes and coaches are available.
{% endif %}

{% if not athlete_list %}
    There are no athletes.
{% endif %}

{% if athlete_list or coach_list %}
    There are some athletes or some coaches.
{% endif %}

{% if not athlete_list or coach_list %}
    There are no athletes or there are some coaches.
{% endif %}

{% if athlete_list and not coach_list %}
    There are some athletes and absolutely no coaches.
{% endif %}
```

Ceadaítear clásail ```agus ``nó ``araon a úsáid laistigh den chlib céanna, agus tosaíocht níos airde ag ``agus``` ná nó \`, m.sh.:

```html+django
{% if athlete_list and coach_list or cheerleader_list %}
```

léirmhínítear mar:

```
if (athlete_list and coach_list) or cheerleader_list:
    ...
```

Úsáid lúibíní iarbhír sa chlib: ttag: if is comhréir neamhbhailí. Má theastaíonn uait chun tosaíocht a léiriú, ba cheart duit clibeanna nested:ttag: if a úsáid.

[`if`](#std-templatetag-if) tags may also use the operators `==`, `!=`, `<`, `>`,
`<=`, `>=`, `in`, `not in`, `is`, and `is not` which work as
follows:

##### `==` oibreoir

Comhionannas. Sampla:

```html+django
{% if somevar == "x" %}
  This appears if variable somevar equals the string "x"
{% endif %}
```

##### `! =` oibreoir

Éagothroime. Sampla:

```html+django
{% if somevar != "x" %}
  This appears if variable somevar does not equal the string "x",
  or if somevar is not found in the context
{% endif %}
```

##### `<` oibreoir

Níos lú ná. Sampla:

```html+django
{% if somevar < 100 %}
  This appears if variable somevar is less than 100.
{% endif %}
```

##### `>` oibreoir

Níos mó ná. Sampla:

```html+django
{% if somevar > 0 %}
  This appears if variable somevar is greater than 0.
{% endif %}
```

##### `<=` oibreoir

Níos lú ná nó cothrom le. Sampla:

```html+django
{% if somevar <= 100 %}
  This appears if variable somevar is less than 100 or equal to 100.
{% endif %}
```

##### `>=` oibreoir

Níos mó ná nó comhionann leis. Sampla:

```html+django
{% if somevar >= 1 %}
  This appears if variable somevar is greater than 1 or equal to 1.
{% endif %}
```

##### Oibreoir `in`

Ag fáil laistigh. Tacaíonn go leor coimeádáin Python leis an oibreoir seo chun tástáil a dhéanamh an bhfuil an luach a thugtar sa choimeádán. Seo a leanas roinnt samplaí den chaoi a léirmhínítear `x in y`:

```html+django
{% if "bc" in "abcdef" %}
  This appears since "bc" is a substring of "abcdef"
{% endif %}

{% if "hello" in greetings %}
  If greetings is a list or set, one element of which is the string
  "hello", this will appear.
{% endif %}

{% if user in users %}
  If users is a QuerySet, this will appear if user is an
  instance that belongs to the QuerySet.
{% endif %}
```

##### Oibreoir nach bhfuil i \`

Níl ann laistigh. Is é seo diúltú an oibreora `in`.

##### Is oibreoir

Féiniúlacht réada. Tástálacha má tá dhá luach an réad céanna. Sampla:

```html+django
{% if somevar is True %}
  This appears if and only if somevar is True.
{% endif %}

{% if somevar is None %}
  This appears if somevar is None, or if somevar is not found in the context.
{% endif %}
```

##### ní 'oibreoir'

Féiniúlacht réad diúltaithe. Tástálacha mura bhfuil dhá luach an rud céanna. Is é seo diúltú an oibreora is . Sampla:

```html+django
{% if somevar is not True %}
  This appears if somevar is not True, or if somevar is not found in the
  context.
{% endif %}

{% if somevar is not None %}
  This appears if and only if somevar is not None.
{% endif %}
```

#### Scagairí

Is féidir leat scagairí a úsáid freisin sa léir:ttag: if . Mar shampla:

```html+django
{% if messages|length >= 100 %}
   You have lots of messages today!
{% endif %}
```

#### Nathanna casta

Is féidir gach ceann de na nithe thuas a chomhcheangal chun nathanna casta a fhoirmiú Maidir le nathanna den sórt sin, d'fhéadfadh sé a bheith tábhachtach a fháil amach conas a ghrúpáiltear na hoibreoirí nuair a dhéantar an abairt a mheas - is é sin, na rialacha tosaíochta. Is é seo a leanas tosaíocht na n-oibreoirí, ón ísle go dtí an airde:

- nó \`\`
- agus \`\`
- `` `ní ``
- `in`
- `==`, `! =`, `<`, \>\`, \<=\`, `>=`, `>=`

(Leanann sé seo Python go díreach). Mar sin, mar shampla, an casta seo a leanas: ttag: if tag:

```html+django
{% if a == b or c == d and e %}
```

Déanfar... léirmhíniú mar:

```python
(a == b) or ((c == d) and e)
```

Má theastaíonn tosaíocht dhifriúil uait, beidh ort clibeanna nested:ttag: if a úsáid. Uaireanta bíonn sé sin níos fearr le haghaidh soiléireachta ar aon nós, ar mhaithe leo siúd nach bhfuil a fhios acu na rialacha tosaíochta.

Ní féidir na hoibreoirí comparáide a 'slabhraithe' cosúil le Python nó i nótaí matamaitice. Mar shampla, in ionad úsáid a bhaint as:

```html+django
{% if a > b > c %}  (WRONG)
```

ba chóir duit úsáid a bhaint as:

```html+django
{% if a > b and b > c %}
```

### má athraíthí'

Seiceáil an bhfuil luach athraithe ón athrú deireanach de lúb.

Úsáidtear an chlib bloc `{% ifchanged%}` laistigh de lúb. Tá dhá úsáid féideartha aige.

1. Seiceálann sé a ábhar rindreáilte féin i gcoinne a staid roimhe seo agus ní thaispeánann sé an t-ábhar ach má Mar shampla, taispeánann sé seo liosta laethanta, ag taispeáint an mhí ach má athraíonn sé:

   ```html+django
   <h1>Archive for {{ year }}</h1>

   {% for date in days %}
       {% ifchanged %}<h3>{{ date|date:"F" }}</h3>{% endifchanged %}
       <a href="{{ date|date:"M/d"|lower }}/">{{ date|date:"j" }}</a>
   {% endfor %}
   ```
2. Má thugtar athróg amháin nó níos mó, seiceáil an bhfuil athróg ar bith athraithe. Mar shampla, taispeánann an méid seo a leanas an dáta gach uair a athraíonn sé, agus an uair a thaispeánann sé má athraigh an uair an chloig nó an dáta:

   ```html+django
   {% for date in days %}
       {% ifchanged date.date %} {{ date.date }} {% endifchanged %}
       {% ifchanged date.hour date.date %}
           {{ date.hour }}
       {% endifchanged %}
   {% endfor %}
   ```

Is féidir leis an gclib if changed clásal roghnach {% else%} a thógáil freisin a thaispeánfar mura bhfuil an luach athraithe:

```html+django
{% for match in matches %}
    <div style="background-color:
        {% ifchanged match.ballot_id %}
            {% cycle "red" "blue" %}
        {% else %}
            gray
        {% endifchanged %}
    ">{{ match }}</div>
{% endfor %}
```

### san áireamh \`\`

Luchtaíonn sé teimpléad agus déanann sé leis an gcomhthéacs reatha é. Is bealach é seo chun teimpléid eile a “áireamh” laistigh de theimpléad.

The template name can either be a variable or a hardcoded (quoted) string,
in either single or double quotes.

Cuimsíonn an sampla seo ábhar an teimpléid `” foo/bar.html “`:

```html+django
{% include "foo/bar.html" %}
```

De ghnáth bíonn ainm an teimpléid i gcoibhneas le eolaire fréimhe an lódóra Féadfaidh argóint teaghrán a bheith ina cosán coibhneasta freisin ag tosú le `./` nó `.. /` mar a thuairiscítear sa chlibe:ttag: extens.

Cuimsíonn an sampla seo ábhar an teimpléid a bhfuil a ainm san athróg `template_name`:

```html+django
{% include template_name %}
```

Féadfaidh an t-athróg a bheith ina rud ar bith le modh render () \`\`a ghlacann le comhthéacs. Ligeann sé seo duit tagairt a thabhairt do \`\`Teimpléad tiomsaithe i do chomhthéacs.

Ina theannta sin, d'fhéadfadh go mbeadh an t-athróg ina athraitheach d'ainmneacha teimpléad, agus sa chás sin úsáidfear an chéad cheann is féidir a luchtú, mar per:func: ~django.template.loader.select\_template.

Déantar teimpléad san áireamh ar fáil laistigh de chomhthéacs an teimpléid a chuimsíonn é. Táirgeann an sampla seo an t-aschur "Dia duit, John!” :

- Comhthéacs: tá athróg ``` `duine ``socraithe go ``"John" ``` agus socraítear athróg `` `gránt `` go `` `Hello" ``.
- Teimpléad:

  ```html+django
  {% include "name_snippet.html" %}
  ```
- An teimpléad `name_snippet.html`:

  ```html+django
  {{ greeting }}, {{ person|default:"friend" }}!
  ```

Is féidir leat comhthéacs breise a chur ar aghaidh chuig an teimpléad ag baint úsáide as

```html+django
{% include "name_snippet.html" with person="Jane" greeting="Hello" %}
```

Más mian leat an comhthéacs a rinneadh ach leis na hathróga a chuirtear ar fáil (nó fiú gan aon athróg ar chor ar bith), bain úsáid as an rogha amháin . Níl aon athróga eile ar fáil don teimpléad san áireamh:

```html+django
{% include "name_snippet.html" with greeting="Hi" only %}
```

> **Note**
>
> Ba chóir an clibe:ttag: include a mheas mar chur i bhfeidhm ar “render this fotheimpléad agus cuir san áireamh an HTML”, ní mar “an fotheimpléad seo a pháirseáil agus a ábhar a chur san áireamh amhail is dá mba chuid den tuismitheoir é”. Ciallaíonn sé seo nach bhfuil aon stát roinnte idir teimpléid san áireamh - is próiseas rindreála go hiomlán neamhspleách é gach áireamh.
>
> Déantar meastóireacht ar bhloic\* roimh\* tá siad san áireamh. Ciallaíonn sé seo go mbeidh bloic a rinneadh meastóireacht agus rinneadh a rinneadh cheana\* i teimpléad a chuimsíonn bloic ó cheann eile - ní bloic ar féidir, mar shampla, teimpléad leathnaithe a shárú.

### `` `ualach ``

Luchtaíonn sé tacar clib teimpléad saincheaptha.

Mar shampla, luchtálfadh an teimpléad seo a leanas na clibeanna agus na scagairí go léir atá cláraithe i `somelibrary` agus ```leabharlann eile ``atá lonnaithe i bpacáiste ``pacáist```:

```html+django
{% load somelibrary package.otherlibrary %}
```

Is féidir leat scagairí nó clibeanna aonair ó leabharlann a luchtú go roghnach freisin, ag baint úsáide as an argóint ```ó ``. Sa sampla seo, luchtálfar na clibeanna/scagairí teimpléad darb ainm ``foo``` agus `bar` ó somelibrary\`:

```html+django
{% load foo bar from somelibrary %}
```

Féach: doc: Clib saincheaptha agus leabharlanna scagair' le haghaidh tuilleadh faisnéise. \</howto/custom-template-tags\>

### `Lorem`

Taispeánann sé téacs Laidineach randamach “torem ipsum”. Tá sé seo úsáideach chun sonraí samplacha a sholáthar i dteimpléid.

Úsáid:

```html+django
{% lorem [count] [method] [random] %}
```

Is féidir an chlib `{% lorem%}` a úsáid le nialas, aon, dhá nó trí argóint. Is iad na hargóintí:

| Argóint | Cur síos |
| --- | --- |
| `comhaireant` | Uimhir (nó athróg) ina bhfuil líon na míreanna nó na bhfocal le giniúint (is é 1 réamhshocraithe). |
| `modh` | Ceachtar `w` le haghaidh focail, `p` do mhíreanna HTML nó `b` do mbloic mhír gnáthtéacs (is é `b` réamhshocraithe ná `b`). |
| `randam` | An focal `randam`, nach n-úsáideann an mhír choiteann (“Lorem ipsum dolor sit amet...”) agus téacs á ghiniúint. |

Samplaí:

- `{% lorem%}` aschur an mhír choitianta “lorem ipsum”.
- \<p\>Aschur `` {% lorem 3 p%} `an mhír choitianta “lorem ipsum” agus dhá mhír randamach gach ceann atá fillte i gclibeanna HTML` ``.
- Aschur `{% lorem 2 w randamach%}` dhá fhocal randamacha Laidine.

### `anois`

Taispeánann sé an dáta agus/nó an t-am reatha, ag baint úsáide as formáid de réir an teaghrán tugtha. Is féidir carachtair sonraitheoirí formáide a bheith i sreang den sórt sin mar a thuairiscítear sa chuid scagaire: tfilter: dáta.

Sampla:

```html+django
It is {% now "jS F Y H:i" %}
```

Tabhair faoi deara gur féidir leat teaghrán formáide a éalú ar ais más mian leat an luach “amh” a úsáid. Sa sampla seo, tá “o” agus “f” araon éalaithe le cúltaca, mar ar shlí eile is teaghrán formáide é gach ceann acu a thaispeánann an bhliain agus an t-am, faoi seach:

```html+django
It is the {% now "jS \o\f F" %}
```

Taispeánfaí sé seo mar “Is é an 4 Meán Fómhair é”.

> **Note**
>
> Is féidir leis an bhformáid a rith a bheith ar cheann de na cinn réamhshainithe freisin: setting: DATE\_FORMAT, :setting: DATETIME\_FORMAT, :setting: SHORT\_DATE\_FORMAT nó:setting: SHORT\_DATETIME\_FORMAT. Féadfaidh na formáidí réamhshainithe a bheith éagsúil ag brath ar an áitiúil reatha agus má tá: doc: /topics/i18n/formatting cumasaithe, m.sh.:
>
> ```html+django
> It is {% now "SHORT_DATETIME_FORMAT" %}
> ```

Is féidir leat an comhréir `{% now “Y” a úsáid mar current_year%}` chun an t-aschur (mar shreang) a stóráil taobh istigh d'athróg. Tá sé seo úsáideach más mian leat `{% now%}` a úsáid taobh istigh de chlib teimpléad cosúil:ttag: blocktranslate mar shampla:

```html+django
{% now "Y" as current_year %}
{% blocktranslate %}Copyright {{ current_year }}{% endblocktranslate %}
```

### `partial`

> **New in Django 6.0**

Renders a template fragment that was defined with [`partialdef`](#std-templatetag-partialdef), inserting
the matching partial at this location.

Úsáid:

```html+django
{% partial partial_name %}
```

The `partial_name` argument is the name of the template fragment to render.

In the following example, a partial named `button` is defined and then
rendered three times:

```html+django
{% partialdef button %}
    <button>Submit</button>
{% endpartialdef %}

{% partial button %}
{% partial button %}
{% partial button %}
```

### `partialdef`

> **New in Django 6.0**

Defines a reusable template fragment that can be rendered multiple times within
the same template or accessed directly via [template loading or inclusion](/ga/6.1/ref/templates/language/#template-partials-direct-access).

Úsáid:

```html+django
{% partialdef partial_name %}
    {# Reusable content. #}
{% endpartialdef %}
```

The `partial_name` argument is required and must be a valid template
identifier.

In the following example, a new fragment named `card` is defined:

```html+django
{% partialdef card %}
    <div class="card">
        <h3>{{ title }}</h3>
        <p>{{ content }}</p>
    </div>
{% endpartialdef %}
```

This partial can then be rendered using the [`partial`](#std-templatetag-partial) tag:

```html+django
{% partial card %}
{% partial card %}
```

To [render a fragment immediately in place](/ga/6.1/ref/templates/language/#template-partials-inline),
use the `inline` option. The partial is still stored and can be reused later.

### `ceisteanna ceiste`

Aschur sreang ceisteanna formáidithe ionchódaithe URL bunaithe ar na paraiméadair a chuirtear ar fáil.

This tag accepts positional arguments, which must be mappings (such as
[`QueryDict`](/ga/6.1/ref/request-response/#django.http.QueryDict) or [`dict`](https://docs.python.org/3/library/stdtypes.html#dict)). If no positional arguments
are provided, [`request.GET`](/ga/6.1/ref/request-response/#django.http.HttpRequest.GET) is used as the
default to construct the query string.

Positional arguments are processed sequentially, while keyword arguments are
treated as key-value pairs, applied last. Later arguments take precedence over
earlier ones, ensuring the most recent pairs are reflected in the final result.

The result always includes a leading `"?"` since this tag is mainly used for
links, and an empty result could prevent the page from reloading as expected.

> **Ag baint úsáide as request.get mar réamhshocraithe**
>
> Chun `request.get` a úsáid mar shampla réamhshocraithe `QueryDict`, ba chóir an próiseálaí comhthéacs `django.template.context_processors.request` a chumasú. Mura bhfuil sé cumasaithe, ní mór duit an réad iarraidh\` a chur go sainráite isteach i gcomhthéacs an teimpléid, nó sampla QueryDict' a sholáthar don chlib seo.

> **Changed in Django 6.0**
>
> A `?` was prepended to the query string for empty results.

#### Úsáid bunúsach

```html+django
{% querystring %}
```

Outputs the current query string verbatim. So if the query string in the
request is `?color=green`, the output would be `?color=green`. If the
current query string is empty, the output will be `?`.

```html+django
{% querystring size="M" %}
```

Aisíonn sé an teaghrán fiosrúcháin reatha leis an bparaiméadar méid a chur leis. Tar éis an sampla roimhe seo, bheadh an t-aschur ? Dath = glas & Méid = M .

#### Míreanna a shocrú

```html+django
{% querystring color="red" size="S" %}
```

Cuireann sé nó modhnóidh sé paraiméadair sa sreang fiosrúcháin. Cuirfear gach argóint eochairfhocal leis an sreangán fiosrúcháin, ag ionad aon luach atá ann cheana don eochair sin. Mar shampla, más é ```an teaghrán ceisteanna reatha? dath = glas ``, beidh an t-aschur```? Dath = dearg & Méid = S .

#### Míreanna a bhaint

```html+django
{% querystring color=None %}
```

Ag dul ```None ``mar an luach baineann an paraiméadar ón sreang fiosrúcháin. Mar shampla, más é ``an teaghrán fiosrúcháin reatha? Dath = glas & méid = M ``, beidh an t-aschur```? Méid = m .

#### Liosta láimhseála

```html+django
{% querystring color=my_list %}
```

Má tá `my_list` `["dearg”, “gorm"]`, beidh an t-aschur ? color = red&color = gorm , ag caomhnú struchtúr an liosta sa sreang ceisteanna.

#### Customizing the base QueryDict

You can pass custom `QueryDict` or `dict` instances as positional arguments
to replace `request.GET`. When multiple arguments are provided, key-value
pairs from later arguments take precedence over earlier ones.

For example, if `my_query_dict` is `<QueryDict: {'color': ['blue'], 'size':
['S']}>` and `my_dict` is `{'color': 'orange', 'fabric': 'silk', 'type':
'dress'}`, this outputs `?color=orange&size=S&fabric=silk`.

```html+django
{% querystring my_query_dict my_dict size="S" type=None %}
```

If all keys are removed by setting them to `None`, this outputs `?`:

```html+django
{% querystring my_query_dict my_dict color=None size=None fabric=None type=None %}
```

Similarly, if all positional arguments are empty and keyword arguments do not
contribute any new params, the output will also be `?`.

> **Changed in Django 6.0**
>
> Support for multiple positional mapping arguments was added.

#### Úsáid dinimiciúil

Sampla coitianta den chlib seo a úsáid is ea an sreang ceisteanna reatha a chaomhnú agus leathanach torthaí á thaispeáint, agus nasc á chur leis na chéad leathanaigh eile agus roimhe seo de na torthaí. Mar shampla, má tá an paginator ar leathanach 3 faoi láthair, agus is é an teaghrán ceisteanna reatha `? color=gorm&size = M&page = 3`, aschur an cód seo a leanas `? Dath = gorm&méid = M & page = 4`:

```html+django
{% querystring page=page.next_page_number %}
```

Is féidir leat an luach a stóráil in athróg freisin. Mar shampla, má theastaíonn iliomad naisc uait leis an leathanach céanna, sainmhínigh é mar:

```html+django
{% querystring page=page.next_page_number as next_page %}
```

### `athghrúpa`

Athghrúpaíonn sé liosta de na rudaí céanna de réir tréith choiteann.

Is fearr an chlib casta seo a léiriú trí shampla: abair gur liosta cathracha é cathracha a léiríonn foclóirí ina bhfuil \`"ainm"```, ``daonra"```, agus tír" eochracha:

```python
cities = [
    {"name": "Mumbai", "population": "19,000,000", "country": "India"},
    {"name": "Calcutta", "population": "15,000,000", "country": "India"},
    {"name": "New York", "population": "20,000,000", "country": "USA"},
    {"name": "Chicago", "population": "7,000,000", "country": "USA"},
    {"name": "Tokyo", "population": "33,000,000", "country": "Japan"},
]
```

... agus ba mhaith leat liosta ordlathach a ordaítear de réir tíre a thaispeáint, mar seo:

- An India

  - Mumbai: 19,000,000
  - Calcutta: 15,000,000
- STÁIT AONTAITHE

  - Nua Eabhrac: 20,000,000
  - Chicago: 7,000,000
- An tSeapáin

  - Tóiceo: 33,000,000

Is féidir leat an chlib `{% regroup%}` a úsáid chun liosta na gcathracha a ghrúpáil de réir tíre. Chuirfeadh an snippet seo a leanas de chód teimpléid i gcrích é seo:

```html+django
{% regroup cities by country as country_list %}

<ul>
{% for country in country_list %}
    <li>{{ country.grouper }}
    <ul>
        {% for city in country.list %}
          <li>{{ city.name }}: {{ city.population }}</li>
        {% endfor %}
    </ul>
    </li>
{% endfor %}
</ul>
```

Siúlóimid tríd an sampla seo. `{% regroup%}` tógann trí argóint: an liosta is mian leat a athghrúpáil, an tréith le grúpáil leis, agus ainm an liosta mar thoradh air. Anseo, táimid ag athghrúpáil an liosta `cathr` de réir an tréith ``` `country ``agus glaoimid ar an toradh ``lista_country ```.

`{% regroup %}` produces a list (in this case, `country_list`) of
**group objects**. Group objects are instances of
[`namedtuple()`](https://docs.python.org/3/library/collections.html#collections.namedtuple) with two fields:

- `Grúpa` \- an mír a rinneadh grúpáil le (m.sh., an sreang “India” nó “An tSeapáin”).
- `liosta` \- liosta de na míreanna uile sa ghrúpa seo (m.sh., liosta de na cathracha go léir le tír = 'India').

Because `{% regroup %}` produces [`namedtuple()`](https://docs.python.org/3/library/collections.html#collections.namedtuple) objects,
you can also write the previous example as:

```html+django
{% regroup cities by country as country_list %}

<ul>
{% for country, local_cities in country_list %}
    <li>{{ country }}
    <ul>
        {% for city in local_cities %}
          <li>{{ city.name }}: {{ city.population }}</li>
        {% endfor %}
    </ul>
    </li>
{% endfor %}
</ul>
```

Tabhair faoi deara nach n-ordaíonn `{% regroup%}` a ionchur! Braitheann ár sampla ar an bhfíric gur ordaigh “tír” an liosta `cathr` sa chéad áit. Dá n-ordódh liosta na cathracha \`\`\`\`\`\`\`\`\`\`\`\`\`\`\`baill \`\`\`\`\`\`\`\`\`\`\`\`\`\`\`\`\`\`\`\`\`\`, ní dhéanfadh an t-athghrúpáil níos mó ná grúpa amháin go naif do thír amháin. Mar shampla, abair go raibh an liosta cathracha socraithe chuige seo (tabhair faoi deara nach bhfuil na tíortha grúpáilte le chéile):

```python
cities = [
    {"name": "Mumbai", "population": "19,000,000", "country": "India"},
    {"name": "New York", "population": "20,000,000", "country": "USA"},
    {"name": "Calcutta", "population": "15,000,000", "country": "India"},
    {"name": "Chicago", "population": "7,000,000", "country": "USA"},
    {"name": "Tokyo", "population": "33,000,000", "country": "Japan"},
]
```

Leis an ionchur seo do cathracha \`, bheadh an t-aschur seo a leanas mar thoradh ar an gcód teimpléad\`\` {% athghrúpaí%} thuas:

- An India

  - Mumbai: 19,000,000
- STÁIT AONTAITHE

  - Nua Eabhrac: 20,000,000
- An India

  - Calcutta: 15,000,000
- STÁIT AONTAITHE

  - Chicago: 7,000,000
- An tSeapáin

  - Tóiceo: 33,000,000

Is é an réiteach is éasca ar an gotcha seo ná a chinntiú i do chód amharc go ndéantar na sonraí a ordú de réir an chaoi ar mhaith leat iad a thaispeáint.

Réiteach eile is ea na sonraí sa teimpléad a shórtáil ag baint úsáide as an scagair:tfilter: dictsort, má tá do chuid sonraí i liosta foclóirí:

```html+django
{% regroup cities|dictsort:"country" by country as country_list %}
```

#### Grúpáil ar airíonna eile

Is tréith grúpála dlíthiúil é aon chuardach teimpléad bailí don chlib athghrúpála, lena n-áirítear modhanna, tréithe, eochracha foclóra agus míreanna liosta. Mar shampla, más eochair eachtrach é an réimse “tíre” do rang le tréith “cur síos”, d'fhéadfá úsáid a bhaint as:

```html+django
{% regroup cities by country.description as country_list %}
```

Nó, más réimse é ````country ```roghanna````, beidh a: meth: ~django.db.models.model.get\_foo\_display modh ar fáil mar thréith, rud a ligfidh duit grúpáil ar an teaghrán taispeána seachas an eochair roghanna :

```html+django
{% regroup cities by get_country_display as country_list %}
```

Taispeánfaidh `{{country.grouper}}` anois na réimsí luacha ón tacar `roghna` seachas na heochracha.

### `athshocraitheach`

Athshocraíonn sé “timthriall” roimhe seo ionas go dtosóidh sé óna chéad mhír ag an gcéad teagmháil eile. Gan argóintí, athshocróidh ``{% resetcycle%} `an`` {% timthriall%}\` deireanach a shainmhínítear sa teimpléad.

Úsáid sampla:

```html+django
{% for coach in coach_list %}
    <h1>{{ coach.name }}</h1>
    {% for athlete in coach.athlete_set.all %}
        <p class="{% cycle 'odd' 'even' %}">{{ athlete.name }}</p>
    {% endfor %}
    {% resetcycle %}
{% endfor %}
```

Chuirfeadh an sampla seo ar ais an HTML seo:

```html
<h1>Gareth</h1>
<p class="odd">Harry</p>
<p class="even">John</p>
<p class="odd">Nick</p>

<h1>John</h1>
<p class="odd">Andrea</p>
<p class="even">Melissa</p>
```

Tabhair faoi deara conas a chríochnaíonn an chéad bloc le `class="odd"` agus tosaíonn an ceann nua le `class="odd"`. Gan an chlib `{% resetcycle%}`, tosódh an dara bloc le `class="even"`.

Is féidir leat clibeanna timthriall ainmnithe a athshocrú freisin:

```html+django
{% for item in list %}
    <p class="{% cycle 'odd' 'even' as stripe %} {% cycle 'major' 'minor' 'minor' 'minor' 'minor' as tick %}">
        {{ item.data }}
    </p>
    {% ifchanged item.category %}
        <h1>{{ item.category }}</h1>
        {% if not forloop.first %}{% resetcycle tick %}{% endif %}
    {% endifchanged %}
{% endfor %}
```

Sa sampla seo, tá na sraitheanna neamhghair/fiú malartacha againn agus sraith “mór” gach cúigiú sraith. Ní athshocraítear ach an timthriall cúig shraith nuair a athraíonn catagóir.

### gan spás \`\`

Baineann sé spás bán idir clibeanna HTML. Cuimsíonn sé seo carachtair cluaisín agus línte nua.

Úsáid sampla:

```html+django
{% spaceless %}
    <p>
        <a href="foo/">Foo</a>
    </p>
{% endspaceless %}
```

Chuirfeadh an sampla seo ar ais an HTML seo:

```html+django
<p><a href="foo/">Foo</a></p>
```

Ní bhaintear ach spás idir *tags* \- ní spás idir clibeanna agus téacs. Sa sampla seo, ní scriosfar an spás timpeall `Hello`:

```html+django
{% spaceless %}
    <strong>
        Hello
    </strong>
{% endspaceless %}
```

### `Teimpléad tag`

Aschur ceann de na carachtair chomhréireachta a úsáidtear chun clibeanna teimpléad

Níl aon choincheap ag an gcóras teimpléid maidir le carachtair aonair “éalú”. Mar sin féin, is féidir leat an chlib `{% templatetag%}` a úsáid chun ceann de na teaglaim carachtair clib teimpléad a thaispeáint.

Insíonn an argóint cén giotán teimpléid atá le haschur:

| Argóint | Aschuir |
| --- | --- |
| `openblock` | `{%` |
| `cloing` | %} \`\` |
| `openinathraithe` | `{{` |
| `dúnta inathraitheach` | `}}` |
| `openbrace` | `{` |
| `Closebraice` | `}` |
| `Tráchtaireacht oscail` | `{#` |
| `dlúthchomhlána` | #} \`\` |

Úsáid samplach:

```html+django
The {% templatetag openblock %} characters open a block.
```

Féach freisin an clibe:ttag: verbatim le haghaidh bealach eile chun na carachtair seo a áireamh.

### `Url`

Tugann tagairt cosán iomlán ar ais (URL gan ainm fearainn) a mheaitseálann radharc ar leith agus paraiméadair roghnacha. Déanfar aon charachtair speisialta sa chosán mar thoradh air a ionchódú ag baint úsáide as: func: ~django.utils.encoding.iri\_to\_uri.

This is a way to output links without violating the DRY principle by having to
hardcode URLs in your templates:

```html+django
{% url 'some-url-name' v1 v2 %}
```

\<naming-url-patterns\>Is é an chéad argóint a:ref: Ainm patrún URL . Is féidir é a bheith ina athróg litriúil nó aon athróg comhthéacs eile. Tá argóintí breise roghnach agus ba cheart go mbeadh luachanna scartha ó spás iad a úsáidfear mar argóintí san URL. Taispeánann an sampla thuas ag rith argóintí seasaimh. De rogha air is féidir leat comhréir eochairfhocal a úsáid:

```html+django
{% url 'some-url-name' arg1=v1 arg2=v2 %}
```

Ná déan comhréir seasmhach agus eochairfhocal a mheascadh i nglao amháin. Ba chóir go mbeadh gach argóint a éilíonn ag an URLConf i láthair.

Mar shampla, cuir i gcás go bhfuil amharc agat, `app_views.client`, a ghlacann a URLConf ID cliant (anseo, client () \`modh taobh istigh den chomhad tuairimí \`\`app\_views.py\`). D'fhéadfadh cuma seo a bheith ar líne URLConf:

```python
path("client/<int:id>/", app_views.client, name="app-views-client")
```

Má tá URLConf an aip seo san áireamh i URLConf an tionscadail faoi chonair mar seo:

```python
path("clients/", include("project_name.app_name.urls"))
```

... ansin, i dteimpléad, is féidir leat nasc a chruthú leis an radharc seo mar seo:

```html+django
{% url 'app-views-client' client.id %}
```

Aschróidh an chlib teimpléid an sreang `/cliant/cliant/123/`.

Tabhair faoi deara mura bhfuil an URL atá á aisiompú agat ann, gheobhaidh tú eisceacht: exc: ~django.urls.noReverseMatch ardaithe, rud a fhágfaidh go dtaispeánfaidh do shuíomh leathanach earráide.

Más mian leat URL a aisghabháil gan é a thaispeáint, is féidir leat glao beagán difriúil a úsáid:

```html+django
{% url 'some-url-name' arg arg2 as the_url %}

<a href="{{ the_url }}">I'm linking to {{ the_url }}</a>
```

Is é raon feidhme an athróg a chruthaíonn an chomhréir as var\` an `{% block%}` ina bhfuil an chlib `{% url%}` le feiceáil.

Ní chuirfidh an comhréir seo `{% url... as var%}` \*\* ina chúis le earráid má tá an radharc ar iarraidh. Go praiticiúil úsáidfidh tú é seo chun nasc a dhéanamh le tuairimí atá roghnach:

```html+django
{% url 'some-url-name' as the_url %}
{% if the_url %}
  <a href="{{ the_url }}">Link to optional stuff</a>
{% endif %}
```

Más mian leat URL spás ainmneacha a aisghabháil, sonraigh an t-ainm láncháilithe:

```html+django
{% url 'myapp:view-name' %}
```

Leanfaidh sé seo an straitéis gnáth:ref: ainmspaced URL \<topics-http-reversing-url-namespaces\>', lena n-áirítear aon leideanna a sholáthraíonn an comhthéacs maidir leis an bhfeidhmchlár reatha a úsáid.

> **Warning**
>
> Ná déan dearmad luachana a chur timpeall an phatrún URL ainm , ar shlí eile léirmhínífear an luach mar athróg comhthéacs!

### `Verbatim`

Stopann inneall an teimpléid ó ábhar an chlib bloc seo a léiriú.

Úsáid choitianta ná ciseal teimpléad JavaScript a cheadú a imbhuaileann le comhréir Django. Mar shampla:

```html+django
{% verbatim %}
    {{if dying}}Still alive.{{/if}}
{% endverbatim %}
```

Is féidir leat clib deiridh sonrach a ainmniú freisin, rud a cheadaíonn úsáid `{% endverbatim%}` mar chuid den ábhar neamh-rindreáilte:

```html+django
{% verbatim myblock %}
    Avoid template rendering via the {% verbatim %}{% endverbatim %} block.
{% endverbatim myblock %}
```

### Leithead leithead\`

Chun barrachairteacha agus dá leithéid a chruthú, ríomhann an clib seo cóimheas luach ar leith go luach uasta, agus ansin cuireann an cóimheas sin i bhfeidhm ar thairiseach.

Mar shampla:

```html+django
<img src="bar.png" alt="Bar"
     height="10" width="{% widthratio this_value max_value max_width %}">
```

Má tá ```luach_seo ``175, `luach_maxe``` 200, agus `max_width` 100, beidh an íomhá sa sampla thuas 88 picteilín ar leithead (mar 175/200 = .875; .875 \* 100 = 87.5 atá cruinn suas go dtí 88).

I roinnt cásanna b'fhéidir gur mhaith leat toradh leithead\` a ghabháil in athróg. Is féidir leis a bheith úsáideach, mar shampla, in a:ttag: blocktranslate mar seo:

```html+django
{% widthratio this_value max_value max_width as width %}
{% blocktranslate %}The width is: {{ width }}{% endblocktranslate %}
```

### Invalid section title or transition marker.

Cuireann sé athróg casta faoi ainm níos simplí. Tá sé seo úsáideach agus tú ag rochtain ar mhodh “daor” (m.sh., ceann a bhuaileann an bunachar sonraí) arís agus arís eile.

Mar shampla:

```html+django
{% with total=business.employees.count %}
    {{ total }} employee{{ total|pluralize }}
{% endwith %}
```

Níl an t-athróg daonra (sa sampla thuas, ```iomlán ``) ar fáil ach idir na clibeanna``` {% with%} `agus` {% endwith%} .

Is féidir leat níos mó ná athróg comhthéacs amháin a shannadh:

```html+django
{% with alpha=1 beta=2 %}
    ...
{% endwith %}
```

> **Note**
>
> Tacaítear fós leis an bhformáid níos fabhraí roimhe seo: `{% with business.staffes.count as total%}`

## Tagairt scagaire tógtha

### Cuir leis \`\`

Cuireann sé an argóint leis an luach.

Mar shampla:

```html+django
{{ value|add:"2" }}
```

Más é `` `luach `` `4`, ansin is é `6` an t-aschur.

Déanfaidh an scagaire seo iarracht an dá luach a chur i bhfeidhm go sláimhreacha ar dtús. Má theipeann sé seo, déanfaidh sé iarracht na luachanna a chur le chéile ar aon nós. Oibreoidh sé seo ar roinnt cineálacha sonraí (teaghráin, liosta, srl.) agus teipeann sé ar dhaoine eile. Má theipeann air, beidh an toradh ina shreang folamh.

Mar shampla, má tá:

```html+django
{{ first|add:second }}
```

agus is é ``` chéad `` ``` \[1, 2, 3\] ```agus ``an dara``` `is é` \[4, 5, 6\] `, ansin is é` \[1, 2, 3, 4, 5, 6\] an t-aschur.

> **Warning**
>
> Beidh teaghráin is féidir a iallach a chur ar shlámhshuimhreacha **comhiomraithe**, gan a chomhcheangal, mar atá sa chéad shampla thuas.

### `Addslashes`

Cuireann sé slashes roimh luachana. Úsáideach chun teaghráin a éalú i CSV, mar shampla.

Mar shampla:

```html+django
{{ value|addslashes }}
```

Más é `luach` `` `Táim ag úsáid Django" ``, beidh an t-aschur `"Táim ag úsáid Django"`.

### `capfirst`

Caipitlíonn sé an chéad charachtar den luach. Mura litir é an chéad charachtar, níl aon éifeacht ag an scagaire seo.

Mar shampla:

```html+django
{{ value|capfirst }}
```

Más é `luach` `django"`, is é "Django" an t-aschur.

### `Ionad`

Díríonn an luach i réimse de leithead ar leith.

Mar shampla:

```html+django
"{{ value|center:"15" }}"
```

Más é `luach` ```Django"`, is é ``” Django “``` an t-aschur.

### `gearrth`

Baineann gach luach arg as an sreang tugtha.

Mar shampla:

```html+django
{{ value|cut:" " }}
```

Más é `luach` "Sreang le spásanna” , is é an t-aschur "Stringwithspaces".

### Dáta \`\`

Formálaíonn sé dáta de réir an fhormáide a thugtar.

Úsáideann sé formáid den chineál céanna le feidhm  PHP \< <https://www.php.net/manual/en/function.date.php>\> le roinnt difríochtaí.

> **Note**
>
> Ní úsáidtear na carachtair formáide seo i Django lasmuigh de theimpléid. Dearadh iad le bheith comhoiriúnach le PHP chun aistriú a éascú do dhearthóirí.

Teagáin formáid atá ar fáil:

| Carachtar formáid | Cur síos | Aschur sampla |
| --- | --- | --- |
| **Lae** |  |  |
| `d` | Lá na míosa, 2 dhigit le nialas tosaigh. | `'01'` go `` `'31' `` |
| `j` | Lá na míosa gan nialas tosaigh. | `` `'1' `` go ``` ``31' ``` |
| `D` | Lá na seachtaine, téacsúil, 3 litir. | `` `'Dé hAoine ' `` |
| `l` | Lá na seachtaine, téacsúil, fada. | `` `'Dé hAoine ' `` |
| `S` | Iarmhír ordúil Béarla do lá na míosa, 2 charachtar. | `` `'st' ``, `'nd'`, `'rd'` nó `` `th' `` |
| `w` | Lá na seachtaine, digití gan nialas tosaigh. | `'0'` (Dé Domhnaigh) go `'6'` (Dé Sathairn) |
| `Z` | Lá na bliana. | `1` go `366` |
| **Seachtain** |  |  |
| `W` | Líon seachtaine na bliana ISO-8601, le seachtainí ag tosú Dé Luain. | `` `1 ``, 53\` |
| **Mí** |  |  |
| `m` | Mí, 2 dhigit le nialas tosaigh. | `'01'` go `'12'` |
| `n` | Mí gan nialais tosaigh. | `` `'1' `` go `` `'12' `` |
| `M` | Mí, téacsúil, 3 litir. | `` `'Jan' `` |
| `b` | Mí, téacsach, 3 litir, litreacha beaga. | ``` ``Jan' ``` |
| `E` | Mí, ionadaíocht mhalartach áitiúil a úsáidtear de ghnáth le haghaidh ionadaíocht dáta fada. | ```` `listopada'` (i gcás áitiúil na Polainne, seachas ```Listopad` ````) |
| `F` | Mí, téacsúil, fada. | `` `'Eanáir' `` |
| `N` | Giorrúchán míosa i stíl Associated Press. Síneadh dílseánaigh. | `` `'Ean.' ``, `` Feabhra '` ``, `Márta`, Bealtaí'\` |
| t \`\` | Líon na laethanta sa mhí ar leith. | `28` go `31` |
| **Bliain** |  |  |
| `` `t `` | Bliain, 2 dhigit le nialas tosaigh. | `'00'` go `` `99' `` |
| `` `T `` | Bliain, 4 dhigit le nialas tosaigh. | `'0001'`,..., `'1999'`,..., `'9999'` |
| `L` | Boolean maidir le cibé an bhliain léim í. | `Fíor` nó `Bréag` |
| `o` | Bliain uimhrithe seachtaine ISO-8601, a fhreagraíonn d'uimhir seachtaine ISO-8601 (W) a úsáideann seachtainí léim. Féach Y don fhormáid bliana níos coitianta. | `` `'1999' `` |
| **Aim** |  |  |
| `g` | Uair an chloig, formáid 12 uair an chloig gan nialas tosaigh. | `` `'1' `` go `` `'12' `` |
| `G` | Uair an chloig, formáid 24 uair an chloig gan nialas tosaigh. | `'0'` go `` `'23' `` |
| `h` | Uair an chloig, formáid 12 uair an chloig. | `'01'` go `'12'` |
| `H` | Uair, formáid 24 uair an chloig. | `'00'` go `` `'23' `` |
| I \` | Miontuairiscí | `'00'` go `'59'` |
| `s` | Soicind, 2 dhigit le nialas tosaigh. | `'00'` go `'59'` |
| `u` | Micreasoicind. | `000000` go `999999` |
| `a` | a.m.' nó p.m.' (Tabhair faoi deara go bhfuil sé seo beagán difriúil ná aschur PHP, toisc go n-áirítear tréimhsí seo chun stíl Associated Press a mheaitseáil.) | ``` ``a.m.' ``` |
| `A` | `` `AM' `` nó ``` ``PM' ```. | ```` ```AM ```` |
| `f` | Am, in uair an chloig agus nóiméad 12 uair an chloig, le nóiméid fágtha má tá siad nialas. Síneadh dílseánaigh. | `` `'1' ``, `'1:30 '` |
| `P` | Am, i 12 uair an chloig, nóiméad agus 'a.m.' /'p.m. ', le nóiméid fágtha má tá siad nialas agus na teaghráin cásanna speisialta' meán oíche 'agus' meán lae 'más cuí. Síneadh dílseánaigh. | ``` `'1 a.m.'`, ``'1:30 p.m.' ```, `meán oíche'`, `noon'`, `` `12:30 p.m.' `` |
| **Crios Ama** |  |  |
| `e` | Ainm crios ama. D'fhéadfadh sé a bheith i bhformáid ar bith, nó d'fhéadfadh sé teaghrán folamh a thabhairt ar ais, ag brath ar an dáta-am. | `"`, `GMT'`, `'-500'`, US/Oirtheir', srl. |
| I \` | Am sábhála solais an lae, cibé an bhfuil sé i bhfeidhm nó nach bhfuil. | `` `'1' `` nó `` `0' `` |
| `O` | Difríocht le am Greenwich in uaireanta. | `` `'+0200' `` |
| T \`\` | Crios ama an mheaisín seo. | `` `'EST' ``, `MDT'` |
| `Z` | Fhritháireamh crios ama i soicindí. Tá an fhritháireamh do chóin ama siar ó UTC diúltach i gcónaí, agus dóibh siúd ó thoir UTC tá sé dearfach i gcónaí. | `-43200` go `43200` |
| **Dáta/Aim** |  |  |
| `c` | Formáid ISO 8601. (Nóta: murab ionann agus formáidithe eile, mar shampla “Z”, “O” nó “r”, ní chuirfidh an formáiditheoir “c” fritháireamh crios ama más dáta naif é an luach (féach:class: datetime.tzinfo). | ```2008-01-02T 10:30:00.000 123+ 02:00 ``, nó ``2008-01-02T 10:30:00.000 123``` má tá an dáta naíoch |
| `R` | \<5322 #section -3.3\>:rfc: RFC 5322 dáta formáidithe. | `'Déar, 21 Noll 2000 16:01:07 +0200'` |
| `U` | Soicind ó Eocha Unix (1 Eanáir 1970 00:00:00 UTC). |  |

Mar shampla:

```html+django
{{ value|date:"D d M Y" }}
```

If `value` is a [`datetime`](https://docs.python.org/3/library/datetime.html#datetime.datetime) object (e.g., the result of
`datetime.datetime.now()`), the output will be the string
`'Wed 09 Jan 2008'`.

Is féidir leis an bhformáid a rith a bheith ar cheann de na cinn réamhshainithe: setting: DATE\_FORMAT, :setting: DATETIME\_FORMAT, :setting: SHORT\_DATE\_FORMAT nó:setting: SHORT\_DATETIME\_FORMAT, nó formáid saincheaptha a úsáideann na sonraitheoirí formáide a thaispeántar sa tábla thuas. Tabhair faoi deara go bhféadfadh formáidí réamhshainithe athrú ag brath ar an áitiúil reatha.

Ag glacadh leis gur:setting: LANGUAGE\_CODE, mar shampla, `"es"`, ansin le haghaidh:

```html+django
{{ value|date:"SHORT_DATE_FORMAT" }}
```

is é an t-aschur an teaghrán ```"09/01/2008" ``(is é ``"D/M/Y"``` an sonraitheoir formáid `"SHORT_DATE_FORMAT”` don áitiúil es mar a sheoltar le Django).

Nuair a úsáidtear é gan teaghrán formáide, úsáidtear an sonraitheoir formáide DATE\_FORMAT . Ag glacadh leis na socruithe céanna leis an sampla roimhe seo:

```html+django
{{ value|date }}
```

aschuir `9 Eanáir 2008` (is é r'jde Fde Fde Y'\` an sonraitheoir formáid ```DATE_FORMAT ``don `es``` áitiúil `es`). Tá “d” agus “e” araon éalaithe le cúltaca, mar ar shlí eile is teaghrán formáide é gach ceann acu a thaispeánann an lá agus ainm an crios ama, faoi seach.

Is féidir leat ```dáta ``a chur le chéile leis an scagair:tfilter: `time` chun léiriú iomlán a thabhairt ar luach ``datetime```. M.sh.:

```html+django
{{ value|date:"D d M Y" }} {{ value|time:"H:i" }}
```

### `réamhshocraithe`

Má mheastóidh luach go `False`, úsáideann sé an réamhshocrú tugtha. Seachas sin, úsáideann sé an luach.

Mar shampla:

```html+django
{{ value|default:"nothing" }}
```

Más é `luach` `“`” (an teaghrán folamh), beidh `` `rud ar bith `` an t-aschur.

### `réamhshocraithe_ife_neamh`

Más é (agus mura bhfuil) luach `None`, úsáideann sé an réamhshocrú tugtha. Seachas sin, úsáideann sé an luach.

Tabhair faoi deara má thugtar sreang folamh, go n-úsáidfear an luach réamhshocraithe\*. Úsáid an scagair:tfilter: default más mian leat teacht ar ais le haghaidh teaghráin folamh.

Mar shampla:

```html+django
{{ value|default_if_none:"nothing" }}
```

Más é `` `luach `` `None`, beidh rud ar bit' an t-aschur.

### `dictsort`

Tógann sé liosta de na foclóirí agus tugann sé ar ais an liosta sin a shórtáiltear de réir an eochair a thugtar san

Mar shampla:

```html+django
{{ value|dictsort:"name" }}
```

Más é “luach”:

```python
[
    {"name": "zed", "age": 19},
    {"name": "amy", "age": 22},
    {"name": "joe", "age": 31},
]
```

ansin bheadh an t-aschur:

```python
[
    {"name": "amy", "age": 22},
    {"name": "joe", "age": 31},
    {"name": "zed", "age": 19},
]
```

Is féidir leat rudaí níos casta a dhéanamh freisin mar:

```html+django
{% for book in books|dictsort:"author.age" %}
    * {{ book.title }} ({{ book.author.name }})
{% endfor %}
```

Más é “leabhair”:

```python
[
    {"title": "1984", "author": {"name": "George", "age": 45}},
    {"title": "Timequake", "author": {"name": "Kurt", "age": 75}},
    {"title": "Alice", "author": {"name": "Lewis", "age": 33}},
]
```

ansin bheadh an t-aschur:

```html+django
* Alice (Lewis)
* 1984 (George)
* Timequake (Kurt)
```

Is féidir le `dictsort` liosta liostaí a ordú freisin (nó aon rud eile a chuirtear chun feidhme \_\_getitem\_\_ () ) de réir eilimintí ag innéacs sonraithe. Mar shampla:

```html+django
{{ value|dictsort:0 }}
```

Más é “luach”:

```python
[
    ("a", "42"),
    ("c", "string"),
    ("b", "foo"),
]
```

ansin bheadh an t-aschur:

```python
[
    ("a", "42"),
    ("b", "foo"),
    ("c", "string"),
]
```

Ní mór duit an t-innéacs a rith mar shláimhir seachas sreang. Táirgeann na seo a leanas aschur folamh:

```html+django
{{ values|dictsort:"0" }}
```

Ní thacaítear le hordú de réir eilimintí ag innéacs sonraithe ar fhoclóirí

### `dictsortreversed`

Tógann sé liosta de na foclóirí agus tuairisceann an liosta sin a shórtáil in ord droim de réir an eochair a thugtar san argóint Oibríonn sé seo díreach mar an gcéanna leis an scagaire thuas, ach beidh an luach ar ais in ord droim.

### `roinntear`

Tugann sé “Fíor” ar ais má tá an luach inroinnte leis an argóint.

Mar shampla:

```html+django
{{ value|divisibleby:"3" }}
```

Más é `` `luach `` `21`, bheadh an t-aschur Fíor .

### éalú \`

Éalaíonn sé HTML teaghrán. Go sonrach, déanann sé na hathsholáthairtí seo:

- Déantar `<` a thiontú go `<`
- Tiontaítear \>\` go \>\`
- Tiontaítear ````` ````(luachan aonair) go ``` `````
- Déantar ```"``(luachan dúbailte) a thiontú go```"\`\`
- Tiontaítear & \`\`go \`&\`

Ní dhéanfar ach babhta amháin éalaithe mar thoradh ar “éalú” a chur i bhfeidhm ar athróg a bheadh éalú uathoibríoch i bhfeidhm ar an toradh de ghnáth. Mar sin tá sé sábháilte an fheidhm seo a úsáid fiú i dtimpeallachtaí éalaithe uathoibríoch Más mian leat go gcuirfear pasanna éalaithe iolracha i bhfeidhm, bain úsáid as an scagair:tfilter: force\_escape.

Mar shampla, is féidir leat `escape` a chur i bhfeidhm ar réimsí nuai:ttag: autoescape as:

```html+django
{% autoescape off %}
    {{ title|escape }}
{% endautoescape %}
```

> **“Éalú” a shlánú le scagairí eile**
>
> Mar a luaitear sa rannait:ttag: autoescape, nuair a chuirtear scagairí lena n-áirítear ```éalú ``slabhraithe le chéile, féadfaidh torthaí gan choinne a bheith mar thoradh air má mharcálann scagairí roimhe seo sreang a d'fhéadfadh a bheith sábháilte mar gheall ar an easpa éalaithe mar gheall ar: ttag: `autoescape` a bheith `off```.
>
> I gcásanna den sórt sin, ní dhéanfadh slabhraí éalú a athéalú teaghráin atá marcáilte mar shábháilte cheana féin.
>
> Tá sé seo tábhachtach go háirithe nuair a úsáidtear scagairí a oibríonn ar seicheamh, mar shampla:tfilter: join. Más gá duit gach eilimint a éalú i seicheamh, bain úsáid as an scagaire tiomnaithe: tfilter: escapeseq.

### éalaithe \`

Éalaíonn sé carachtair le húsáid mar shreang JavaScript iomlán liteartha, laistigh de luachana aonair nó dúbailte, mar atá thíos. Ní dhéanann an scagaire seo an sreang sábháilte le húsáid in\*"Litríochtaí teimpléad JavaScript"\* (an comhréir backtick JavaScript). Ní thacaítear le haon úsáidí eile nach bhfuil liostaithe thuas. Moltar go ginearálta gur chóir sonraí a rith ag baint úsáide as tréithe HTML sonraí , nó an scagair:tfilter: json\_script, seachas i JavaScript leabaithe.

Mar shampla:

```html+django
<script>
let myValue = '{{ value|escapejs }}'
```

### `` `Escapeseq ``

Cuireann an scagaire: tfilter: escape i bhfeidhm ar gach eilimint de seicheamh. Úsáideach i gcomhar le scagairí eile a oibríonn ar sheicheamh, mar shampla:tfilter: join. Mar shampla:

```html+django
{% autoescape off %}
    {{ my_list|escapeseq|join:", " }}
{% endautoescape %}
```

### formáid comhaid \`\`

Formáidigh an luach cosúil le méid comhad 'inléite ag an duine' (ie `'13 KB'`, `4.1 MB'`, `` `102 bytes' ``, srl.).

Mar shampla:

```html+django
{{ value|filesizeformat }}
```

Más é “luach” 123456789, is é `117.7 MB` an t-aschur.

> **Méideanna comhaid agus aonaid SI**
>
> Go docht, ní chomhlíonann `filesizeformat` leis an gCóras Idirnáisiúnta Aonaid a mholann KiB, MiB, GiB, srl a úsáid nuair a ríomhtar méideanna byte i gcumhachtaí 1024 (rud atá an cás anseo). Ina áit sin, úsáideann Django ainmneacha aonaid traidisiúnta (KB, MB, GB, srl.) A fhreagraíonn d'ainmneacha a úsáidtear níos coitianta.

### `` `chéad ``

Tugann sé an chéad mhír ar liosta ar ais.

Mar shampla:

```html+django
{{ value|first }}
```

Más é `luach` an liosta `['a', 'b', 'c']`, is é a'\` an t-aschur.

### `formáid snámha`

Nuair a úsáidtear é gan argóint, cruinnigh uimhir phointe snámh go háit deachúil amháin - ach amháin má tá cuid deachúil le taispeáint. Mar shampla:

| `luach` | Teimpléad | Aschur |
| --- | --- | --- |
| `34.23234` | `{{luach\|formáid snámh}}` | `34.2` |
| `34.00000` | `{{luach\|formáid snámh}}` | `34` |
| `34.26000` | `{{luach\|formáid snámh}}` | `34.3` |

Má úsáidtear é le hargóint slámhshláir uimhriúil, cruthaíonn `formáid float` uimhir go dtí an iliomad áiteanna deachúil sin. Mar shampla:

| `luach` | Teimpléad | Aschur |
| --- | --- | --- |
| `34.23234` | `{{luach\|formáid snám:3}}` | `34.232` |
| `34.00000` | `{{luach\|formáid snám:3}}` | `34.000` |
| `34.26000` | `{{luach\|formáid snám:3}}` | `34.260` |

Is úsáideach go háirithe tá 0 (nialas) a rith mar an argóint a chuirfidh an snámhphointe go dtí an slámhshláir is gaire.

| `luach` | Teimpléad | Aschur |
| --- | --- | --- |
| `34.23234` | `{{luach\|formáid snámh: "0"}}` | `34` |
| `34.00000` | `{{luach\|formáid snámh: "0"}}` | `34` |
| `39.56000` | `{{luach\|formáid snámh: "0"}}` | `40` |

Má tá an argóint a chuirtear chuig “floatformat” diúltach, cuirfidh sé uimhir go dtí an iliomad áiteanna deachúil sin - ach amháin má tá cuid deachúil le taispeáint. Mar shampla:

| `luach` | Teimpléad | Aschur |
| --- | --- | --- |
| `34.23234` | `{{luach\|formáid snámh:” -3"}}` | `34.232` |
| `34.00000` | `{{luach\|formáid snámh:” -3"}}` | `34` |
| `34.26000` | `{{luach\|formáid snámh:” -3"}}` | `34.260` |

Má tá an iarmhír ``` ``ag an argóint a chuirtear chuig `floatformat ```, cuirfidh sé iallach ar ghrúpáil trí:setting: THOUSAND\_SEPARATOR don áit ghníomhach. Mar shampla, nuair is é en\` (Béarla) an áitiúil gníomhach:

| `luach` | Teimpléad | Aschur |
| --- | --- | --- |
| `34232.34` | `{{luach\|formáid snámh: "2g”}}` | `34,232.34` |
| `34232.06` | `{{luach\|formáid snámh: "g”}}` | `34,232.1` |
| `34232.00` | `{{luach\|formáid snámh:” -3g”}}` | `34,232` |

Tá an t-aschur logánaithe i gcónaí (go neamhspleách ar an gclibe:ttag: {% localize off%}\`\<localize\>) mura bhfuil an iarmhír \`\`u \`\`ag an argóint a chuirtear chuig \`floatformat\`, a chuirfidh iallach ar logánú a dhíchumasú. Mar shampla, nuair is é pl\` (Polainnis) an áitiúil gníomhach:

| `luach` | Teimpléad | Aschur |
| --- | --- | --- |
| `34.23234` | `{{luach\|formáid snámh: "3"}}` | `34,232` |
| `34.23234` | `{{luach\|formáid snámh: "3u”}}` | `34.232` |

Is cothrom le `floatformat` a úsáid gan aon argóint le `floatform` a úsáid le argóint `-1`.

### `Force_escape`

Cuireann éalú HTML i bhfeidhm chuig teaghrán (féach an scagair:tfilter: escape le haghaidh sonraí). Cuirtear an scagaire seo i bhfeidhme\* láithreach\* agus filleann sé sreang nua éalaithe ar ais. Tá sé seo úsáideach sna cásanna annamh ina dteastaíonn éalú iolracha uait nó gur mhaith leat scagairí eile a chur i bhfeidhm ar na torthaí éalaithe De ghnáth, ba mhaith leat an scagaire: tfilter: escape a úsáid.

Mar shampla, más mian leat na heilimintí \<p\>HTML a chruthaigh an scagair:tfilter: \`linebreaks a ghabháil:

```html+django
{% autoescape off %}
    {{ body|linebreaks|force_escape }}
{% endautoescape %}
```

### `faigh_digit`

Mar gheall ar uimhir iomlán, filleann sé an digit iarrtha, áit a bhfuil 1 an dhigit is deise, 2 an dara digiteach is mó ar dheis, srl. Tugann sé an luach bunaidh le haghaidh ionchur neamhbhailí (mura bhfuil ionchur nó argóint sláimhir, nó má tá argóint níos lú ná 1). Seachas sin, is sláimhir é aschur i gcónaí.

Mar shampla:

```html+django
{{ value|get_digit:"2" }}
```

Más é ``` `luach ``123456789 ```, is é `8` an t-aschur.

### `iriencode`

Athraíonn sé IRI (Aitheantóir Acmhainní Idirnáisiúnta) go sreang atá oiriúnach lena n-áireamh i URL. Tá sé seo riachtanach má tá tú ag iarraidh teaghráin a úsáid ina bhfuil carachtair neamh-ASCII i URL.

Tá sé sábháilte an scagaire seo a úsáid ar shreang atá imithe tríd an scagaire: tfilter: urlencode cheana féin.

Mar shampla:

```html+django
{{ value|iriencode }}
```

Más é `luach` `? Test = I ♥ Django “`, beidh an t-aschur\`\`”? Tástáil = I% 20% E 2% 99% A 5% 20Django “.

### `` `Bhreastala ``

Cuireann sé le liosta le sreang, cosúil le str.join (list) Python

Mar shampla:

```html+django
{{ value|join:" // " }}
```

Más é `luach` an liosta `['a', 'b', 'c']`, is é an t-aschur an teaghrán `"a//b//c"`.

### `json_script`

Aisíonn sé réad Python go sábháilte mar JSON, fillte i gcli \<script\>b , réidh le húsáid le JavaScript.

Argóint: \*\* An “id” HTML roghnach den chlib \<script\>\`\`\`.

Mar shampla:

```html+django
{{ value|json_script:"hello-data" }}
```

Más é `luach` an foclóir `{'hello': 'world'}`, is é an t-aschur:

```html
<script id="hello-data" type="application/json">{"hello": "world"}</script>
```

Is féidir rochtain a fháil ar na sonraí mar gheall air i JavaScript mar seo:

```javascript
const value = JSON.parse(document.getElementById('hello-data').textContent);
```

Maolaítear ionsaithe XSS trí na carachtair “\<”, “\>” agus “&” a éalú. Mar shampla má tá `luach` `{'hello': 'domhan &'}`, is é an t-aschur:\</script\>

```html
<script id="hello-data" type="application/json">{"hello": "world\\u003C/script\\u003E\\u0026amp;"}</script>
```

Tá sé seo comhoiriúnach le Polasaí Slándála Ábhar dian a chuireann cosc ar fhorghníomhú script ar an Coinníonn sé scaradh glan freisin idir sonraí éighníomhacha agus cód infheidhmithe.

### `deireann`

Tugann an mír deireanach ar liosta ar ais.

Mar shampla:

```html+django
{{ value|last }}
```

Más é `luach` an liosta `['a', 'b', 'c', 'd']`, is é an t-aschur an teaghrán `"d"`.

### Fad \`\`

Tugann sé ar ais fad an luacha. Oibríonn sé seo le haghaidh teaghráin agus liostaí araon.

Mar shampla:

```html+django
{{ value|length }}
```

Más é `luach` `['a', 'b', 'c', 'd']` nó `"abcd"`, is é `4` an aschur.

Filleann an scagaire `0` le haghaidh athróg neamhshainithe.

### `breiseanna líne`

Cuireann HTML cuí in ionad sosanna líne i ngnáthtéacs; bíonn líne nua amháin ina bhri\</p\> \<br\>seadh líne HTML (`` ) agus bíonn líne nua ina bhriseadh mír ina líne bán ina dhiaidh sin (` ``).

Mar shampla:

```html+django
{{ value|linebreaks }}
```

\<p\>Más é `luach` ``` ``Joel\ n slug ```, is é an t-aschur `Is slug é Joel`.\</p\> \<br\>

### `linebreaksbr`

Athraíonn sé gach líne nua i bpíosa téacs simplí go briseanna líne HTML (\<br\>\`\`\`).

Mar shampla:

```html+django
{{ value|linebreaksbr }}
```

\<br\>Más é `luach` `` `Joel\ n slug ``, is é an t-aschur `` `Joel is slug ``.

### `Uimhreacha líne`

Taispeánann sé téacs le huimhreacha líne.

Mar shampla:

```html+django
{{ value|linenumbers }}
```

Más é “luach”:

```html+django
one
two
three
```

beidh an t-aschur:

```html+django
1. one
2. two
3. three
```

### `` `fuaim ``

Ailíníonn clé an luach i réimse de leithead ar leith.

Argóint: \*\* méid réimse

Mar shampla:

```html+django
"{{ value|ljust:"10" }}"
```

Más é `luach` `Django`, is é "Django “an t-aschur.

### níos ísle \`

Athraíonn sé sreang go léir litreacha beaga.

Mar shampla:

```html+django
{{ value|lower }}
```

Má tá `luach` GRÁ go hiomlán ag an Albam seo! \`, beidh an t-aschur grámhar go hiomlán leis an albam seo! .

### `liosta` make\_list\`\`

Tugann sé an luach a iompaigh ina liosta. Maidir le sreang, is liosta carachtair é. Maidir le sláimhir, caitheann an argóint chuig teaghrán sula gcruthaítear liosta.

Mar shampla:

```html+django
{{ value|make_list }}
```

Más é `luach` an teaghrán `"Joel"`, bheadh an t-aschur an liosta `['J', 'o', 'e', 'l']`. Más é `` `luach `` 123\`, is é an t-aschur an liosta `['1', '2', '3']`.

### `fhóna2uimhriach`

Athraíonn sé uimhir theileafóin (b'fhéidir ina bhfuil litreacha ann) go dtí a choibhéis

Ní gá go mbeadh an t-ionchur ina uimhir theileafóin bailí. Déanfaidh sé seo aon sreang a thiontú go sona sásta.

Mar shampla:

```html+django
{{ value|phone2numeric }}
```

Más é ```luach ``800-COLLECT ``, is é `800-2655328``` an t-aschur.

### `iolraithe`

Tugann iarmhír iolra ar ais mura bhfuil an luach `1`, `1'`, nó réad de fhad 1. De réir réamhshocraithe, is é an iarmhír seo `s'`.

Sampla:

```html+django
You have {{ num_messages }} message{{ num_messages|pluralize }}.
```

Más é `` `num_messages `` `1`, is é an aschur `````Tá 1 theachtaireacht agat. ``Má tá ``num_teachtaireachtaí ````2````` is é an aschur Tá 2 theachtaireacht agat. \`\`

Maidir le focail a dteastaíonn iarmhír seachas `` `s' ``, is féidir leat iarmhír malartach a sholáthar mar pharaiméadar don scagaire.

Sampla:

```html+django
You have {{ num_walruses }} walrus{{ num_walruses|pluralize:"es" }}.
```

Maidir le focail nach n-iolraíonn le iarmhír simplí, is féidir leat iarmhír uaineach agus iolra a shonrú, scartha le camóg.

Sampla:

```html+django
You have {{ num_cherries }} cherr{{ num_cherries|pluralize:"y,ies" }}.
```

> **Note**
>
> Úsáid: ttag: blocktranslate chun teaghráin aistrithe a iolrú.

### `pprint`

Fillteán timpeall: func: pprint.pprint \- le haghaidh dífhabhtú, i ndáiríre.

### `randam`

Tugann mír randamach ar ais ón liosta a thugtar.

Mar shampla:

```html+django
{{ value|random }}
```

Más é `luach` an liosta `['a', 'b', 'c', 'd']`, d'fhéadfadh an t-aschur a bheith `"b"`.

### `Rjust`

Ailíníonn ar dheis an luach i réimse de leithead ar leith.

Argóint: \*\* méid réimse

Mar shampla:

```html+django
"{{ value|rjust:"10" }}"
```

Más é `luach` `Django`, is é Django"\` an t-aschur.

### `sábháilte`

Marcálann sé teaghrán mar nach dteastaíonn tuilleadh HTML éalú roimh aschur. Nuair a bhíonn autoescaping as, níl aon éifeacht ag an scagaire seo.

> **Note**
>
> Má tá scagairí a shlánú agat, is féidir le scagaire a chuirtear i bhfeidhm tar éis `sábháilte` an t-ábhar a dhéanamh neamhshábháilte Mar shampla, priontáil an cód seo a leanas an t-athróg mar atá, gan éalú:
>
> ```html+django
> {{ var|safe|escape }}
> ```

### `sábháilteq`

Cuireann an scagaire: tfilter: sábháil' i bhfeidhm ar gach eilimint de seicheamh. Úsáideach i gcomhar le scagairí eile a oibríonn ar sheicheamh, mar shampla:tfilter: \`join. Mar shampla:

```html+django
{{ some_list|safeseq|join:", " }}
```

Ní fhéadfá an scagaire: tfilter: safe a úsáid go díreach sa chás seo, mar thiontfadh sé an t-athróg i sreang ar dtús, seachas oibriú le heilimintí aonair an seicheamh.

### `slise`

Tugann sé slisnán den liosta ar ais.

Úsáideann sé an chomhréir céanna le slisnú liosta Python. \< <https://docs.python.org/3/tutorial/introduction.html#lists>\>Féach an  le haghaidh réamhrá.

Sampla:

```html+django
{{ some_list|slice:":2" }}
```

Más é `some_list` `['a', 'b', 'c']`, is é `['a', 'b']` an aschur.

### `slugify`

Tiontaíonn sé go ASCII. Athraíonn sé spásanna go hiphens. Baineann sé carachtair nach alfaiméiricí, béim nó braithíní iad. Athraíonn sé go litreacha beaga. Chomh maith leis sin stiallacha spás bán a threoraíonn agus a leanann.

Mar shampla:

```html+django
{{ value|slugify }}
```

Más é `luach` `` `"Is slug é Joel" ``, is é an t-aschur `"joel-is-a-slug"`.

### `Formáid teaghrána`

Formálaíonn sé an t-athróg de réir an argóint, sonraitheoir formáidithe sreangáin. Úsáideann an sonraitheoir seo an comhréire:ref: old-string-formatting, ach amháin go dtioctar an “%” tosaigh.

Mar shampla:

```html+django
{{ value|stringformat:"E" }}
```

Más é `` `luach `` `10`, is é 1.000000E+01\` an t-aschur.

### `striptags`

Déanann sé gach iarracht is féidir chun gach clib HTML \[X\] a scriosadh.

Mar shampla:

```html+django
{{ value|striptags }}
```

Más é `luach` `” Is slug é <b>Joel</b> “`, \<button\>is\</button\> é an t-aschur `<span>"Is slug</span> é Joel"`.

> **Gan aon ráthaíocht sábhá**
>
> Tabhair faoi deara nach dtugann striptags aon ráthaíocht faoi go bhfuil a aschur sábháilte HTML, go háirithe le hionchur HTML neamhbhailí. Mar sin **RIAM** cuir an scagaire sábháilte i bhfeidhm ar aschur striptags\`. Má tá tú ag lorg rud éigin níos láidre, smaoinigh ar uirlis sláintíochta HTML tríú páirtí a úsáid.

### Am \`

Formálaíonn sé am de réir an fhormáid a thugtar.

Is féidir le formáid thugtar a bheith mar an ceann réamhshainithe: setting: TIME\_FORMAT, nó formáid saincheaptha, mar an scagaire: tfilter: dáta. Tabhair faoi deara go bhfuil an fhormáid réamhshainithe ag brath go háitiúil.

Mar shampla:

```html+django
{{ value|time:"H:i" }}
```

Má tá `lua` comhionann le ```datetime.datetime.now () ``, is é an t-aschur an teaghrán```” 01:23 “.

Tabhair faoi deara gur féidir leat teaghrán formáide a éalú ar ais más mian leat an luach “amh” a úsáid. Sa sampla seo, tá “h” agus “m” araon éalaithe le cúltaca, mar ar shlí eile is teaghrán formáide é gach ceann acu a thaispeánann an uair agus an mhí, faoi seach:

```html+django
{{ value|time:"H\h i\m" }}
```

Taispeánfaí sé seo mar “01h 23m”.

Sampla eile:

Ag glacadh leis gur:setting: LANGUAGE\_CODE, mar shampla, `de"`, ansin le haghaidh:

```html+django
{{ value|time:"TIME_FORMAT" }}
```

is é an t-aschur an teaghrán `” 01:23 “` (Is é an sonraitheoir formáide ```"TIME_FORMAT” ``don áitiúil ``de``` mar a sheoltar le Django ná `"H: i"`).

The `time` filter will only accept parameters in the format string that
relate to the time of day, not the date. If you need to format a `date`
value, use the [`date`](#std-templatefilter-date) filter instead (or along with [`time`](#std-templatefilter-time) if
you need to render a full [`datetime`](https://docs.python.org/3/library/datetime.html#datetime.datetime) value).

\<date-and-time-formatting-specifiers\>Tá eisceacht amháin ann an riail thuas: Nuair a rith luach `datetime` le faisnéis crios ama ceangailte (a:ref: time-chrione-aware \`\`datetime\`\`\<naive\_vs\_aware\_datetimes\>) glacfaidh an scagaire \`\`time\` leis an scagaire `time` a bhaineann leis an crios ama:ref: sonraitheoirí formáid ```` ``` ````, ``` `` ```.

Nuair a úsáidtear é gan teaghrán formáide, úsáidtear an sonraitheoir formáide TIME\_FORMAT :

```html+django
{{ value|time }}
```

tá sé mar an gcéanna le:

```html+django
{{ value|time:"TIME_FORMAT" }}
```

### `` `Time ``

Déanann dáta a fhormáidiú mar an t-am ón dáta sin (m.sh., “4 lá, 6 uair an chloig”).

Tógann sé argóint roghnach atá ina athróg ina bhfuil an dáta le húsáid mar phointe comparáide (gan an argóint, is í\*anois\* an pointe comparáide). Mar shampla, más cás dáta é `blog_date` a léiríonn meán oíche an 1 Meitheamh 2006, agus is sampla dáta é comment\_date\` le haghaidh 08:00 an 1 Meitheamh 2006, ansin fillfeadh an méid seo a leanas “8 n-uair an chloig” ar ais:

```html+django
{{ blog_date|timesince:comment_date }}
```

Cuirfear sreang folamh ar ais ar ais i gcomparáid idir amanna dáta nach n-aithníonn agus na hamanna atá ar an eolas

Is é miontuairiscí an t-aonad is lú a úsáidtear, agus cuirfear “0 nóiméad” ar ais d'aon dáta atá sa todhchaí i gcoibhneas leis an bpointe comparáide.

### `` `timéireann ``

Cosúil le `timesince`, ach amháin go dtomhaiseann sé an t-am ó seo go dtí an dáta nó an dáta-am ar leith. Mar shampla, más é an 1 Meitheamh 2006 inniu agus má tá conference\_date\` ina scála dáta a bheidh ar siúl an 29 Meitheamh 2006, ansin fillfidh {{conference\_date|timetill}} “4 seachtaine”.

Tógann sé argóint roghnach atá ina athróg ina bhfuil an dáta le húsáid mar phointe comparáide (in ionad\* anois\*). Má tá 22 Meitheamh 2006 sa `from_date`, ansin cuirfidh an méid seo a leanas ar ais “1 seachtain”:

```html+django
{{ conference_date|timeuntil:from_date }}
```

Cuirfear sreang folamh ar ais ar ais i gcomparáid idir amanna dáta nach n-aithníonn agus na hamanna atá ar an eolas

Is é miontuairiscí an t-aonad is lú a úsáidtear, agus cuirfear “0 nóiméad” ar ais d'aon dáta atá san am atá thart i gcoibhneas leis an bpointe comparáide.

### teideal \`\`

Déanann teaghrán a thiontú ina theitlicase trí fhocail a thosú le carachtar uachtarchlóir agus na carachtair atá fágtha le litreacha beaga. Ní dhéanann an chlib seo aon iarracht “focail thábhachtacha” a choinneáil i litreacha beaga.

Mar shampla:

```html+django
{{ value|title }}
```

Más é `luach` `` `mo CHÉAD phost" ``, is é an t-aschur "Mo Chéad Post” .

### `truncatechars`

Déanann sé teaghrán a ghearradh má tá sé níos faide ná an líon sonraithe carachtair. Críochnóidh teaghráin ghearrtha le carachtar ellipsis inaistrithe (“...”).

Argóint: \*\* Líon na gcarachtar le gearradh

Mar shampla:

```html+django
{{ value|truncatechars:7 }}
```

Más é `luach` `"Is slug é Joel"`, is é an t-aschur `"Joel i... "`.

### `truncatechars_html`

Cosúil le:tfilter: truncatechars, ach amháin go bhfuil sé ar an eolas faoi chlibeanna HTML. Dúntar aon chlibeanna a osclaítear sa sreangán agus nach bhfuil dúnta roimh an bpointe bearrtha díreach tar éis an chruinnithe.

Mar shampla:

```html+django
{{ value|truncatechars_html:7 }}
```

\<p\>Más é `luach` `” Is <p>slug é Joel “`, is é an\</p\> t-aschur `” Joel i... “`.\</p\>

Caomhnófar línte nua san ábhar HTML.

> **Méid an teaghrán ionchuir**
>
> Processing large, potentially malformed HTML strings can be
> resource-intensive and impact service performance.

### `` `truncatewords ``

Cuireann sé teaghrán tar éis líon áirithe focal.

Argóint: \*\* Líon na bhfocal le gearradh ina dhiaidh sin

Mar shampla:

```html+django
{{ value|truncatewords:2 }}
```

Más é `luach` `"Is slug é Joel"`, is é an t-aschur `"Is é Joel... "`.

Bainfear línte nua laistigh den teaghrán.

### `truncatewords_html`

Cosúil le:tfilter: truncatewords, ach amháin go bhfuil sé ar an eolas faoi chlibeanna HTML. Dúntar aon chlibeanna a osclaítear sa sreangán agus nach bhfuil dúnta roimh an bpointe bearrtha díreach tar éis an chruinnithe.

Níl sé seo chomh héifeachtach ná: tfilter: truncatewords, mar sin níor cheart é a úsáid ach amháin nuair a bhíonn téacs HTML á rith.

Mar shampla:

```html+django
{{ value|truncatewords_html:2 }}
```

\<p\>Más é `luach` `” Is <p>slug é Joel “`, is é an\</p\> t-aschur `” Is é Joel... “`.\</p\>

Caomhnófar línte nua san ábhar HTML.

> **Méid an teaghrán ionchuir**
>
> Processing large, potentially malformed HTML strings can be
> resource-intensive and impact service performance.

### `liosta_neamh-ordúnaí`

\<ul\>Tógann sé liosta féin-neadaithe go réasúnta agus filleann sé liosta neamh-ordaithe HTML ar ais - GAN clibeanna a oscailt agus a dhúnadh.

Glactar leis go bhfuil an liosta san fhormáid cheart. Mar shampla, má tá `var` \`\` \['Stáit', \['Kansas', \['Lawrence', 'Topeka'\], 'Illinois'\]\] , ansin \`\`{{var|unordered\_list}}\` ar ais:

```html+django
<li>States
<ul>
        <li>Kansas
        <ul>
                <li>Lawrence</li>
                <li>Topeka</li>
        </ul>
        </li>
        <li>Illinois</li>
</ul>
</li>
```

### `uachtar`

Athraíonn sé teaghrán i ngach uachchlár.

Mar shampla:

```html+django
{{ value|upper }}
```

Más é `luach` `"Is slóg é Joel"`, is é an t-aschur `"JOEL IS A SLUG"`.

### Urlencode \`\`

Éalaíonn sé luach le húsáid i URL.

Mar shampla:

```html+django
{{ value|urlencode }}
```

Más é `luach` `” https://www.example.org/foo?a=b&c=d “`, is é an aschur `"https%3A//www.example.org/foo%3FA%3DB%26C%3DD"`.

Is féidir argóint roghnach ina bhfuil na carachtair nár chóir iad a éalú a sholáthar.

Mura gcuirtear ar fáil, glactar leis an carachtar '/' sábháilte. Is féidir teaghrán folamh a sholáthar nuair ba chóir carachtair uach\* a éalú. Mar shampla:

```html+django
{{ value|urlencode:"" }}
```

Más é `luach` `” https://www.example.org/ “`, is é an t-aschur ná `"https%3A%2F%2Fwww.example.org%2F"`.

### `Urlize`

Tiontaíonn URLanna agus seoltaí ríomhphoist sa téacs ina naisc inchliceáilte.

Oibríonn an chlib teimpléad seo ar naisc réamhshocraithe le `http: //`, https: //\`, nó `www.`. Mar shampla, tiontófar `https://djangocon.eu` ach ní dhéanfaidh `djangocon.eu`.

Tacaíonn sé freisin le naisc fearainn amháin a chríochnaíonn i gceann de na fearainn barrleibhéil bunaidh (.com\`, .edu\`, .gov\`, .int \`, .mil\`, .net\`, agus `.org`). Mar shampla, déantar `djangoproject.com` a thiontú.

Is féidir le poncóireacht (tréimhsí, camóga, dlúththuismitheoirí) agus poncaíocht tosaigh (tuismitheoirí oscailte) a bheith ag naisc, agus déanfaidh urlize an rud ceart fós.

Tá tréith `rel="nofollow"` curtha leis na naisc a ghineann `urlize`.

Mar shampla:

```html+django
{{ value|urlize }}
```

If `value` is `"Check out www.djangoproject.com"`, the output will be:

```html+django
Check out <a href="http://www.djangoproject.com" rel="nofollow">www.djangoproject.com</a>
```

> **Deprecated since Django 6.0**
>
> Deprecated since version 6.0: The default protocol when none is provided will change from HTTP to HTTPS
> in Django 7.0. Hence, the output will become:
>
> ```html+django
> Check out <a href="https://www.djangoproject.com" rel="nofollow">www.djangoproject.com</a>
> ```
>
> Set the transitional setting [`URLIZE_ASSUME_HTTPS`](/ga/6.1/ref/settings/#std-setting-URLIZE_ASSUME_HTTPS) to `True` to
> opt into using HTTPS during the Django 6.x release cycle.

Chomh maith le naisc gréasáin, athraíonn `urlize` seoltaí ríomhphoist ina naisc ```mailto: ``. <a href="mailto:foo@example.com">Más é ``luach``` `"Seol ceisteanna chuig foo@example.com “`, is é an aschur `"Seol ceisteanna chuig foo@example.com “`.\</a\>

Glacann an scagaire `urlize` paraiméadar roghnach `autoescape` freisin. Má tá `autoescape` True\`, éalófar an téacs nasc agus URLanna ag baint úsáide as scagaire ionsuite Django: tfilter: escape. Is é an luach réamhshocraithe do `autoescape` `True`.

> **Note**
>
> Má chuirtear urlize\` i bhfeidhm ar théacs ina bhfuil marcáil HTML cheana féin, nó ar sheoltaí ríomhphoist ina bhfuil luachana aonair (), ní oibreoidh rudaí mar a bhíothas ag súil leis. Cuir an scagaire seo i bhfeidhm ach ar théacs simplí.

### `urlizetrunc`

Tiontaíonn sé URLanna agus seoltaí ríomhphoist ina naisc inchliceáilte díreach cosúil le [urlize](#urlize), ach cuireann sé URLanna níos faide ná an teorainn charachtair ar leith.

Argóint: \*\* Ba chóir líon na gcarachtair a nascann téacs a ghearradh leo, lena n-áirítear an ellipsis a chuirtear leis má tá gá le gearradh.

Mar shampla:

```html+django
{{ value|urlizetrunc:15 }}
```

If `value` is `"Check out www.djangoproject.com"`, the output would be:

```html+django
Check out <a href="http://www.djangoproject.com" rel="nofollow">www.djangoproj…</a>
```

> **Deprecated since Django 6.0**
>
> Deprecated since version 6.0: The default protocol when none is provided will change from HTTP to HTTPS
> in Django 7.0. Hence, the output will become:
>
> ```html+django
> Check out <a href="https://www.djangoproject.com" rel="nofollow">www.djangoproj…</a>
> ```
>
> Set the transitional setting [`URLIZE_ASSUME_HTTPS`](/ga/6.1/ref/settings/#std-setting-URLIZE_ASSUME_HTTPS) to `True` to
> opt into using HTTPS during the Django 6.x release cycle.

Mar is amhlaidh le [urlize](#urlize), níor cheart an scagaire seo a chur i bhfeidhm ach ar théacs simplí.

### comhaireamh focal \`\`

Tugann sé líon na bhfocal ar ais.

Mar shampla:

```html+django
{{ value|wordcount }}
```

Más é `luach` `` `"Is slug é Joel" ``, is é `4` an t-aschur.

### wordwrap \`\`

Fillteann sé focail ag fad líne sonraithe.

Argóint: \*\* líon na gcarachtar chun an téacs a fhilleadh

Mar shampla:

```html+django
{{ value|wordwrap:5 }}
```

Más é `luach` Sluig é Joel , bheadh an t-aschur:

```html+django
Joel
is a
slug
```

### `Yesno`

Léarscáil luachanna do `True`, False\`, agus (roghnach) None , chuig na teaghráin “yes”, “níl”, “b'fhéidir”, nó mapáil saincheaptha a rith mar liosta scartha le camóg, agus filleann sé ceann de na teaghráin sin de réir an luacha:

Mar shampla:

```html+django
{{ value|yesno:"yeah,no,maybe" }}
```

| Luach | Argóint | Aschuir |
| --- | --- | --- |
| `Fíor` |  | tá \` |
| `Fíor` | `"Sea, níl, b'fhéidir “` | `` `Yeah `` |
| `Bréag` | `"Sea, níl, b'fhéidir “` | `` `ní `` |
| `` `Aon cheann `` | `"Sea, níl, b'fhéidir “` | `d'fhéadfa` |
| `` `Aon cheann `` | "sea, níl” \`\` | ```No ``(athraíonn ``None``` go `False` mura dtugtar aon mhapáil le haghaidh `None`) |

## Clibeanna agus scagairí idirnáisiúnta

Soláthraíonn Django clibeanna teimpléad agus scagairí chun gach gné de:doc: idirnáisiúnaíon i dteimpléid a rial\</topics/i18n/index\> ú. Ceadaíonn siad rialú gráinneach ar aistriúcháin, formáidiú agus tiontaithe crios ama.

### `i18n`

Ligeann an leabharlann seo téacs inaistrithe a shonrú i dteimpl Chun é a chumasú, socraí:setting: USE\_I18N go `True`, ansin luchtaigh é le {% load i18n%} .

Féach:ref: sonraí-aistriúcháin-strings-in-theimpléad-cód.

### `l10n`

Soláthraíonn an leabharlann seo smacht ar logánú luachanna i dteimpléid. Ní gá duit ach an leabharlann a luchtú ag baint úsáide as `{% load l10n%}`.

Féach:ref: topic-l10n-templates.

### `tz`

Soláthraíonn an leabharlann seo smacht ar thiontú crios ama i teimpléid. Cosúil le `l10n`, ní gá duit ach an leabharlann a luchtú ag baint úsáide as `{% load tz%}`, ach de ghnáth socraíonn tú freis:setting: USE\_TZ go `True` ionas go dtarlóidh tiontú go am áitiúil de réir réamhshocraithe.

Féach:ref: criosanna ama-in-theimpléid'.

## leabharlanna clibeanna agus scagairí eile

\<load\>Tagann Django le cúpla leabharlann clib teimpléad eile a chaithfidh tú a chumasú go sainráite i do shuíomh: INSTALLED\_APPS agus a chumasú i do theimpléad leis an gclibe:ttag: {% load%}.

### `django.contrib.humanize`

Sraith scagairí teimpléad Django atá úsáideach chun “teagmháil dhaonna” a chur le sonraí. Féach: doc: /ref/contrib/humanize.

### `statach`

#### `statach`

Chun nasc a dhéanamh le comhaid statacha a shábháiltear in:setting: STATIC\_ROOT Seolann Django le clib teimpléad a:ttag: static. Má tá an aip: mod: django.contrib.staticfiles suiteáilte, freastalóidh an clib comhaid ag baint úsáide as modh ```url () `den stóráil a shonraítear le ``staticfiles``` in:setting: STORAGES. Mar shampla:

```html+django
{% load static %}
<img src="{% static 'images/hi.jpg' %}" alt="Hi!">
```

Tá sé in ann athróga comhthéacs caighdeánacha a ithe freisin, m.sh. ag glacadh leis go gcuirtear athróg `user_stylesheet` chuig an teimpléad:

```html+django
{% load static %}
<link rel="stylesheet" href="{% static user_stylesheet %}" media="screen">
```

Más mian leat URL statach a aisghabháil gan é a thaispeáint, is féidir leat glao beagán difriúil a úsáid:

```html+django
{% load static %}
{% static "images/hi.jpg" as myphoto %}
<img src="{{ myphoto }}" alt="Hi!">
```

> **Ag baint úsáide as teimpléid Jinja2?**
>
> Féach: Class: ~django.template.backends.jinja2.jinja2 le haghaidh faisnéise maidir leis an gclib `static` a úsáid le Jinja2.

#### `get_static_prefix`

Ba chóir duit an chlib teimpléad: ttag: static, ach má theastaíonn níos mó smachta uait ar an áit go díreach agus cona:setting: STATIC\_URL a instealladh isteach sa teimpléad, is féidir leat clib teimpléad:ttag: get\_static\_prefix a úsáid:

```html+django
{% load static %}
<img src="{% get_static_prefix %}images/hi.jpg" alt="Hi!">
```

Tá an dara foirm ann freisin is féidir leat a úsáid chun próiseáil bhreise a sheachaint má theastaíonn an luach uait arís agus arís eile:

```html+django
{% load static %}
{% get_static_prefix as STATIC_PREFIX %}

<img src="{{ STATIC_PREFIX }}images/hi.jpg" alt="Hi!">
<img src="{{ STATIC_PREFIX }}images/hi2.jpg" alt="Hello!">
```

#### `get_media_prefix`

Cosúil leis an:ttag: get\_static\_prefix, `get_media_prefix` líonann athróg teimpléad leis an réamhshocraithe:setting: MEDIA\_URL, m.sh.:

```html+django
{% load static %}
<body data-media-url="{% get_media_prefix %}">
```

Trí an luach a stóráil i dtréith sonraí, cinntímid go bhfuil sé éalaithe go cuí más mian linn é a úsáid i gcomhthéacs JavaScript.