Funzioni del latte
******************

.[perex]
Oltre alle comuni funzioni PHP, è possibile utilizzarle anche nei template.

.[table-latte-filters]
| `clamp` | [blocca il valore all'intervallo |#clamp]
| `divisibleBy`| [controlla se una variabile è divisibile per un numero |#divisibleBy]
| `even` | [controlla se il numero dato è pari |#even]
| `first` | [restituisce il primo elemento di un array o un carattere di una stringa |#first]
| `group` | [raggruppa i dati secondo vari criteri |#group]
| `hasBlock` | [rileva l'esistenza di un blocco |#hasBlock]
| `last` | [restituisce l'ultimo elemento di un array o un carattere di una stringa |#last]
| `odd` | [controlla se il numero dato è dispari |#odd]
| `slice` | [estrae una fetta di un array o di una stringa |#slice]


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

Le funzioni sono utilizzate allo stesso modo delle comuni funzioni PHP e possono essere usate in tutte le espressioni:

```latte
<p>{clamp($num, 1, 100)}</p>

{if odd($num)} ... {/if}
```

[Le funzioni personalizzate |extending-latte#functions] possono essere registrate in questo modo:

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

Le usiamo in un modello come questo:

```latte
<p>{shortify($text)}</p>
<p>{shortify($text, 100)}</p>
```


Funzioni .[#toc-functions]
==========================


clamp(int|float $value, int|float $min, int|float $max): int|float .[method]
----------------------------------------------------------------------------
Restituisce un valore limitato all'intervallo compreso tra min e max.

```latte
{=clamp($level, 0, 255)}
```

Vedere anche [filtro clamp |filters#clamp]:


divisibleBy(int $value, int $by): bool .[method]
------------------------------------------------
Verifica se una variabile è divisibile per un numero.

```latte
{if divisibleBy($num, 5)} ... {/if}
```


even(int $value): bool .[method]
--------------------------------
Verifica se il numero dato è pari.

```latte
{if even($num)} ... {/if}
```


first(string|iterable $value): mixed .[method]
----------------------------------------------
Restituisce il primo elemento di una matrice o un carattere di una stringa:

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

Vedere anche [last |#last], [filter first |filters#first].


group(iterable $data, string|int|\Closure $by): array .[method]{data-version:3.0.16}
------------------------------------------------------------------------------------
Questa funzione raggruppa i dati in base a diversi criteri.

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

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

Vedere anche [gruppo di |filters#group] filtri.


hasBlock(string $name): bool .[method]{data-version:3.0.10}
-----------------------------------------------------------
Controlla se il blocco con il nome specificato esiste:

```latte
{if hasBlock(header)} ... {/if}
```

Si veda anche il [controllo dell'esistenza del blocco |template-inheritance#Checking Block Existence].


last(string|array $value): mixed .[method]
------------------------------------------
Restituisce l'ultimo elemento della matrice o il carattere della stringa:

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

Vedere anche [first |#first], [filter last |filters#last].


odd(int $value): bool .[method]
-------------------------------
Controlla se il numero dato è dispari.

```latte
{if odd($num)} ... {/if}
```


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

```latte
{=slice('hello', 1, 2)} {* output 'el' *}
{=slice(['a', 'b', 'c'], 1, 2)} {* output ['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.