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 |#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]
| `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]
| `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>
```


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ă o dimensiune în bytes în formă lizibilă pentru oameni.

```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]
-----------------------------
Returnează o dată în formatul dat folosind opțiunile funcțiilor PHP [php:strftime] sau [php:date]. Filtrul obține o dată sub forma unui timestamp UNIX, a unui șir de caractere sau a unui obiect de tip `DateTime`.

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


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].


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}
```


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 cu un anumit număr de zecimale. De asemenea, puteți specifica un caracter al punctului zecimal și al separatorului de mii.

```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
```


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  .[filter]
---------------
Filtru care sortează o matrice și menține asocierea indicilor.

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

Array sortat în ordine inversă.

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

Puteți trece propria funcție de comparație ca parametru:

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


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:].