Filtri per latte
****************

.[perex]
I filtri sono funzioni che modificano o formattano i dati nella forma desiderata. Questo è un riassunto dei filtri incorporati disponibili.

.[table-latte-filters]
|## Trasformazione di stringhe/array
| `batch` | [elenca i dati lineari in una tabella |#batch]
| `breakLines` | [Inserisce le interruzioni di riga HTML prima di tutte le newline |#breakLines]
| `bytes` | [Formatta la dimensione in byte |#bytes]
| `clamp` | [blocca il valore all'intervallo |#clamp]
| `dataStream` | [Conversione del protocollo URI dei dati |#datastream]
| `date` | [formatta la data e l'ora |#date]
| `explode` | [divide una stringa in base al delimitatore dato |#explode]
| `first` | [restituisce il primo elemento di un array o un carattere di una stringa |#first]
| `group` | [raggruppa i dati secondo vari criteri |#group]
| `implode` | [unisce un array a una stringa |#implode]
| `indent` | [indenta il testo da sinistra con un certo numero di tabulazioni |#indent]
| `join` | [unisce un array a una stringa |#implode]
| `last` | [restituisce l'ultimo elemento di un array o un carattere di una stringa |#last]
| `length` | [restituisce la lunghezza di una stringa o di un array |#length]
| `localDate` | [formatta la data e l'ora in base al locale |#localDate]
| `number` | [formatta un numero |#number]
| `padLeft` | [completa la stringa alla lunghezza data da sinistra |#padLeft]
| `padRight` | [completa la stringa alla lunghezza data da destra |#padRight]
| `random` | [restituisce un elemento casuale di un array o un carattere di una stringa |#random]
| `repeat` | [ripete la stringa |#repeat]
| `replace` | [sostituisce tutte le occorrenze della stringa cercata con la sostituzione |#replace]
| `replaceRE` | [sostituisce tutte le occorrenze secondo l'espressione regolare |#replaceRE]
| `reverse` | [inverte una stringa o un array UTF-8 |#reverse]
| `slice` | [estrae una fetta di un array o di una stringa |#slice]
| `sort` | [ordina un array |#sort]
| `spaceless` | [rimuove gli spazi bianchi |#spaceless], simile al tag [spaceless |tags]
| `split` | [divide una stringa in base al delimitatore dato |#explode]
| `strip` | [rimuove gli spazi bianchi |#spaceless]
| `stripHtml` | [rimuove i tag HTML e converte le entità HTML in testo |#stripHtml]
| `substr` | [restituisce una parte della stringa |#substr]
| `trim` | [elimina gli spazi bianchi dalla stringa |#trim]
| `translate` | [traduzione in altre lingue |#translate]
| `truncate` | [accorcia la lunghezza preservando le parole intere |#truncate]
| `webalize` | [adatta la stringa UTF-8 alla forma utilizzata nell'URL |#webalize]

.[table-latte-filters]
|## Incasellamento delle lettere
| `capitalize` | [minuscolo, la prima lettera di ogni parola maiuscola |#capitalize]
| `firstUpper` | [rende la prima lettera maiuscola |#firstUpper]
| `lower` | [rende una stringa minuscola |#lower]
| `upper` | [rende una stringa maiuscola |#upper]

.[table-latte-filters]
|## Arrotondamento dei numeri
| `ceil` | [arrotonda un numero fino a una determinata precisione |#ceil]
| `floor` | [arrotonda un numero per difetto a una determinata precisione|#floor]
| `round` | [arrotonda un numero a una determinata precisione|#round]

.[table-latte-filters]
|## Escaping
| `escapeUrl` | [esegue l'escape di un parametro nell'URL |#escapeUrl]
| `noescape` | [stampa una variabile senza escape |#noescape]
| `query` | [genera una stringa di query nell'URL |#query]

Esistono anche filtri di escape per HTML (`escapeHtml` e `escapeHtmlComment`), XML (`escapeXml`), JavaScript (`escapeJs`), CSS (`escapeCss`) e iCalendar (`escapeICal`), che Latte utilizza autonomamente grazie all'[escape context-aware |safety-first#Context-aware escaping] e che non è necessario scrivere.

.[table-latte-filters]
|## Sicurezza
| `checkUrl` | [sanifica le stringhe da usare nell'attributo href |#checkUrl]
| `nocheck` | [impedisce la sanitizzazione automatica degli URL |#nocheck]

I [controlli |safety-first#link checking] degli attributi `src` e `href` vengono eseguiti [automaticamente |safety-first#link checking], quindi non è necessario usare il filtro `checkUrl`.


.[note]
Tutti i filtri incorporati funzionano con stringhe codificate UTF-8.


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

Latte consente di chiamare i filtri usando la notazione del segno di pipe (è ammesso lo spazio precedente):

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

I filtri possono essere concatenati, in tal caso si applicano in ordine da sinistra a destra:

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

I parametri vengono inseriti dopo il nome del filtro, separati da due punti o da una virgola:

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

I filtri possono essere applicati alle espressioni:

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

[I filtri personalizzati |extending-latte#filters] possono essere registrati in questo modo:

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

Lo utilizziamo in un modello come questo:

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


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


batch(int $length, mixed $item): array .[filter]
------------------------------------------------
Filtro che semplifica l'elencazione di dati lineari sotto forma di tabella. Restituisce un array di array con il numero di elementi indicato. Se si fornisce un secondo parametro, questo viene utilizzato per riempire gli elementi mancanti nell'ultima riga.

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

Stampa:

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

Vedere anche [gruppo |#group] e tag [iterateWhile |tags#iterateWhile].


breakLines .[filter]
--------------------
Inserisce le interruzioni di riga HTML prima di tutti i newline.

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


bytes(int $precision=2) .[filter]
---------------------------------
Formatta la dimensione in byte in una forma leggibile. Se il [locale |develop#locale] è impostato, vengono utilizzati i corrispondenti separatori decimali e delle migliaia.

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


ceil(int $precision=0) .[filter]
--------------------------------
Arrotonda un numero fino a una determinata precisione.

```latte
{=3.4|ceil}         {* uscite 4      *}
{=135.22|ceil:1}    {* uscite 135.3  *}
{=135.22|ceil:3}    {* uscite 135.22 *}
```

Vedere anche [piano |#floor], [rotondo |#round].


capitalize .[filter]
--------------------
Restituisce una versione con titolo del valore. Le parole inizieranno con lettere maiuscole, tutti i caratteri rimanenti saranno minuscoli. Richiede l'estensione PHP `mbstring`.

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

Vedere anche [firstUpper |#firstUpper], [lower |#lower], [upper |#upper].


checkUrl .[filter]
------------------
Impone la sanitizzazione degli URL. Controlla se la variabile contiene un URL web (cioè un protocollo HTTP/HTTPS) e impedisce la scrittura di link che potrebbero rappresentare un rischio per la sicurezza.

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

Stampa:

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

Vedere anche [nocheck |#nocheck].


clamp(int|float $min, int|float $max) .[filter]
-----------------------------------------------
Restituisce un valore limitato all'intervallo inclusivo di min e max.

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

Esiste anche come [funzione |functions#clamp].


dataStream(string $mimetype=detect) .[filter]
---------------------------------------------
Converte il contenuto in uno schema URI di dati. Può essere usato per inserire immagini in HTML o CSS senza la necessità di collegare file esterni.

Poniamo di avere un'immagine in una variabile `$img = Image::fromFile('obrazek.gif')`, allora

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

Stampa ad esempio:

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

.[caution]
Richiede l'estensione PHP `fileinfo`.


date(string $format) .[filter]
------------------------------
Formatta la data e l'ora secondo la maschera utilizzata dalla funzione PHP [php:date]. Il filtro accetta la data in formato UNIX timestamp, come stringa o come oggetto `DateTimeInterface`.

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

Vedere anche [localDate |#localDate].


escapeUrl .[filter]
-------------------
Permette di separare una variabile da usare come parametro nell'URL.

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

Vedere anche [query |#query].


explode(string $separator='') .[filter]
---------------------------------------
Divide una stringa in base al delimitatore dato e restituisce un array di stringhe. Alias di `split`.

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

Se il delimitatore è una stringa vuota (valore predefinito), l'input verrà diviso in singoli caratteri:

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

È possibile utilizzare anche l'alias `split`:

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

Vedere anche [implode |#implode].


first .[filter]
---------------
Restituisce il primo elemento di una matrice o un carattere di una stringa:

```latte
{=[1, 2, 3, 4]|first}    {* uscite 1 *}
{='abcd'|first}          {* uscite 'a' *}
```

Vedere anche [last |#last], [random |#random].


floor(int $precision=0) .[filter]
---------------------------------
Arrotonda un numero fino a una determinata precisione.

```latte
{=3.5|floor}        {* uscite 3      *}
{=135.79|floor:1}   {* uscite 135.7  *}
{=135.79|floor:3}   {* uscite 135.79 *}
```

Vedere anche [ceil |#ceil], [round |#round].


firstUpper .[filter]
--------------------
Converte la prima lettera di un valore in maiuscolo. Richiede l'estensione PHP `mbstring`.

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

Vedere anche [capitalize |#capitalize], [lower |#lower], [upper |#upper].


group(string|int|\Closure $by): array .[filter]{data-version:3.0.16}
--------------------------------------------------------------------
Il filtro raggruppa i dati in base a diversi criteri.

In questo esempio, le righe della tabella sono raggruppate in base alla colonna `categoryId`. L'output è un array di array in cui la chiave è il valore della colonna `categoryId`. Leggete le [istruzioni dettagliate |cookbook/grouping].

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

Vedere anche [batch |#batch], la funzione [group |functions#group] e il tag [iterateWhile |tags#iterateWhile].


implode(string $glue='') .[filter]
----------------------------------
Restituisce una stringa che è la concatenazione delle stringhe dell'array. Alias di `join`.

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

È possibile utilizzare anche l'alias `join`:

```latte
{=[1, 2, 3]|join}         {* uscite '123' *}
```


indent(int $level=1, string $char="\t") .[filter]
-------------------------------------------------
Rientra un testo da sinistra di un determinato numero di tabulazioni o di altri caratteri, specificati nel secondo argomento opzionale. Le righe vuote non sono rientrate.

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

Stampa:

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


last .[filter]
--------------
Restituisce l'ultimo elemento della matrice o il carattere della stringa:

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

Vedere anche [first |#first], [random |#random].


length .[filter]
----------------
Restituisce la lunghezza di una stringa o di un array.

- per le stringhe, restituisce la lunghezza in caratteri UTF-8
- per gli array, restituisce il conteggio degli elementi
- per gli oggetti che implementano l'interfaccia Countable, utilizzerà il valore di ritorno del metodo count()
- per gli oggetti che implementano l'interfaccia IteratorAggregate, utilizzerà il valore di ritorno dell'iterator_count()


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


localDate(?string $format=null, ?string $date=null, ?string $time=null) .[filter]
---------------------------------------------------------------------------------
Formatta la data e l'ora in base al [locale |develop#locale], garantendo una visualizzazione coerente e localizzata dei dati temporali in diverse lingue e regioni. Il filtro accetta la data come timestamp UNIX, stringa o oggetto `DateTimeInterface`.

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

Se si utilizza il filtro senza alcun parametro, verrà emessa la data nel livello di formato lungo, come spiegato più avanti.

**a) Utilizzo del formato**

Il parametro `format` descrive quali componenti dell'ora devono essere visualizzati. Utilizza codici di lettere, il cui numero di ripetizioni influisce sull'ampiezza dell'output:

| Anno | `y` / `yy` / `yyyy` | `2024` / `24` / `2024`
| Mese | `M` / `MM` / `MMM` / `MMMM` | `8` / `08` / `ago` / `agosto`
| Giorno | `d` / `dd` / `E` / `EEEE` | `1` / `01` / `dom` / `domenica`
| Ora | `j` / `H` / `h` | preferito / 24 ore / 12 ore
| Minuto | `m` / `mm` | `5` / `05` <small>(2 cifre se combinato con i secondi)</small>
| Secondo | `s` / `ss` | `8` / `08` <small>(2 cifre se combinato con i minuti)</small>

L'ordine dei codici nel formato non ha importanza, poiché l'ordine dei componenti sarà visualizzato in base alle convenzioni del locale. Pertanto, il formato è indipendente dal locale. Ad esempio, il formato `yyyyMMMMd` nel locale `en_US` produce `April 15, 2024`, mentre nel locale `cs_CZ` produce `15. dubna 2024`:

| locale:  | it-IT | en_US
|---
| `format: 'dMy'` | 10/8/2024 | 8/10/2024
| `format: 'yM'` | 8/2024 | 8/2024
| `format: 'yyyyMMMM'` | agosto 2024 | August 2024
| `format: 'MMMM'` | agosto | August
| `format: 'jm'` | 17:54 | 5:54 PM
| `format: 'Hm'` | 17:54 | 17:54
| `format: 'hm'` | 5:54 PM | 5:54 PM


**b) Utilizzo di stili preimpostati**

I parametri `date` e `time` determinano il livello di dettaglio della visualizzazione di data e ora. È possibile scegliere tra diversi livelli: `full`, `long`, `medium`, `short`. È possibile visualizzare solo la data, solo l'ora o entrambe:

| locale:  | it-IT | en_US
|---
| `date: short` | 23/01/78 | 1/23/78
| `date: medium` | 23 gen 1978 | Jan 23, 1978
| `date: long` | 23 gennaio 1978 | January 23, 1978
| `date: full` | lunedì 23 gennaio 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/78, 08:30 | 1/23/78, 8:30 AM
| `date: medium, time: short` | 23 gen 1978, 08:30 | Jan 23, 1978, 8:30 AM
| `date: long, time: short` | 23 gennaio 1978 alle ore 08:30 | January 23, 1978 at 8:30 AM

Per la data si può anche usare il prefisso `relative-` (ad esempio, `relative-short`), che per le date vicine al presente visualizzerà `yesterday`, `today`, o `tomorrow`; altrimenti, verrà visualizzato nel modo standard.

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

Vedere anche [data |#date].


lower .[filter]
---------------
Converte un valore in minuscolo. Richiede l'estensione PHP `mbstring`.

```latte
{='LATTE'|lower}   {* uscite 'latte' *}
```

Vedere anche [capitalize |#capitalize], [firstUpper |#firstUpper], [upper |#upper].


nocheck .[filter]
-----------------
Impedisce la sanificazione automatica degli URL. Latte [controlla automaticamente |safety-first#Link checking] se la variabile contiene un URL web (cioè un protocollo HTTP/HTTPS) e impedisce la scrittura di link che potrebbero rappresentare un rischio per la sicurezza.

Se il link utilizza uno schema diverso, come `javascript:` o `data:`, e si è sicuri del suo contenuto, si può disabilitare il controllo tramite `|nocheck`.

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

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

Stampe:

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

Vedere anche [checkUrl |#checkUrl].


noescape .[filter]
------------------
Disabilita l'escape automatico.

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

Stampa:

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

.[warning]
L'uso improprio del filtro `noescape` può portare a una vulnerabilità XSS! Non utilizzatelo mai a meno che non siate **assolutamente sicuri** di quello che state facendo e che la stringa che state stampando provenga da una fonte affidabile.


number(int $decimals=0, string $decPoint='.', string $thousandsSep=',') .[filter]
---------------------------------------------------------------------------------
Formatta un numero con un numero specificato di cifre decimali. Se il [locale |develop#locale] è impostato, vengono utilizzati i corrispondenti separatori decimali e delle migliaia.

```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]
--------------------------------
Il parametro `format` consente di definire l'aspetto dei numeri esattamente secondo le proprie esigenze. Richiede un [locale |develop#locale] impostato. Il formato consiste in diversi caratteri speciali, la cui descrizione completa si trova nella documentazione "DecimalFormat":https://unicode.org/reports/tr35/tr35-numbers.html#Number_Format_Patterns:

- <c id=6/> cifra obbligatoria, sempre visualizzata anche se è zero
- `#` cifra opzionale, visualizzata solo se il numero ha una cifra in quel posto
- `@` cifra significativa, aiuta a visualizzare il numero con un certo numero di cifre significative
- `.` segna la posizione del separatore decimale (virgola o punto, a seconda del locale)
- `,` si usa per separare gruppi di cifre, di solito le migliaia
- `%` moltiplica il numero per 100 e aggiunge il segno di percentuale

Vediamo alcuni esempi. Nel primo esempio, le due cifre decimali sono obbligatorie; nel secondo, sono facoltative. Il terzo esempio mostra un'imbottitura con zeri su entrambi i lati, mentre il quarto visualizza solo le cifre esistenti:

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

Le cifre significative determinano il numero di cifre da visualizzare, indipendentemente dal punto decimale, arrotondando il numero se necessario:

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

Un modo semplice per visualizzare un numero come percentuale. Il numero viene moltiplicato per 100 e viene aggiunto il segno `%`:

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

Possiamo definire un formato diverso per i numeri positivi e negativi, separati da un carattere `;`. In questo modo, ad esempio, i numeri positivi possono essere visualizzati con il segno `+`:

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

Ricordate che l'aspetto effettivo dei numeri può variare a seconda delle impostazioni locali. Ad esempio, in alcuni Paesi si usa una virgola al posto del punto come separatore decimale. Questo filtro ne tiene conto automaticamente, quindi non è necessario preoccuparsene.


padLeft(int $length, string $pad=' ') .[filter]
-----------------------------------------------
Imbottisce una stringa di una certa lunghezza con un'altra stringa a partire da sinistra.

```latte
{='hello'|padLeft: 10, '123'}  {* uscite '12312hello' *}
```


padRight(int $length, string $pad=' ') .[filter]
------------------------------------------------
Imbottisce una stringa di una certa lunghezza con un'altra stringa proveniente da destra.

```latte
{='hello'|padRight: 10, '123'}  {* uscite 'hello12312' *}
```


query  .[filter]
----------------
Genera dinamicamente una stringa di query nell'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>
```

Stampa:

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

I tasti con valore `null` vengono omessi.

Vedere anche [escapeUrl |#escapeUrl].


random .[filter]
----------------
Restituisce un elemento casuale di una matrice o un carattere di una stringa:

```latte
{=[1, 2, 3, 4]|random}    {* esempio di uscita: 3 *}
{='abcd'|random}          {* esempio di uscita: 'b' *}
```

Vedere anche [primo |#first], [ultimo |#last].


repeat(int $count) .[filter]
----------------------------
Ripete la stringa x volte.

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


replace(string|array $search, string $replace='') .[filter]
-----------------------------------------------------------
Sostituisce tutte le occorrenze della stringa di ricerca con la stringa di sostituzione.

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

È possibile effettuare più sostituzioni contemporaneamente:

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


replaceRE(string $pattern, string $replace='') .[filter]
--------------------------------------------------------
Sostituisce tutte le occorrenze in base all'espressione regolare.

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


reverse .[filter]
-----------------
Inverte la stringa o l'array dato.

```latte
{var $s = 'Nette'}
{$s|reverse}    {* outputs 'etteN' *}
{var $a = ['N', 'e', 't', 't', 'e']}
{$a|reverse}    {* returns ['e', 't', 't', 'e', 'N'] *}
```


round(int $precision=0) .[filter]
---------------------------------
Arrotonda un numero a una determinata precisione.

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

Vedere anche [ceil |#ceil], [floor |#floor].


slice(int $start, ?int $length=null, bool $preserveKeys=false) .[filter]
------------------------------------------------------------------------
Estrae una fetta di un array o di una stringa.

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

Il filtro slice funziona come la funzione PHP `array_slice` per gli array e `mb_substr` per le stringhe, con un fallback a `iconv_substr` in modalità UTF-8.

Se start è non negativo, la sequenza inizierà da quell'inizio nella variabile. Se start è negativo, la sequenza inizierà a quella distanza dalla fine della variabile.

Se la lunghezza è data ed è positiva, la sequenza conterrà fino a quel numero di elementi. Se la variabile è più corta della lunghezza, saranno presenti solo gli elementi disponibili della variabile. Se la lunghezza è data ed è negativa, la sequenza si fermerà a tanti elementi dalla fine della variabile. Se viene omesso, la sequenza conterrà tutti gli elementi dall'offset fino alla fine della variabile.

Per impostazione predefinita, Filter riordina e reimposta le chiavi dell'array di interi. Questo comportamento può essere modificato impostando preserveKeys su true. Le chiavi stringa vengono sempre conservate, indipendentemente da questo parametro.


sort(?Closure $comparison, string|int|\Closure|null $by=null, string|int|\Closure|bool $byKey=false) .[filter]
--------------------------------------------------------------------------------------------------------------
Il filtro ordina gli elementi di un array o di un iteratore preservandone le chiavi associative. Quando viene impostato un [locale |develop#locale], l'ordinamento segue le sue regole, a meno che non venga specificata una funzione di confronto personalizzata.

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

Array ordinato in ordine inverso.

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

È possibile specificare una funzione di confronto personalizzata per l'ordinamento (l'esempio mostra come invertire l'ordinamento dal più grande al più piccolo):

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

Il filtro `|sort` consente anche di ordinare gli elementi per chiave:

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

Se si desidera ordinare una tabella in base a una colonna specifica, è possibile utilizzare il parametro `by`. Il valore `'name'` nell'esempio specifica che l'ordinamento sarà effettuato da `$row->name` o da `$row['name']`a seconda che `$row` sia una matrice o un oggetto:

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

Si può anche definire una funzione di callback che determina il valore da ordinare:

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

Il parametro `byKey` può essere utilizzato allo stesso modo.


spaceless  .[filter]
--------------------
Rimuove gli spazi bianchi non necessari dall'output. Si può anche usare l'alias `strip`.

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

Stampa:

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


stripHtml .[filter]
-------------------
Converte l'HTML in testo normale. Ossia, rimuove i tag HTML e converte le entità HTML in testo.

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

Il testo normale risultante può naturalmente contenere caratteri che rappresentano tag HTML, ad esempio `'&lt;p&gt;'|stripHtml` viene convertito in `<p>`. Non inviare mai il testo risultante con `|noescape`, perché ciò potrebbe causare una vulnerabilità della sicurezza.


substr(int $offset, ?int $length=null) .[filter]
------------------------------------------------
Estrae una fetta di una stringa. Questo filtro è stato sostituito da un filtro [a fetta |#slice].

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


translate(...$args) .[filter]
-----------------------------
Traduce le espressioni in altre lingue. Per rendere disponibile il filtro, è necessario [impostare il traduttore |develop#TranslatorExtension]. Si possono anche usare i [tag per la traduzione |tags#Translation].

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


trim(string $charlist=" \t\n\r\0\x0B\u{A0}") .[filter]
------------------------------------------------------
Spogliare i caratteri iniziali e finali, per impostazione predefinita gli spazi bianchi.

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


truncate(int $length, string $append='…') .[filter]
---------------------------------------------------
Accorcia una stringa alla lunghezza massima indicata, ma cerca di conservare le parole intere. Se la stringa è troncata, aggiunge un'ellissi alla fine (questo può essere cambiato con il secondo parametro).

```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 un valore in maiuscolo. Richiede l'estensione PHP `mbstring`.

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

Vedere anche [capitalize |#capitalize], [firstUpper |#firstUpper], [lower |#lower].


webalize .[filter]
------------------
Converte in ASCII.

Converte gli spazi in trattini. Rimuove i caratteri che non sono alfanumerici, sottolineati o trattini. Converte in minuscolo. Elimina anche gli spazi bianchi iniziali e finali.

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

.[caution]
Richiede il pacchetto [nette/utils |utils:].