Nette Documentation Preview

syntax
Filtre Latte
************

.[perex]
Filtrele sunt funcții care modifică sau formatează datele în forma dorită. Acesta este un rezumat al filtrelor încorporate care sunt disponibile.

.[table-latte-filters]
|## Transformare șiruri / matrice
| `batch` | [listarea datelor liniare într-un tabel |#batch]
| `breakLines` | [inserează întreruperi de linie HTML înainte de toate liniile noi |#breakLines]
| `bytes` | [formatează dimensiunea în bytes |#bytes]
| `clamp` | [fixează valoarea în intervalul |#clamp]
| `dataStream` | [Conversia protocolului URI de date |#datastream]
| `date` | [formatează data și ora |#date]
| `explode` | [separă un șir de caractere prin delimitatorul dat |#explode]
| `first` | [returnează primul element al unui array sau caracterul unui șir de caractere |#first]
| `group` | [grupează datele în funcție de diverse criterii |#group]
| `implode` | [unește un array cu un șir de caractere|#implode]
| `indent` | [indentează textul de la stânga cu un număr de tabulări |#indent]
| `join` | [unește un array cu un șir de caractere|#implode]
| `last` | [returnează ultimul element al unui array sau caracter al unui șir de caractere|#last]
| `length` | [returnează lungimea unui șir sau a unui array |#length]
| `localDate` | [formatează data și ora în funcție de locale |#localDate]
| `number` | [formatează numere |#number]
| `padLeft` | [completează șirul de caractere la o lungime dată din stânga |#padLeft]
| `padRight` | [completează șirul la lungimea dată dinspre dreapta |#padRight]
| `random` | [returnează un element aleatoriu al unui array sau un caracter al unui șir de caractere|#random]
| `repeat` | [repetă șirul |#repeat]
| `replace` | [înlocuiește toate aparițiile șirului de căutare cu șirul de înlocuire |#replace]
| `replaceRE` | [înlocuiește toate aparițiile în funcție de expresia regulată |#replaceRE]
| `reverse` | [inversează un șir sau o matrice UTF-8 |#reverse]
| `slice` | [extrage o porțiune dintr-un array sau un șir de caractere |#slice]
| `sort` | [sortează un array |#sort]
| `spaceless` | [elimină spațiile albe |#spaceless], similar cu tag-ul [fără spațiu |tags]
| `split` | [împarte un șir de caractere după delimitatorul dat |#explode]
| `strip` | [elimină spațiile albe |#spaceless]
| `stripHtml` | [elimină etichetele HTML și convertește entitățile HTML în text |#stripHtml]
| `substr` | [returnează o parte din șir |#substr]
| `trim` | [elimină spațiile albe din șirul de caractere |#trim]
| `translate` | [traducere în alte limbi |#translate]
| `truncate` | [scurtează lungimea păstrând cuvinte întregi |#truncate]
| `webalize` | [adaptează șirul UTF-8 la forma utilizată în URL |#webalize]

.[table-latte-filters]
|## Casetarea literelor
| `capitalize` | [litere minuscule, prima literă a fiecărui cuvânt majusculă |#capitalize]
| `firstUpper` | [face ca prima literă să fie majusculă |#firstUpper]
| `lower` | [face ca un șir de caractere să fie minuscul |#lower]
| `upper` | [face un șir de caractere majuscule |#upper]

.[table-latte-filters]
|## Rotunjirea numerelor
| `ceil` | [rotunjește un număr până la o precizie dată |#ceil]
| `floor` | [rotunjește un număr la o precizie dată, în jos |#floor]
| `round` | [rotunjește un număr la o precizie dată |#round]

.[table-latte-filters]
|## Escaping
| `escapeUrl` | [evită parametrii în URL |#escapeUrl]
| `noescape` | [tipărește o variabilă fără scăpare |#noescape]
| `query` | [generează un șir de interogare în URL |#query]

Există, de asemenea, filtre de [scăpare |safety-first#Context-aware escaping] pentru HTML (`escapeHtml` și `escapeHtmlComment`), XML (`escapeXml`), JavaScript (`escapeJs`), CSS (`escapeCss`) și iCalendar (`escapeICal`), pe care Latte le utilizează singur datorită [scăpării în funcție de context |safety-first#Context-aware escaping] și pe care nu este nevoie să le scrieți.

.[table-latte-filters]
|## Securitate
| `checkUrl` | [dezinfectează șirul de caractere pentru utilizarea în interiorul atributului href |#checkUrl]
| `nocheck` | [previne dezinfectarea automată a URL-urilor |#nocheck]

Latte [verifică automat |safety-first#link checking] atributele `src` și `href`, astfel încât aproape că nu este nevoie să utilizați filtrul `checkUrl`.


.[note]
Toate filtrele încorporate funcționează cu șiruri de caractere codificate UTF-8.


Utilizare .[#toc-usage]
=======================

Latte permite apelarea filtrelor folosind notația "pipe" (este permisă folosirea unui spațiu înainte):

```latte
<h1>{$heading|upper}</h1>
```

Filtrele pot fi înlănțuite, caz în care se aplică în ordine de la stânga la dreapta:

```latte
<h1>{$heading|lower|capitalize}</h1>
```

Parametrii se pun după numele filtrului, separați prin două puncte sau virgulă:

```latte
<h1>{$heading|truncate:20,''}</h1>
```

Filtrele pot fi aplicate pe expresie:

```latte
{var $name = ($title|upper) . ($subtitle|lower)}</h1>
```

[Filtrele personalizate |extending-latte#filters] pot fi înregistrate în acest mod:

```php
$latte = new Latte\Engine;
$latte->addFilter('shortify', fn(string $s, int $len = 10) => mb_substr($s, 0, $len));
```

Îl folosim într-un șablon ca acesta:

```latte
<p>{$text|shortify}</p>
<p>{$text|shortify:100}</p>
```


Filtre .[#toc-filters]
======================


batch(int $length, mixed $item): array .[filter]
------------------------------------------------
Filtru care simplifică listarea datelor liniare sub formă de tabel. Acesta returnează o matrice de tablouri cu numărul dat de elemente. Dacă furnizați un al doilea parametru, acesta este utilizat pentru a completa elementele lipsă de pe ultimul rând.

```latte
{var $items = ['a', 'b', 'c', 'd', 'e']}
<table>
{foreach ($items|batch: 3, 'No item') as $row}
	<tr>
		{foreach $row as $column}
			<td>{$column}</td>
		{/foreach}
	</tr>
{/foreach}
</table>
```

Se tipărește:

```latte
<table>
	<tr>
		<td>a</td>
		<td>b</td>
		<td>c</td>
	</tr>
	<tr>
		<td>d</td>
		<td>e</td>
		<td>No item</td>
	</tr>
</table>
```

A se vedea, de asemenea, [grupul |#group] și eticheta [iterateWhile |tags#iterateWhile].


breakLines .[filter]
--------------------
Inserează întreruperi de linie HTML înainte de toate liniile noi.

```latte
{var $s = "Text & with \n newline"}
{$s|breakLines}    {* outputs "Text & with <br>\n newline" *}
```


bytes(int $precision=2) .[filter]
---------------------------------
Formatează dimensiunea în octeți într-o formă lizibilă de către om. Dacă este setată [localitatea |develop#locale], sunt utilizate separatoarele corespunzătoare de zecimale și de mii.

```latte
{$size|bytes}     0 B, 1.25 GB, …
{$size|bytes:0}   10 B, 1 GB, …
```


ceil(int $precision=0) .[filter]
--------------------------------
Rotunjește un număr până la o precizie dată.

```latte
{=3.4|ceil}         {* ieșiri 4 *}
{=135.22|ceil:1}    {* ieșiri 135.3 *}
{=135.22|ceil:3}    {* ieșiri 135.22 *}
```

A se vedea, de asemenea, [floor |#floor], [round |#round].


capitalize .[filter]
--------------------
Returnează o versiune a valorii cu titlu. Cuvintele vor începe cu litere majuscule, toate caracterele rămase sunt minuscule. Necesită extensia PHP `mbstring`.

```latte
{='i like LATTE'|capitalize}  {* outputs 'I Like Latte' *}
```

A se vedea, de asemenea, [firstUpper |#firstUpper], [lower |#lower], [upper |#upper].


checkUrl .[filter]
------------------
Aplică igienizarea URL-urilor. Verifică dacă variabila conține un URL web (adică protocolul HTTP/HTTPS) și previne scrierea de linkuri care pot reprezenta un risc de securitate.

```latte
{var $link = 'javascript:window.close()'}
<a data-href={$link|checkUrl}>checked</a>
<a data-href={$link}>unchecked</a>
```

Imprimă:

```latte
<a data-href="">checked</a>
<a data-href="javascript:window.close()">unchecked</a>
```

A se vedea și [nocheck |#nocheck].


clamp(int|float $min, int|float $max) .[filter]
-----------------------------------------------
Returnează valoarea fixată în intervalul inclusiv dintre min și max.

```latte
{$level|clamp: 0, 255}
```

Există, de asemenea, ca [funcție |functions#clamp].


dataStream(string $mimetype=detect) .[filter]
---------------------------------------------
Convertește conținutul în schema URI de date. Poate fi utilizat pentru a insera imagini în HTML sau CSS fără a fi nevoie să se facă legătura cu fișiere externe.

Să avem o imagine într-o variabilă `$img = Image::fromFile('obrazek.gif')`, atunci

```latte
<img src={$img|dataStream}>
```

Se imprimă de exemplu:

```latte
<img src="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAUA
AAAFCAYAAACNbyblAAAAHElEQVQI12P4//8/w38GIAXDIBKE0DHxgljNBAAO
9TXL0Y4OHwAAAABJRU5ErkJggg==">
```

.[caution]
Necesită extensia PHP `fileinfo`.


date(string $format) .[filter]
------------------------------
Formatează data și ora în conformitate cu masca utilizată de funcția PHP [php:date]. Filtrul acceptă data în format UNIX timestamp, ca șir de caractere sau ca obiect `DateTimeInterface`.

```latte
{$today|date:'j. n. Y'}
```

A se vedea și [localDate |#localDate].


escapeUrl .[filter]
-------------------
Scapă o variabilă pentru a fi utilizată ca parametru în URL.

```latte
<a href="http://example.com/{$name|escapeUrl}">{$name}</a>
```

A se vedea, de asemenea, [query |#query].


explode(string $separator='') .[filter]
---------------------------------------
Împarte un șir de caractere după delimitatorul dat și returnează un tablou de șiruri de caractere. Alias pentru `split`.

```latte
{='one,two,three'|explode:','}    {* returns ['one', 'two', 'three'] *}
```

Dacă delimitatorul este un șir de caractere gol (valoare implicită), datele de intrare vor fi împărțite în caractere individuale:

```latte
{='123'|explode}                  {* returnează ['1', '2', '3'] *}
```

Puteți utiliza și aliasul `split`:

```latte
{='1,2,3'|split:','}              {* returnează ['1', '2', '3'] *}
```

A se vedea și [implode |#implode].


first .[filter]
---------------
Returnează primul element al unui array sau caracterul unui șir de caractere:

```latte
{=[1, 2, 3, 4]|first}    {* ieșiri 1 *}
{='abcd'|first}          {* iese "a" *}
```

A se vedea, de asemenea, [last |#last], [random |#random].


floor(int $precision=0) .[filter]
---------------------------------
Rotunjește un număr până la o precizie dată.

```latte
{=3.5|floor}        {* ieșiri 3 *}
{=135.79|floor:1}   {* ieșiri 135.7 *}
{=135.79|floor:3}   {* ieșiri 135.79 *}
```

A se vedea și [plafon |#ceil], [rotunjire |#round].


firstUpper .[filter]
--------------------
Convertește prima literă a unei valori în majusculă. Necesită extensia PHP `mbstring`.

```latte
{='the latte'|firstUpper}  {* outputs 'The latte' *}
```

A se vedea, de asemenea, [capitalize |#capitalize], [lower |#lower], [upper |#upper].


group(string|int|\Closure $by): array .[filter]{data-version:3.0.16}
--------------------------------------------------------------------
Filtrul grupează datele în funcție de diferite criterii.

În acest exemplu, rândurile din tabel sunt grupate în funcție de coloana `categoryId`. Rezultatul este un tablou de tablouri în care cheia este valoarea din coloana `categoryId`. Citiți [instrucțiunile detaliate |cookbook/grouping].

```latte
{foreach ($items|group: categoryId) as $categoryId => $categoryItems}
    <ul>
        {foreach $categoryItems as $item}
            <li>{$item->name}</li>
        {/foreach}
    </ul>
{/foreach}
```

A se vedea, de asemenea, [batch |#batch], funcția [group |functions#group] și eticheta [iterateWhile |tags#iterateWhile].


implode(string $glue='') .[filter]
----------------------------------
Returnează un șir de caractere care este concatenarea șirurilor din matrice. Alias pentru `join`.

```latte
{=[1, 2, 3]|implode}      {* iese "123" *}
{=[1, 2, 3]|implode:'|'}  {* iese '1|2|3' *}
```

Puteți utiliza și un alias `join`:

```latte
{=[1, 2, 3]|join}         {* acest "123" *}
```


indent(int $level=1, string $char="\t") .[filter]
-------------------------------------------------
Indentează un text de la stânga cu un anumit număr de tabulauri sau alte caractere pe care îl specificăm în al doilea argument opțional. Liniile goale nu sunt indentate.

```latte
<div>
{block |indent}
<p>Hello</p>
{/block}
</div>
```

Imprimă:

```latte
<div>
	<p>Hello</p>
</div>
```


last .[filter]
--------------
Returnează ultimul element al unui array sau caracterul unui șir de caractere:

```latte
{=[1, 2, 3, 4]|last}    {* ieșiri 4 *}
{='abcd'|last}          {* ieșiri 'd' *}
```

A se vedea, de asemenea, [first |#first], [random |#random].


length .[filter]
----------------
Returnează lungimea unui șir de caractere sau a unei matrice.

- pentru șiruri de caractere, va returna lungimea în caractere UTF-8
- pentru array-uri, va returna numărul de elemente.
- pentru obiectele care implementează interfața Countable, se va utiliza valoarea returnată de count().
- pentru obiectele care implementează interfața IteratorAggregate, se va utiliza valoarea returnată de iterator_count().


```latte
{if ($users|length) > 10}
	...
{/if}
```


localDate(?string $format=null, ?string $date=null, ?string $time=null) .[filter]
---------------------------------------------------------------------------------
Formatează data și ora în funcție de [locale |develop#locale], asigurând afișarea consecventă și localizată a datelor de timp în diferite limbi și regiuni. Filtrul acceptă data ca timestamp UNIX, șir sau obiect `DateTimeInterface`.

```latte
{$date|localDate}                  {* 15. dubna 2024 *}
{$date|format: yM}                 {* 4/2024 *}
{$date|localDate: date: medium}    {* 15. 4. 2024 *}
```

Dacă utilizați filtrul fără niciun parametru, acesta va afișa data în format lung, după cum se explică în continuare.

**a) Utilizarea formatului**

Parametrul `format` descrie componentele de timp care ar trebui afișate. Acesta utilizează coduri de litere, unde numărul de repetiții afectează lățimea ieșirii:

| An | `y` / `yy` / `yyyy` | `2024` / `24` / `2024`
| Luna | `M` / `MM` / `MMM` / `MMMM` | `8` / `08` / `aug.` / `august`
| Zi | `d` / `dd` / `E` / `EEEE` | `1` / `01` / `dum.` / `duminică`
| Ora | `j` / `H` / `h` | preferat / 24 de ore / 12 ore
| Minute | `m` / `mm` | `5` / `05` <small>(2 cifre atunci când sunt combinate cu secundele)</small>
| Second | `s` / `ss` | `8` / `08` <small>(2 cifre atunci când sunt combinate cu minutele)</small>

Ordinea codurilor în format nu contează, deoarece ordinea componentelor va fi afișată în conformitate cu convențiile locale. Prin urmare, formatul este independent de locale. De exemplu, formatul `yyyyMMMMd` în localul `en_US` afișează `April 15, 2024`, în timp ce în localul `cs_CZ` afișează `15. dubna 2024`:

| locale:  | ro-RO | en_US
|---
| `format: 'dMy'` | 10.08.2024 | 8/10/2024
| `format: 'yM'` | 08.2024 | 8/2024
| `format: 'yyyyMMMM'` | august 2024 | August 2024
| `format: 'MMMM'` | august | August
| `format: 'jm'` | 17:54 | 5:54 PM
| `format: 'Hm'` | 17:54 | 17:54
| `format: 'hm'` | 5:54 p.m. | 5:54 PM


**b) Utilizarea stilurilor prestabilite**

Parametrii `date` și `time` determină nivelul de detaliu pentru afișarea datei și orei. Puteți alege din mai multe niveluri: `full`, `long`, `medium`, `short`. Puteți afișa doar data, doar ora sau ambele:

| locale:  | ro-RO | en_US
|---
| `date: short` | 23.01.1978 | 1/23/78
| `date: medium` | 23 ian. 1978 | Jan 23, 1978
| `date: long` | 23 ianuarie 1978 | January 23, 1978
| `date: full` | luni, 23 ianuarie 1978 | Monday, January 23, 1978
| `time: short` | 08:30 | 8:30 AM
| `time: medium` | 08:30:59 | 8:30:59 AM
| `time: long` | 08:30:59 CET | 8:30:59 AM GMT+1
| `date: short, time: short` | 23.01.1978, 08:30 | 1/23/78, 8:30 AM
| `date: medium, time: short` | 23 ian. 1978, 08:30 | Jan 23, 1978, 8:30 AM
| `date: long, time: short` | 23 ianuarie 1978 la 08:30 | January 23, 1978 at 8:30 AM

Pentru dată, puteți utiliza, de asemenea, prefixul `relative-` (de exemplu, `relative-short`), care pentru datele apropiate de prezent va afișa `yesterday`, `today` sau `tomorrow`; în caz contrar, se va afișa în mod standard.

```latte
{$date|localDate: date: relative-short}    {* yesterday *}
```

A se vedea și [data |#date].


lower .[filter]
---------------
Convertește o valoare în minuscule. Necesită extensia PHP `mbstring`.

```latte
{='LATTE'|lower}   {* acest "latte" *}
```

A se vedea, de asemenea, [capitalize |#capitalize], [firstUpper |#firstUpper], [upper |#upper].


nocheck .[filter]
-----------------
Împiedică dezinfectarea automată a URL-urilor. Latte [verifică automat |safety-first#Link checking] dacă variabila conține un URL web (adică protocolul HTTP/HTTPS) și împiedică scrierea de link-uri care pot reprezenta un risc de securitate.

Dacă link-ul utilizează o schemă diferită, cum ar fi `javascript:` sau `data:`, și sunteți sigur de conținutul acestuia, puteți dezactiva verificarea prin intermediul `|nocheck`.

```latte
{var $link = 'javascript:window.close()'}

<a href={$link}>checked</a>
<a href={$link|nocheck}>unchecked</a>
```

Tipărituri:

```latte
<a href="">checked</a>
<a href="javascript:window.close()">unchecked</a>
```

A se vedea, de asemenea, [checkUrl |#checkUrl].


noescape .[filter]
------------------
Dezactive scăparea automată.

```latte
{var $trustedHtmlString = '<b>hello</b>'}
Escaped: {$trustedHtmlString}
Unescaped: {$trustedHtmlString|noescape}
```

Imprimă:

```latte
Escaped: &lt;b&gt;hello&lt;/b&gt;
Unescaped: <b>hello</b>
```

.[warning]
Folosirea abuzivă a filtrului `noescape` poate duce la o vulnerabilitate XSS! Nu îl utilizați niciodată decât dacă sunteți **absolut sigur** de ceea ce faceți și dacă șirul pe care îl imprimați provine dintr-o sursă de încredere.


number(int $decimals=0, string $decPoint='.', string $thousandsSep=',') .[filter]
---------------------------------------------------------------------------------
Formatează un număr la un număr specificat de zecimale. Dacă este setată [localitatea |develop#locale], se utilizează separatoarele de zecimale și de mii corespunzătoare.

```latte
{1234.20 |number}              1,234
{1234.20 |number:1}            1,234.2
{1234.20 |number:2}            1,234.20
{1234.20 |number:2, ',', ' '}  1 234,20
```


number(string $format) .[filter]
--------------------------------
Parametrul `format` vă permite să definiți aspectul numerelor exact în funcție de nevoile dumneavoastră. Acesta necesită o [localitate |develop#locale] stabilită. Formatul constă din mai multe caractere speciale, a căror descriere completă poate fi găsită în documentația "DecimalFormat":https://unicode.org/reports/tr35/tr35-numbers.html#Number_Format_Patterns:

- <c id=6/> cifră obligatorie, afișată întotdeauna chiar dacă este zero
- `#` cifră opțională, afișată numai dacă numărul are o cifră în acel loc
- `@` cifră semnificativă, ajută la afișarea numărului cu un anumit număr de cifre semnificative
- `.` marchează locul unde ar trebui să fie separatorul zecimal (virgulă sau punct, în funcție de localitate)
- `,` utilizat pentru a separa grupuri de cifre, de obicei mii
- `%` înmulțește numărul cu 100 și adaugă semnul procentului

Să ne uităm la câteva exemple. În primul exemplu, două zecimale sunt obligatorii; în al doilea, ele sunt opționale. Al treilea exemplu prezintă o umplere cu zerouri pe ambele părți, iar al patrulea afișează doar cifrele existente:

```latte
{1234.5|number: '#,##0.00'}     {* 1,234.50 *}
{1234.5|number: '#,##0.##'}     {* 1,234.5 *}
{1.23  |number: '000.000'}      {* 001.230 *}
{1.2   |number: '##.##'}        {* 1.2 *}
```

Cifrele semnificative determină câte cifre, indiferent de punctul zecimal, ar trebui afișate, rotunjind numărul dacă este necesar:

```latte
{1234|number: '@@'}             {* 1200 *}
{1234|number: '@@@'}            {* 1230 *}
{1234|number: '@@@#'}           {* 1234 *}
{1.2345|number: '@@@'}          {* 1.23 *}
{0.00123|number: '@@'}          {* 0.0012 *}
```

O modalitate ușoară de a afișa un număr ca procent. Numărul este înmulțit cu 100 și se adaugă semnul `%`:

```latte
{0.1234|number: '#.##%'}        {* 12.34% *}
```

Putem defini un format diferit pentru numerele pozitive și negative, separate de un caracter `;`. În acest fel, de exemplu, numerele pozitive pot fi afișate cu un semn `+`:

```latte
{42|number: '#.##;(#.##)'}      {* 42 *}
{-42|number: '#.##;(#.##)'}     {* (42) *}
{42|number: '+#.##;-#.##'}      {* +42 *}
{-42|number: '+#.##;-#.##'}     {* -42 *}
```

Rețineți că aspectul real al numerelor poate varia în funcție de setările locale. De exemplu, în unele țări, se utilizează o virgulă în loc de un punct ca separator zecimal. Acest filtru ține cont automat de acest lucru, deci nu trebuie să vă faceți griji.


padLeft(int $length, string $pad=' ') .[filter]
-----------------------------------------------
Pads un șir de caractere la o anumită lungime cu un alt șir de caractere din stânga.

```latte
{='hello'|padLeft: 10, '123'}  {* ieșiri '12312hello' *}
```


padRight(int $length, string $pad=' ') .[filter]
------------------------------------------------
Adaugă un șir de caractere la o anumită lungime cu un alt șir din dreapta.

```latte
{='hello'|padRight: 10, '123'}  {* ieșiri 'hello12312' *}
```


query  .[filter]
----------------
Generează dinamic un șir de interogare în URL:

```latte
<a href="http://example.com/?{[name: 'John Doe', age: 43]|query}">click</a>
<a href="http://example.com/?search={$search|query}">search</a>
```

Imprimă:

```latte
<a href="http://example.com/?name=John+Doe&amp;age=43">click</a>
<a href="http://example.com/?search=Foo+Bar">search</a>
```

Cheile cu o valoare de `null` sunt omise.

A se vedea, de asemenea, [escapeUrl |#escapeUrl].


random .[filter]
----------------
Returnează un element aleatoriu din matrice sau un caracter aleatoriu dintr-un șir de caractere:

```latte
{=[1, 2, 3, 4]|random}    {* exemplu de ieșire: 3 *}
{='abcd'|random}          {* exemplu de ieșire: 'b' *}
```

A se vedea, de asemenea, [first |#first], [last |#last].


repeat(int $count) .[filter]
----------------------------
Repetă șirul de x ori.

```latte
{='hello'|repeat: 3}  {* outputs 'hellohellohello' *}
```


replace(string|array $search, string $replace='') .[filter]
-----------------------------------------------------------
Înlocuiește toate aparițiile șirului de căutare cu șirul de înlocuire.

```latte
{='hello world'|replace: 'world', 'friend'}  {* iese 'hello friend' *}
```

Se pot face mai multe înlocuiri deodată:

```latte
{='hello world'|replace: [h => l, l => h]}  {* outputs 'lehho worhd' *}
```


replaceRE(string $pattern, string $replace='') .[filter]
--------------------------------------------------------
Înlocuiește toate ocurențele în funcție de expresia regulată.

```latte
{='hello world'|replaceRE: '/l.*/', 'l'}  {* outputs 'hel' *}
```


reverse .[filter]
-----------------
Inversează șirul sau matricea dată.

```latte
{var $s = 'Nette'}
{$s|reverse}    {* iese "etteN" *}
{var $a = ['N', 'e', 't', 't', 'e']}
{$a|reverse}    {* returnează ['e', 't', 't', 'e', 'N'] *}
```


round(int $precision=0) .[filter]
---------------------------------
Rotunjește un număr la o precizie dată.

```latte
{=3.4|round}        {* ieșiri 3 *}
{=3.5|round}        {* ieșiri 4 *}
{=135.79|round:1}   {* ieșiri 135.8 *}
{=135.79|round:3}   {* ieșiri 135.79 *}
```

A se vedea, de asemenea, [plafon |#ceil], [podea |#floor].


slice(int $start, ?int $length=null, bool $preserveKeys=false) .[filter]
------------------------------------------------------------------------
Extrage o porțiune dintr-un tablou sau un șir de caractere.

```latte
{='hello'|slice: 1, 2}           {* ieșiri 'el' *}
{=['a', 'b', 'c']|slice: 1, 2}   {* ieșiri ['b', 'c'] *}
```

Filtrul slice funcționează ca funcția PHP `array_slice` pentru array-uri și `mb_substr` pentru șiruri de caractere, cu o revenire la `iconv_substr` în modul UTF-8.

În cazul în care startul nu este negativ, secvența va începe de la acel start în variabilă. Dacă start este negativ, secvența va începe la acea distanță de la sfârșitul variabilei.

În cazul în care lungimea este dată și este pozitivă, atunci secvența va avea până la numărul de elemente din ea. În cazul în care variabila este mai scurtă decât lungimea, atunci vor fi prezente numai elementele disponibile ale variabilei. În cazul în care lungimea este dată și este negativă, secvența se va opri la atâtea elemente de la sfârșitul variabilei. În cazul în care este omisă, secvența va conține toate elementele de la offset până la sfârșitul variabilei.

Filter reordonează și resetează implicit cheile tabloului de numere întregi. Acest comportament poate fi modificat prin setarea preserveKeys la true. Cheile șirurilor de caractere sunt întotdeauna păstrate, indiferent de acest parametru.


sort(?Closure $comparison, string|int|\Closure|null $by=null, string|int|\Closure|bool $byKey=false) .[filter]
--------------------------------------------------------------------------------------------------------------
Filtrul sortează elementele unui array sau iterator păstrând cheile lor asociative. Atunci când este setată o [localitate |develop#locale], sortarea urmează regulile acesteia, cu excepția cazului în care este specificată o funcție de comparație personalizată.

```latte
{foreach ($names|sort) as $name}
	...
{/foreach}
```

Array sortat în ordine inversă.

```latte
{foreach ($names|sort|reverse) as $name}
	...
{/foreach}
```

Puteți specifica o funcție de comparație personalizată pentru sortare (exemplul arată cum se inversează sortarea de la cel mai mare la cel mai mic):

```latte
{var $reverted = ($names|sort: fn($a, $b) => $b <=> $a)}
```

Filtrul `|sort` vă permite, de asemenea, să sortați elementele după cheie:

```latte
{foreach ($names|sort: byKey: true) as $name}
	...
{/foreach}
```

Dacă aveți nevoie să sortați un tabel după o anumită coloană, puteți utiliza parametrul `by`. Valoarea `'name'` din exemplu specifică faptul că sortarea se va face după `$row->name` sau `$row['name']`, în funcție de faptul că `$row` este o matrice sau un obiect:

```latte
{foreach ($items|sort: by: 'name') as $item}
	{$item->name}
{/foreach}
```

De asemenea, puteți defini o funcție de apelare care să determine valoarea după care se va sorta:

```latte
{foreach ($items|sort: by: fn($items) => $items->category->name) as $item}
	{$item->name}
{/foreach}
```

Parametrul `byKey` poate fi utilizat în același mod.


spaceless  .[filter]
--------------------
Îndepărtează spațiile albe inutile din rezultat. De asemenea, puteți utiliza aliasul `strip`.

```latte
{block |spaceless}
	<ul>
		<li>Hello</li>
	</ul>
{/block}
```

Imprimă:

```latte
<ul> <li>Hello</li> </ul>
```


stripHtml .[filter]
-------------------
Convertește HTML în text simplu. Adică, elimină etichetele HTML și convertește entitățile HTML în text.

```latte
{='<p>one &lt; two</p>'|stripHtml}  {* outputs 'one < two' *}
```

Textul simplu rezultat poate conține, în mod natural, caractere care reprezintă etichete HTML, de exemplu `'&lt;p&gt;'|stripHtml` este convertit în `<p>`. Nu scoateți niciodată textul rezultat cu `|noescape`, deoarece acest lucru poate duce la o vulnerabilitate de securitate.


substr(int $offset, ?int $length=null) .[filter]
------------------------------------------------
Extrage o porțiune dintr-un șir de caractere. Acest filtru a fost înlocuit cu un filtru de [felie |#slice].

```latte
{$string|substr: 1, 2}
```


translate(string $message, ...$args) .[filter]
----------------------------------------------
Traduce expresii în alte limbi. Pentru ca filtrul să fie disponibil, trebuie să configurați [translator |develop#TranslatorExtension]. De asemenea, puteți utiliza [etichetele pentru traducere |tags#Translation].

```latte
<a href="basket">{='Baskter'|translate}</a>
<span>{$item|translate}</span>
```


trim(string $charlist=" \t\n\r\0\x0B\u{A0}") .[filter]
------------------------------------------------------
Elimină caracterele de început și de sfârșit, implicit spațiile albe.

```latte
{='  I like Latte.  '|trim}    {* outputs 'I like Latte.' *}
{='  I like Latte.'|trim: '.'} {* outputs '  I like Latte' *}
```


truncate(int $length, string $append='…') .[filter]
---------------------------------------------------
Scurtează un șir de caractere până la lungimea maximă dată, dar încearcă să păstreze cuvintele întregi. În cazul în care șirul este trunchiat, adaugă elipse la sfârșit (acest lucru poate fi modificat prin intermediul celui de-al doilea parametru).

```latte
{var $title = 'Hello, how are you?'}
{$title|truncate:5}  {* Hell…                *}
{$title|truncate:17} {* Hello, how are…      *}
{$title|truncate:30} {* Hello, how are you?  *}
```


upper .[filter]
---------------
Convertește o valoare în majuscule. Necesită extensia PHP `mbstring`.

```latte
{='latte'|upper}  {* outputs 'LATTE' *}
```

A se vedea, de asemenea, [capitalize |#capitalize], [firstUpper |#firstUpper], [lower |#lower].


webalize .[filter]
------------------
Convertește în ASCII.

Convertește spațiile în cratimă. Îndepărtează caracterele care nu sunt alfanumerice, sublinieri sau cratime. Convertește în minuscule. Îndepărtează, de asemenea, spațiile albe de început și de sfârșit.

```latte
{var $s = 'Our 10. product'}
{$s|webalize}    {* outputs 'our-10-product' *}
```

.[caution]
Necesită pachetul [nette/utils |utils:].

Filtre Latte

Filtrele sunt funcții care modifică sau formatează datele în forma dorită. Acesta este un rezumat al filtrelor încorporate care sunt disponibile.

Transformare șiruri / matrice
batch listarea datelor liniare într-un tabel
breakLines inserează întreruperi de linie HTML înainte de toate liniile noi
bytes formatează dimensiunea în bytes
clamp fixează valoarea în intervalul
dataStream Conversia protocolului URI de date
date formatează data și ora
explode separă un șir de caractere prin delimitatorul dat
first returnează primul element al unui array sau caracterul unui șir de caractere
group grupează datele în funcție de diverse criterii
implode unește un array cu un șir de caractere
indent indentează textul de la stânga cu un număr de tabulări
join unește un array cu un șir de caractere
last returnează ultimul element al unui array sau caracter al unui șir de caractere
length returnează lungimea unui șir sau a unui array
localDate formatează data și ora în funcție de locale
number formatează numere
padLeft completează șirul de caractere la o lungime dată din stânga
padRight completează șirul la lungimea dată dinspre dreapta
random returnează un element aleatoriu al unui array sau un caracter al unui șir de caractere
repeat repetă șirul
replace înlocuiește toate aparițiile șirului de căutare cu șirul de înlocuire
replaceRE înlocuiește toate aparițiile în funcție de expresia regulată
reverse inversează un șir sau o matrice UTF-8
slice extrage o porțiune dintr-un array sau un șir de caractere
sort sortează un array
spaceless elimină spațiile albe, similar cu tag-ul fără spațiu
split împarte un șir de caractere după delimitatorul dat
strip elimină spațiile albe
stripHtml elimină etichetele HTML și convertește entitățile HTML în text
substr returnează o parte din șir
trim elimină spațiile albe din șirul de caractere
translate traducere în alte limbi
truncate scurtează lungimea păstrând cuvinte întregi
webalize adaptează șirul UTF-8 la forma utilizată în URL
Casetarea literelor
capitalize litere minuscule, prima literă a fiecărui cuvânt majusculă
firstUpper face ca prima literă să fie majusculă
lower face ca un șir de caractere să fie minuscul
upper face un șir de caractere majuscule
Rotunjirea numerelor
ceil rotunjește un număr până la o precizie dată
floor rotunjește un număr la o precizie dată, în jos
round rotunjește un număr la o precizie dată
Escaping
escapeUrl evită parametrii în URL
noescape tipărește o variabilă fără scăpare
query generează un șir de interogare în URL

Există, de asemenea, filtre de scăpare pentru HTML (escapeHtml și escapeHtmlComment), XML (escapeXml), JavaScript (escapeJs), CSS (escapeCss) și iCalendar (escapeICal), pe care Latte le utilizează singur datorită scăpării în funcție de context și pe care nu este nevoie să le scrieți.

Securitate
checkUrl dezinfectează șirul de caractere pentru utilizarea în interiorul atributului href
nocheck previne dezinfectarea automată a URL-urilor

Latte verifică automat atributele src și href, astfel încât aproape că nu este nevoie să utilizați filtrul checkUrl.

Toate filtrele încorporate funcționează cu șiruri de caractere codificate UTF-8.

Utilizare

Latte permite apelarea filtrelor folosind notația „pipe“ (este permisă folosirea unui spațiu înainte):

<h1>{$heading|upper}</h1>

Filtrele pot fi înlănțuite, caz în care se aplică în ordine de la stânga la dreapta:

<h1>{$heading|lower|capitalize}</h1>

Parametrii se pun după numele filtrului, separați prin două puncte sau virgulă:

<h1>{$heading|truncate:20,''}</h1>

Filtrele pot fi aplicate pe expresie:

{var $name = ($title|upper) . ($subtitle|lower)}</h1>

Filtrele personalizate pot fi înregistrate în acest mod:

$latte = new Latte\Engine;
$latte->addFilter('shortify', fn(string $s, int $len = 10) => mb_substr($s, 0, $len));

Îl folosim într-un șablon ca acesta:

<p>{$text|shortify}</p>
<p>{$text|shortify:100}</p>

Filtre

batch (int $length, mixed $item)array

Filtru care simplifică listarea datelor liniare sub formă de tabel. Acesta returnează o matrice de tablouri cu numărul dat de elemente. Dacă furnizați un al doilea parametru, acesta este utilizat pentru a completa elementele lipsă de pe ultimul rând.

{var $items = ['a', 'b', 'c', 'd', 'e']}
<table>
{foreach ($items|batch: 3, 'No item') as $row}
	<tr>
		{foreach $row as $column}
			<td>{$column}</td>
		{/foreach}
	</tr>
{/foreach}
</table>

Se tipărește:

<table>
	<tr>
		<td>a</td>
		<td>b</td>
		<td>c</td>
	</tr>
	<tr>
		<td>d</td>
		<td>e</td>
		<td>No item</td>
	</tr>
</table>

A se vedea, de asemenea, grupul și eticheta iterateWhile.

breakLines

Inserează întreruperi de linie HTML înainte de toate liniile noi.

{var $s = "Text & with \n newline"}
{$s|breakLines}    {* outputs "Text & with <br>\n newline" *}

bytes (int $precision=2)

Formatează dimensiunea în octeți într-o formă lizibilă de către om. Dacă este setată localitatea, sunt utilizate separatoarele corespunzătoare de zecimale și de mii.

{$size|bytes}     0 B, 1.25 GB, …
{$size|bytes:0}   10 B, 1 GB, …

ceil (int $precision=0)

Rotunjește un număr până la o precizie dată.

{=3.4|ceil}         {* ieșiri 4 *}
{=135.22|ceil:1}    {* ieșiri 135.3 *}
{=135.22|ceil:3}    {* ieșiri 135.22 *}

A se vedea, de asemenea, floor, round.

capitalize

Returnează o versiune a valorii cu titlu. Cuvintele vor începe cu litere majuscule, toate caracterele rămase sunt minuscule. Necesită extensia PHP mbstring.

{='i like LATTE'|capitalize}  {* outputs 'I Like Latte' *}

A se vedea, de asemenea, firstUpper, lower, upper.

checkUrl

Aplică igienizarea URL-urilor. Verifică dacă variabila conține un URL web (adică protocolul HTTP/HTTPS) și previne scrierea de linkuri care pot reprezenta un risc de securitate.

{var $link = 'javascript:window.close()'}
<a data-href={$link|checkUrl}>checked</a>
<a data-href={$link}>unchecked</a>

Imprimă:

<a data-href="">checked</a>
<a data-href="javascript:window.close()">unchecked</a>

A se vedea și nocheck.

clamp (int|float $min, int|float $max)

Returnează valoarea fixată în intervalul inclusiv dintre min și max.

{$level|clamp: 0, 255}

Există, de asemenea, ca funcție.

dataStream (string $mimetype=detect)

Convertește conținutul în schema URI de date. Poate fi utilizat pentru a insera imagini în HTML sau CSS fără a fi nevoie să se facă legătura cu fișiere externe.

Să avem o imagine într-o variabilă $img = Image::fromFile('obrazek.gif'), atunci

<img src={$img|dataStream}>

Se imprimă de exemplu:

<img src="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAUA
AAAFCAYAAACNbyblAAAAHElEQVQI12P4//8/w38GIAXDIBKE0DHxgljNBAAO
9TXL0Y4OHwAAAABJRU5ErkJggg==">

Necesită extensia PHP fileinfo.

date (string $format)

Formatează data și ora în conformitate cu masca utilizată de funcția PHP date. Filtrul acceptă data în format UNIX timestamp, ca șir de caractere sau ca obiect DateTimeInterface.

{$today|date:'j. n. Y'}

A se vedea și localDate.

escapeUrl

Scapă o variabilă pentru a fi utilizată ca parametru în URL.

<a href="http://example.com/{$name|escapeUrl}">{$name}</a>

A se vedea, de asemenea, query.

explode (string $separator='')

Împarte un șir de caractere după delimitatorul dat și returnează un tablou de șiruri de caractere. Alias pentru split.

{='one,two,three'|explode:','}    {* returns ['one', 'two', 'three'] *}

Dacă delimitatorul este un șir de caractere gol (valoare implicită), datele de intrare vor fi împărțite în caractere individuale:

{='123'|explode}                  {* returnează ['1', '2', '3'] *}

Puteți utiliza și aliasul split:

{='1,2,3'|split:','}              {* returnează ['1', '2', '3'] *}

A se vedea și implode.

first

Returnează primul element al unui array sau caracterul unui șir de caractere:

{=[1, 2, 3, 4]|first}    {* ieșiri 1 *}
{='abcd'|first}          {* iese "a" *}

A se vedea, de asemenea, last, random.

floor (int $precision=0)

Rotunjește un număr până la o precizie dată.

{=3.5|floor}        {* ieșiri 3 *}
{=135.79|floor:1}   {* ieșiri 135.7 *}
{=135.79|floor:3}   {* ieșiri 135.79 *}

A se vedea și plafon, rotunjire.

firstUpper

Convertește prima literă a unei valori în majusculă. Necesită extensia PHP mbstring.

{='the latte'|firstUpper}  {* outputs 'The latte' *}

A se vedea, de asemenea, capitalize, lower, upper.

group (string|int|\Closure $by)array

Filtrul grupează datele în funcție de diferite criterii.

În acest exemplu, rândurile din tabel sunt grupate în funcție de coloana categoryId. Rezultatul este un tablou de tablouri în care cheia este valoarea din coloana categoryId. Citiți instrucțiunile detaliate.

{foreach ($items|group: categoryId) as $categoryId => $categoryItems}
    <ul>
        {foreach $categoryItems as $item}
            <li>{$item->name}</li>
        {/foreach}
    </ul>
{/foreach}

A se vedea, de asemenea, batch, funcția group și eticheta iterateWhile.

implode (string $glue='')

Returnează un șir de caractere care este concatenarea șirurilor din matrice. Alias pentru join.

{=[1, 2, 3]|implode}      {* iese "123" *}
{=[1, 2, 3]|implode:'|'}  {* iese '1|2|3' *}

Puteți utiliza și un alias join:

{=[1, 2, 3]|join}         {* acest "123" *}

indent (int $level=1, string $char="\t")

Indentează un text de la stânga cu un anumit număr de tabulauri sau alte caractere pe care îl specificăm în al doilea argument opțional. Liniile goale nu sunt indentate.

<div>
{block |indent}
<p>Hello</p>
{/block}
</div>

Imprimă:

<div>
	<p>Hello</p>
</div>

last

Returnează ultimul element al unui array sau caracterul unui șir de caractere:

{=[1, 2, 3, 4]|last}    {* ieșiri 4 *}
{='abcd'|last}          {* ieșiri 'd' *}

A se vedea, de asemenea, first, random.

length

Returnează lungimea unui șir de caractere sau a unei matrice.

  • pentru șiruri de caractere, va returna lungimea în caractere UTF-8
  • pentru array-uri, va returna numărul de elemente.
  • pentru obiectele care implementează interfața Countable, se va utiliza valoarea returnată de count().
  • pentru obiectele care implementează interfața IteratorAggregate, se va utiliza valoarea returnată de iterator_count().
{if ($users|length) > 10}
	...
{/if}

localDate (?string $format=null, ?string $date=null, ?string $time=null)

Formatează data și ora în funcție de locale, asigurând afișarea consecventă și localizată a datelor de timp în diferite limbi și regiuni. Filtrul acceptă data ca timestamp UNIX, șir sau obiect DateTimeInterface.

{$date|localDate}                  {* 15. dubna 2024 *}
{$date|format: yM}                 {* 4/2024 *}
{$date|localDate: date: medium}    {* 15. 4. 2024 *}

Dacă utilizați filtrul fără niciun parametru, acesta va afișa data în format lung, după cum se explică în continuare.

a) Utilizarea formatului

Parametrul format descrie componentele de timp care ar trebui afișate. Acesta utilizează coduri de litere, unde numărul de repetiții afectează lățimea ieșirii:

An y / yy / yyyy 2024 / 24 / 2024
Luna M / MM / MMMMMMM 8 / 08 / aug.august
Zi d / dd / EEEEE 1 / 01 / dum.duminică
Ora j / H / h preferat / 24 de ore / 12 ore
Minute m / mm 5 / 05 (2 cifre atunci când sunt combinate cu secundele)
Second s / ss 8 / 08 (2 cifre atunci când sunt combinate cu minutele)

Ordinea codurilor în format nu contează, deoarece ordinea componentelor va fi afișată în conformitate cu convențiile locale. Prin urmare, formatul este independent de locale. De exemplu, formatul yyyyMMMMd în localul en_US afișează April 15, 2024, în timp ce în localul cs_CZ afișează 15. dubna 2024:

locale: ro-RO en_US
format: 'dMy' 10.08.2024 8/10/2024
format: 'yM' 08.2024 8/2024
format: 'yyyyMMMM' august 2024 August 2024
format: 'MMMM' august August
format: 'jm' 17:54 5:54 PM
format: 'Hm' 17:54 17:54
format: 'hm' 5:54 p.m. 5:54 PM

b) Utilizarea stilurilor prestabilite

Parametrii date și time determină nivelul de detaliu pentru afișarea datei și orei. Puteți alege din mai multe niveluri: full, long, medium, short. Puteți afișa doar data, doar ora sau ambele:

locale: ro-RO en_US
date: short 23.01.1978 1/23/78
date: medium 23 ian. 1978 Jan 23, 1978
date: long 23 ianuarie 1978 January 23, 1978
date: full luni, 23 ianuarie 1978 Monday, January 23, 1978
time: short 08:30 8:30 AM
time: medium 08:30:59 8:30:59 AM
time: long 08:30:59 CET 8:30:59 AM GMT+1
date: short, time: short 23.01.1978, 08:30 1/23/78, 8:30 AM
date: medium, time: short 23 ian. 1978, 08:30 Jan 23, 1978, 8:30 AM
date: long, time: short 23 ianuarie 1978 la 08:30 January 23, 1978 at 8:30 AM

Pentru dată, puteți utiliza, de asemenea, prefixul relative- (de exemplu, relative-short), care pentru datele apropiate de prezent va afișa yesterday, today sau tomorrow; în caz contrar, se va afișa în mod standard.

{$date|localDate: date: relative-short}    {* yesterday *}

A se vedea și data.

lower

Convertește o valoare în minuscule. Necesită extensia PHP mbstring.

{='LATTE'|lower}   {* acest "latte" *}

A se vedea, de asemenea, capitalize, firstUpper, upper.

nocheck

Împiedică dezinfectarea automată a URL-urilor. Latte verifică automat dacă variabila conține un URL web (adică protocolul HTTP/HTTPS) și împiedică scrierea de link-uri care pot reprezenta un risc de securitate.

Dacă link-ul utilizează o schemă diferită, cum ar fi javascript: sau data:, și sunteți sigur de conținutul acestuia, puteți dezactiva verificarea prin intermediul |nocheck.

{var $link = 'javascript:window.close()'}

<a href={$link}>checked</a>
<a href={$link|nocheck}>unchecked</a>

Tipărituri:

<a href="">checked</a>
<a href="javascript:window.close()">unchecked</a>

A se vedea, de asemenea, checkUrl.

noescape

Dezactive scăparea automată.

{var $trustedHtmlString = '<b>hello</b>'}
Escaped: {$trustedHtmlString}
Unescaped: {$trustedHtmlString|noescape}

Imprimă:

Escaped: &lt;b&gt;hello&lt;/b&gt;
Unescaped: <b>hello</b>

Folosirea abuzivă a filtrului noescape poate duce la o vulnerabilitate XSS! Nu îl utilizați niciodată decât dacă sunteți absolut sigur de ceea ce faceți și dacă șirul pe care îl imprimați provine dintr-o sursă de încredere.

number (int $decimals=0, string $decPoint='.', string $thousandsSep=',')

Formatează un număr la un număr specificat de zecimale. Dacă este setată localitatea, se utilizează separatoarele de zecimale și de mii corespunzătoare.

{1234.20 |number}              1,234
{1234.20 |number:1}            1,234.2
{1234.20 |number:2}            1,234.20
{1234.20 |number:2, ',', ' '}  1 234,20

number (string $format)

Parametrul format vă permite să definiți aspectul numerelor exact în funcție de nevoile dumneavoastră. Acesta necesită o localitate stabilită. Formatul constă din mai multe caractere speciale, a căror descriere completă poate fi găsită în documentația DecimalFormat:

  • <c id=6/> cifră obligatorie, afișată întotdeauna chiar dacă este zero
  • # cifră opțională, afișată numai dacă numărul are o cifră în acel loc
  • @ cifră semnificativă, ajută la afișarea numărului cu un anumit număr de cifre semnificative
  • . marchează locul unde ar trebui să fie separatorul zecimal (virgulă sau punct, în funcție de localitate)
  • , utilizat pentru a separa grupuri de cifre, de obicei mii
  • % înmulțește numărul cu 100 și adaugă semnul procentului

Să ne uităm la câteva exemple. În primul exemplu, două zecimale sunt obligatorii; în al doilea, ele sunt opționale. Al treilea exemplu prezintă o umplere cu zerouri pe ambele părți, iar al patrulea afișează doar cifrele existente:

{1234.5|number: '#,##0.00'}     {* 1,234.50 *}
{1234.5|number: '#,##0.##'}     {* 1,234.5 *}
{1.23  |number: '000.000'}      {* 001.230 *}
{1.2   |number: '##.##'}        {* 1.2 *}

Cifrele semnificative determină câte cifre, indiferent de punctul zecimal, ar trebui afișate, rotunjind numărul dacă este necesar:

{1234|number: '@@'}             {* 1200 *}
{1234|number: '@@@'}            {* 1230 *}
{1234|number: '@@@#'}           {* 1234 *}
{1.2345|number: '@@@'}          {* 1.23 *}
{0.00123|number: '@@'}          {* 0.0012 *}

O modalitate ușoară de a afișa un număr ca procent. Numărul este înmulțit cu 100 și se adaugă semnul %:

{0.1234|number: '#.##%'}        {* 12.34% *}

Putem defini un format diferit pentru numerele pozitive și negative, separate de un caracter ;. În acest fel, de exemplu, numerele pozitive pot fi afișate cu un semn +:

{42|number: '#.##;(#.##)'}      {* 42 *}
{-42|number: '#.##;(#.##)'}     {* (42) *}
{42|number: '+#.##;-#.##'}      {* +42 *}
{-42|number: '+#.##;-#.##'}     {* -42 *}

Rețineți că aspectul real al numerelor poate varia în funcție de setările locale. De exemplu, în unele țări, se utilizează o virgulă în loc de un punct ca separator zecimal. Acest filtru ține cont automat de acest lucru, deci nu trebuie să vă faceți griji.

padLeft (int $length, string $pad=' ')

Pads un șir de caractere la o anumită lungime cu un alt șir de caractere din stânga.

{='hello'|padLeft: 10, '123'}  {* ieșiri '12312hello' *}

padRight (int $length, string $pad=' ')

Adaugă un șir de caractere la o anumită lungime cu un alt șir din dreapta.

{='hello'|padRight: 10, '123'}  {* ieșiri 'hello12312' *}

query

Generează dinamic un șir de interogare în URL:

<a href="http://example.com/?{[name: 'John Doe', age: 43]|query}">click</a>
<a href="http://example.com/?search={$search|query}">search</a>

Imprimă:

<a href="http://example.com/?name=John+Doe&amp;age=43">click</a>
<a href="http://example.com/?search=Foo+Bar">search</a>

Cheile cu o valoare de null sunt omise.

A se vedea, de asemenea, escapeUrl.

random

Returnează un element aleatoriu din matrice sau un caracter aleatoriu dintr-un șir de caractere:

{=[1, 2, 3, 4]|random}    {* exemplu de ieșire: 3 *}
{='abcd'|random}          {* exemplu de ieșire: 'b' *}

A se vedea, de asemenea, first, last.

repeat (int $count)

Repetă șirul de x ori.

{='hello'|repeat: 3}  {* outputs 'hellohellohello' *}

replace (string|array $search, string $replace='')

Înlocuiește toate aparițiile șirului de căutare cu șirul de înlocuire.

{='hello world'|replace: 'world', 'friend'}  {* iese 'hello friend' *}

Se pot face mai multe înlocuiri deodată:

{='hello world'|replace: [h => l, l => h]}  {* outputs 'lehho worhd' *}

replaceRE (string $pattern, string $replace='')

Înlocuiește toate ocurențele în funcție de expresia regulată.

{='hello world'|replaceRE: '/l.*/', 'l'}  {* outputs 'hel' *}

reverse

Inversează șirul sau matricea dată.

{var $s = 'Nette'}
{$s|reverse}    {* iese "etteN" *}
{var $a = ['N', 'e', 't', 't', 'e']}
{$a|reverse}    {* returnează ['e', 't', 't', 'e', 'N'] *}

round (int $precision=0)

Rotunjește un număr la o precizie dată.

{=3.4|round}        {* ieșiri 3 *}
{=3.5|round}        {* ieșiri 4 *}
{=135.79|round:1}   {* ieșiri 135.8 *}
{=135.79|round:3}   {* ieșiri 135.79 *}

A se vedea, de asemenea, plafon, podea.

slice (int $start, ?int $length=null, bool $preserveKeys=false)

Extrage o porțiune dintr-un tablou sau un șir de caractere.

{='hello'|slice: 1, 2}           {* ieșiri 'el' *}
{=['a', 'b', 'c']|slice: 1, 2}   {* ieșiri ['b', 'c'] *}

Filtrul slice funcționează ca funcția PHP array_slice pentru array-uri și mb_substr pentru șiruri de caractere, cu o revenire la iconv_substr în modul UTF-8.

În cazul în care startul nu este negativ, secvența va începe de la acel start în variabilă. Dacă start este negativ, secvența va începe la acea distanță de la sfârșitul variabilei.

În cazul în care lungimea este dată și este pozitivă, atunci secvența va avea până la numărul de elemente din ea. În cazul în care variabila este mai scurtă decât lungimea, atunci vor fi prezente numai elementele disponibile ale variabilei. În cazul în care lungimea este dată și este negativă, secvența se va opri la atâtea elemente de la sfârșitul variabilei. În cazul în care este omisă, secvența va conține toate elementele de la offset până la sfârșitul variabilei.

Filter reordonează și resetează implicit cheile tabloului de numere întregi. Acest comportament poate fi modificat prin setarea preserveKeys la true. Cheile șirurilor de caractere sunt întotdeauna păstrate, indiferent de acest parametru.

sort (?Closure $comparison, string|int|\Closure|null $by=null, string|int|\Closure|bool $byKey=false)

Filtrul sortează elementele unui array sau iterator păstrând cheile lor asociative. Atunci când este setată o localitate, sortarea urmează regulile acesteia, cu excepția cazului în care este specificată o funcție de comparație personalizată.

{foreach ($names|sort) as $name}
	...
{/foreach}

Array sortat în ordine inversă.

{foreach ($names|sort|reverse) as $name}
	...
{/foreach}

Puteți specifica o funcție de comparație personalizată pentru sortare (exemplul arată cum se inversează sortarea de la cel mai mare la cel mai mic):

{var $reverted = ($names|sort: fn($a, $b) => $b <=> $a)}

Filtrul |sort vă permite, de asemenea, să sortați elementele după cheie:

{foreach ($names|sort: byKey: true) as $name}
	...
{/foreach}

Dacă aveți nevoie să sortați un tabel după o anumită coloană, puteți utiliza parametrul by. Valoarea 'name' din exemplu specifică faptul că sortarea se va face după $row->name sau $row['name'], în funcție de faptul că $row este o matrice sau un obiect:

{foreach ($items|sort: by: 'name') as $item}
	{$item->name}
{/foreach}

De asemenea, puteți defini o funcție de apelare care să determine valoarea după care se va sorta:

{foreach ($items|sort: by: fn($items) => $items->category->name) as $item}
	{$item->name}
{/foreach}

Parametrul byKey poate fi utilizat în același mod.

spaceless

Îndepărtează spațiile albe inutile din rezultat. De asemenea, puteți utiliza aliasul strip.

{block |spaceless}
	<ul>
		<li>Hello</li>
	</ul>
{/block}

Imprimă:

<ul> <li>Hello</li> </ul>

stripHtml

Convertește HTML în text simplu. Adică, elimină etichetele HTML și convertește entitățile HTML în text.

{='<p>one &lt; two</p>'|stripHtml}  {* outputs 'one < two' *}

Textul simplu rezultat poate conține, în mod natural, caractere care reprezintă etichete HTML, de exemplu '&lt;p&gt;'|stripHtml este convertit în <p>. Nu scoateți niciodată textul rezultat cu |noescape, deoarece acest lucru poate duce la o vulnerabilitate de securitate.

substr (int $offset, ?int $length=null)

Extrage o porțiune dintr-un șir de caractere. Acest filtru a fost înlocuit cu un filtru de felie.

{$string|substr: 1, 2}

translate (string $message, …$args)

Traduce expresii în alte limbi. Pentru ca filtrul să fie disponibil, trebuie să configurați translator. De asemenea, puteți utiliza etichetele pentru traducere.

<a href="basket">{='Baskter'|translate}</a>
<span>{$item|translate}</span>

trim (string $charlist=" \t\n\r\0\x0B\u{A0}")

Elimină caracterele de început și de sfârșit, implicit spațiile albe.

{='  I like Latte.  '|trim}    {* outputs 'I like Latte.' *}
{='  I like Latte.'|trim: '.'} {* outputs '  I like Latte' *}

truncate (int $length, string $append='…')

Scurtează un șir de caractere până la lungimea maximă dată, dar încearcă să păstreze cuvintele întregi. În cazul în care șirul este trunchiat, adaugă elipse la sfârșit (acest lucru poate fi modificat prin intermediul celui de-al doilea parametru).

{var $title = 'Hello, how are you?'}
{$title|truncate:5}  {* Hell…                *}
{$title|truncate:17} {* Hello, how are…      *}
{$title|truncate:30} {* Hello, how are you?  *}

upper

Convertește o valoare în majuscule. Necesită extensia PHP mbstring.

{='latte'|upper}  {* outputs 'LATTE' *}

A se vedea, de asemenea, capitalize, firstUpper, lower.

webalize

Convertește în ASCII.

Convertește spațiile în cratimă. Îndepărtează caracterele care nu sunt alfanumerice, sublinieri sau cratime. Convertește în minuscule. Îndepărtează, de asemenea, spațiile albe de început și de sfârșit.

{var $s = 'Our 10. product'}
{$s|webalize}    {* outputs 'our-10-product' *}

Necesită pachetul nette/utils.