Filtri Latte
************

.[perex]
Nei template possiamo utilizzare funzioni che aiutano a modificare o riformattare i dati nella loro forma finale. Li chiamiamo *filtri*.

.[table-latte-filters]
|## Trasformazione
| `batch`      | [stampa dati lineari in una tabella |#batch]
| `breakLines` | [Aggiunge interruzioni di riga HTML prima delle interruzioni di riga |#breakLines]
| `bytes`      | [formatta la dimensione in byte |#bytes]
| `clamp`      | [limita un valore all'interno di un intervallo specificato |#clamp]
| `dataStream` | [conversione per il protocollo Data URI |#dataStream]
| `date`       | [formatta data e ora |#date]
| `explode`    | [divide una stringa in un array in base a un delimitatore |#explode]
| `first`      | [restituisce il primo elemento di un array o carattere di una stringa |#first]
| `group`      | [raggruppa i dati secondo vari criteri |#group]
| `implode`    | [unisce un array in una stringa |#implode]
| `indent`     | [indenta il testo da sinistra di un dato numero di tabulazioni |#indent]
| `join`       | [unisce un array in una stringa |#implode]
| `last`       | [restituisce l'ultimo elemento di un array o carattere di una stringa |#last]
| `length`     | [restituisce la lunghezza di una stringa in caratteri o di un array |#length]
| `localDate`  | [formatta data e ora secondo il locale |#localDate]
| `number`     | [formatta un numero |#number]
| `padLeft`    | [riempie una stringa a sinistra alla lunghezza desiderata |#padLeft]
| `padRight`   | [riempie una stringa a destra alla lunghezza desiderata |#padRight]
| `random`     | [restituisce un elemento casuale di un array o carattere di una stringa |#random]
| `repeat`     | [ripetizione di una stringa |#repeat]
| `replace`    | [sostituisce le occorrenze di una stringa cercata |#replace]
| `replaceRE`  | [sostituisce le occorrenze secondo un'espressione regolare |#replaceRE]
| `reverse`    | [inverte una stringa UTF‑8 o un array |#reverse]
| `slice`      | [estrae una parte 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 un array in base a un delimitatore |#explode]
| `strip`      | [rimuove gli spazi bianchi |#spaceless]
| `stripHtml`  | [rimuove i tag HTML e converte le entità HTML in caratteri |#stripHtml]
| `substr`     | [restituisce una parte di una stringa |#substr]
| `trim`       | [rimuove gli spazi iniziali e finali o altri caratteri |#trim]
| `translate`  | [traduzione in altre lingue |#translate]
| `truncate`   | [accorcia la lunghezza mantenendo le parole |#truncate]
| `webalize`   | [modifica una stringa UTF‑8 nella forma utilizzata negli URL |#webalize]

.[table-latte-filters]
|## Maiuscole/Minuscole
| `capitalize` | [minuscolo, prima lettera delle parole maiuscola |#capitalize]
| `firstUpper` | [converte la prima lettera in maiuscolo |#firstUpper]
| `lower`      | [converte in minuscolo |#lower]
| `upper`      | [converte in maiuscolo |#upper]

.[table-latte-filters]
|## Arrotondamento
| `ceil`       | [arrotonda un numero per eccesso alla precisione specificata |#ceil]
| `floor`      | [arrotonda un numero per difetto alla precisione specificata |#floor]
| `round`      | [arrotonda un numero alla precisione specificata |#round]

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

Inoltre, esistono filtri di escaping per HTML (`escapeHtml` e `escapeHtmlComment`), XML (`escapeXml`), JavaScript (`escapeJs`), CSS (`escapeCss`) e iCalendar (`escapeICal`), che Latte utilizza autonomamente grazie all'[escaping sensibile al contesto |safety-first#Escaping sensibile al contesto] e non è necessario scriverli.

.[table-latte-filters]
|## Sicurezza
| `checkUrl`   | [pulisce un indirizzo URL da input pericolosi |#checkUrl]
| `nocheck`    | [impedisce la pulizia automatica dell'indirizzo URL |#nocheck]

Gli attributi Latte `src` e `href` [vengono controllati automaticamente |safety-first#Controllo dei link], quindi non è quasi mai necessario utilizzare il filtro `checkUrl`.


.[note]
Tutti i filtri predefiniti sono progettati per stringhe con codifica UTF‑8.


Utilizzo
========

I filtri vengono scritti dopo una barra verticale (può esserci uno spazio prima):

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

I filtri (nelle versioni precedenti helper) possono essere concatenati e vengono applicati nell'ordine da sinistra a destra:

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

I parametri vengono specificati dopo il nome del filtro, separati da due punti o virgole:

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

I filtri possono essere applicati anche a un'espressione:

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

[Filtri personalizzati|custom-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));
```

Nel template, viene quindi chiamato così:

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


Filtri
======


batch(int $length, mixed $item): array .[filter]
------------------------------------------------
Filtro che semplifica la visualizzazione di dati lineari sotto forma di tabella. Restituisce un array di array con il numero specificato di elementi. Se si specifica il secondo parametro, verrà utilizzato per completare 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>
```

Vedi anche [#group] e il tag [iterateWhile |tags#iterateWhile].


breakLines .[filter]
--------------------
Aggiunge un tag HTML `<br>` prima di ogni carattere di nuova riga.

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


bytes(int $precision=2) .[filter]
---------------------------------
Formatta la dimensione in byte in un formato leggibile dall'uomo. Se è impostato il [locale |develop#Locale], verranno utilizzati i separatori decimali e delle migliaia corrispondenti.

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


ceil(int $precision=0) .[filter]
--------------------------------
Arrotonda un numero per eccesso alla precisione specificata.

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

Vedi anche [#floor], [#round].


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

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

Vedi anche [#firstUpper], [#lower], [#upper].


checkUrl .[filter]
------------------
Forza la pulizia dell'indirizzo URL. Controlla se la variabile contiene un URL web (cioè protocollo HTTP/HTTPS) e impedisce la visualizzazione di link che potrebbero rappresentare un rischio per la sicurezza.

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

Stampa:

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

Vedi anche [#nocheck].


clamp(int|float $min, int|float $max) .[filter]
-----------------------------------------------
Limita un valore all'interno dell'intervallo inclusivo specificato min e max.

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

Esiste anche come [funzione |functions#clamp].


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

Supponiamo di avere un'immagine nella variabile `$img = Image::fromFile('image.gif')`, quindi

```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 data e ora secondo la maschera utilizzata dalla funzione PHP [php:date]. Il filtro accetta la data nel formato timestamp UNIX, come stringa o oggetto di tipo `DateTimeInterface`.

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

Vedi anche [#localDate].


escapeUrl .[filter]
-------------------
Esegue l'escaping di una variabile per l'uso come parametro in un URL.

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

Vedi anche [#query].


explode(string $separator='') .[filter]
---------------------------------------
Divide una stringa in un array in base a un delimitatore. Alias per `split`.

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

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

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

Puoi anche usare l'alias `split`:

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

Vedi anche [#implode].


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

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

Vedi anche [#last], [#random].


floor(int $precision=0) .[filter]
---------------------------------
Arrotonda un numero per difetto alla precisione specificata.

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

Vedi anche [#ceil], [#round].


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

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

Vedi anche [#capitalize], [#lower], [#upper].


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

In questo esempio, le righe della tabella vengono raggruppate per la colonna `categoryId`. L'output è un array di array, dove la chiave è il valore nella colonna `categoryId`. [Leggi il tutorial dettagliato|cookbook/grouping].

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

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


implode(string $glue='') .[filter]
----------------------------------
Restituisce una stringa che è la concatenazione degli elementi della sequenza. Alias per `join`.

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

Puoi anche usare l'alias `join`:

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


indent(int $level=1, string $char="\t") .[filter]
-------------------------------------------------
Indenta il testo da sinistra di un dato numero di tabulazioni o altri caratteri, che possiamo specificare nel secondo argomento. Le righe vuote non vengono indentate.

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

Stampa:

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


last .[filter]
--------------
Restituisce l'ultimo elemento di un array o carattere di una stringa:

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

Vedi anche [#first], [#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 numero di elementi
- per gli oggetti che implementano l'interfaccia Countable, utilizza il valore restituito dal metodo count()
- per gli oggetti che implementano l'interfaccia IteratorAggregate, utilizza il valore restituito dalla funzione iterator_count()


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


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

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

Se si utilizza il filtro senza parametri, la data verrà visualizzata al livello `long`, vedi oltre.

**a) utilizzo del formato**

Il parametro `format` descrive quali componenti temporali devono essere visualizzati. Utilizza codici letterali per questo, il cui numero di ripetizioni influenza la larghezza 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 in combinazione con i secondi)</small>
| secondo | `s` / `ss` | `8` / `08` <small>(2 cifre in combinazione con i minuti)</small>

L'ordine dei codici nel formato non ha importanza, poiché l'ordine dei componenti viene visualizzato secondo le convenzioni del locale. Il formato è quindi indipendente da esso. Ad esempio, il formato `yyyyMMMMd` nell'ambiente `en_US` stampa `April 15, 2024`, mentre nell'ambiente `it_IT` stampa `15 aprile 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:22 | 5:22 PM
| `format: 'Hm'` | 17:22 | 17:22
| `format: 'hm'` | 5:22 PM | 5:22 PM


**b) utilizzo di stili preimpostati**

I parametri `date` e `time` specificano quanto dettagliatamente devono essere visualizzati data e ora. È possibile scegliere tra diversi livelli: `full`, `long`, `medium`, `short`. È possibile visualizzare solo la data, solo l'ora o entrambi:

| 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 08:30 | January 23, 1978 at 8:30 AM

Per la data, è possibile utilizzare anche il prefisso `relative-` (es. `relative-short`), che per le date vicine a quella attuale visualizzerà `ieri`, `oggi` o `domani`, altrimenti verrà visualizzato nel modo standard.

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

Vedi anche [#date].


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

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

Vedi anche [#capitalize], [#firstUpper], [#upper].


nocheck .[filter]
-----------------
Impedisce la pulizia automatica dell'indirizzo URL. Latte [controlla automaticamente |safety-first#Controllo dei link] se la variabile contiene un URL web (cioè protocollo HTTP/HTTPS) e impedisce la visualizzazione di link che potrebbero rappresentare un rischio per la sicurezza.

Se il link utilizza un altro schema, ad esempio `javascript:` o `data:`, e sei sicuro del suo contenuto, puoi disabilitare il controllo usando `|nocheck`.

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

<a href={$link}>controllato</a>
<a href={$link|nocheck}>non controllato</a>
```

Stampa:

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

Vedi anche [#checkUrl].


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

```latte
{var $trustedHtmlString = '<b>hello</b>'}
Escapato: {$trustedHtmlString}
Non escapato: {$trustedHtmlString|noescape}
```

Stampa:

```latte
Escapato: &lt;b&gt;hello&lt;/b&gt;
Non escapato: <b>hello</b>
```

.[warning]
L'uso improprio del filtro `noescape` può portare a una vulnerabilità XSS! Non utilizzarlo mai a meno che tu non sia **assolutamente sicuro** di quello che stai facendo e che la stringa stampata provenga da una fonte attendibile.


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

```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. Per questo è necessario aver impostato il [locale |develop#Locale]. Il formato è composto da diversi caratteri speciali, la cui descrizione completa si trova nella documentazione "DecimalFormat":https://unicode.org/reports/tr35/tr35-numbers.html#Number_Format_Patterns:

- `0` cifra obbligatoria, viene sempre visualizzata, anche se è zero
- `#` cifra facoltativa, viene visualizzata solo se il numero è effettivamente presente in quella posizione
- `@` cifra significativa, aiuta a visualizzare il numero con un certo numero di cifre significative
- `.` indica dove deve trovarsi la virgola decimale (o il punto, a seconda del paese)
- `,` serve per separare i gruppi di cifre, più comunemente le migliaia
- `%` moltiplica il numero per 100× e aggiunge il simbolo di percentuale

Vediamo alcuni esempi. Nel primo esempio, due cifre decimali sono obbligatorie, nel secondo facoltative. Il terzo esempio mostra il riempimento con zeri a sinistra e a destra, 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 quante cifre devono essere visualizzate indipendentemente dalla virgola decimale, arrotondando:

```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 simbolo `%`:

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

Possiamo definire un formato diverso per i numeri positivi e negativi, separati dal carattere `;`. In questo modo, ad esempio, è possibile impostare che i numeri positivi vengano visualizzati con il segno `+`:

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

Ricorda che l'aspetto effettivo dei numeri può variare a seconda delle impostazioni del paese. Ad esempio, in alcuni paesi si usa la virgola invece del punto come separatore decimale. Questo filtro lo tiene automaticamente in considerazione e non devi preoccuparti di nulla.


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

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


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

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


query .[filter]
---------------
Genera dinamicamente una query string in un 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>
```

Le chiavi con valore `null` vengono omesse.

Vedi anche [#escapeUrl].


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

```latte
{=[1, 2, 3, 4]|random}    {* stampa ad es.: 3 *}
{='abcd'|random}          {* stampa ad es.: 'b' *}
```

Vedi anche [#first], [#last].


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

```latte
{='hello'|repeat: 3}  {* stampa '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'}  {* stampa 'hello friend' *}
```

È possibile eseguire più sostituzioni contemporaneamente:

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


replaceRE(string $pattern, string $replace='') .[filter]
--------------------------------------------------------
Esegue una ricerca tramite espressione regolare con sostituzione.

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


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

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


round(int $precision=0) .[filter]
---------------------------------
Arrotonda un numero alla precisione specificata.

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

Vedi anche [#ceil], [#floor].


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

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

Il filtro funziona come la funzione PHP `array_slice` per gli array o `mb_substr` per le stringhe con fallback alla funzione `iconv_substr` in modalità UTF‑8.

Se start è positivo, la sequenza inizierà spostata di questo numero dall'inizio dell'array/stringa. Se è negativo, la sequenza inizierà spostata di tanto dalla fine.

Se il parametro length è specificato ed è positivo, la sequenza conterrà tanti elementi. Se a questa funzione viene passato un parametro length negativo, la sequenza conterrà tutti gli elementi dell'array originale, iniziando dalla posizione start e terminando alla posizione minore di length elementi dalla fine dell'array. Se questo parametro non viene specificato, la sequenza conterrà tutti gli elementi dell'array originale, iniziando dalla posizione start.

Per impostazione predefinita, il filtro riordina e reimposta le chiavi intere dell'array. 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 e conserva le loro chiavi associative. Se è impostato il [locale |develop#Locale], l'ordinamento segue le sue regole, a meno che non sia 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 è necessario ordinare una tabella per una colonna specifica, è possibile utilizzare il parametro `by`. Il valore `'name'` nell'esempio specifica che l'ordinamento avverrà per `$item->name` o `$item['name']`, a seconda che `$item` sia un array o un oggetto:

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

È anche possibile definire una funzione di callback che determini il valore in base al quale ordinare:

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

Allo stesso modo si può utilizzare anche il parametro `byKey`.


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

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

Stampa:

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


stripHtml .[filter]
-------------------
Converte HTML in testo puro. Cioè, rimuove i tag HTML e converte le entità HTML in testo.

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

Il testo puro risultante può naturalmente contenere caratteri che rappresentano tag HTML, ad esempio `'&lt;p&gt;'|stripHtml` viene convertito in `<p>`. In nessun caso stampare il testo così generato con `|noescape`, poiché ciò può portare a una falla di sicurezza.


substr(int $offset, ?int $length=null) .[filter]
------------------------------------------------
Estrae una parte di una stringa. Questo filtro è stato sostituito dal filtro [#slice].

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


translate(...$args) .[filter]
-----------------------------
Traduce le espressioni in altre lingue. Affinché il filtro sia disponibile, è necessario [impostare il traduttore |develop#TranslatorExtension]. È inoltre possibile utilizzare i [tag per la traduzione |tags#Traduzioni].

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


trim(string $charlist=" \t\n\r\0\x0B\u{A0}") .[filter]
------------------------------------------------------
Rimuove gli spazi bianchi (o altri caratteri) dall'inizio e dalla fine di una stringa.

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


truncate(int $length, string $append='…') .[filter]
---------------------------------------------------
Tronca una stringa alla lunghezza massima specificata, cercando di preservare le parole intere. Se la stringa viene accorciata, aggiunge alla fine tre punti (modificabili 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 una stringa in maiuscolo. Richiede l'estensione PHP `mbstring`.

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

Vedi anche [#capitalize], [#firstUpper], [#lower].


webalize .[filter]
------------------
Modifica una stringa UTF‑8 nella forma utilizzata negli URL.

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

```latte
{var $s = 'Il nostro 10° prodotto'}
{$s|webalize}   {* stampa 'il-nostro-10-prodotto' *}
```

.[caution]
Richiede la libreria [nette/utils|utils:].