Fonctions de Latte
******************

.[perex]
Outre les fonctions PHP courantes, vous pouvez également les utiliser dans les modèles.

.[table-latte-filters]
| `clamp` | [fixe la valeur à l'intervalle |#clamp]
| `divisibleBy`| [vérifie si une variable est divisible par un nombre |#divisibleBy]
| `even` | [vérifie si le nombre donné est pair |#even]
| `first` | [renvoie le premier élément d'un tableau ou un caractère d'une chaîne de caractères |#first]
| `group` | [regroupe les données en fonction de différents critères |#group]
| `hasBlock` | [détecte l'existence d'un bloc |#hasBlock]
| `last` | [renvoie le dernier élément d'un tableau ou un caractère d'une chaîne de caractères |#last]
| `odd` | [vérifie si le nombre donné est impair |#odd]
| `slice` | [extrait une tranche d'un tableau ou d'une chaîne de caractères |#slice]


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

Les fonctions sont utilisées de la même manière que les fonctions PHP courantes et peuvent être utilisées dans toutes les expressions :

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

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

Les [fonctions personnalisées |extending-latte#functions] peuvent être enregistrées de cette façon :

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

Nous l'utilisons dans un modèle comme celui-ci :

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


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


clamp(int|float $value, int|float $min, int|float $max): int|float .[method]
----------------------------------------------------------------------------
Renvoie une valeur limitée à l'intervalle inclusif de min et max.

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

Voir également le [filtre clamp |filters#clamp]:


divisibleBy(int $value, int $by): bool .[method]
------------------------------------------------
Vérifie si une variable est divisible par un nombre.

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


even(int $value): bool .[method]
--------------------------------
Vérifie si le nombre donné est pair.

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


first(string|iterable $value): mixed .[method]
----------------------------------------------
Retourne le premier élément d'un tableau ou le premier caractère d'une chaîne de caractères :

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

Voir aussi [last |#last], [filter first |filters#first].


group(iterable $data, string|int|\Closure $by): array .[method]{data-version:3.0.16}
------------------------------------------------------------------------------------
Cette fonction permet de regrouper les données selon différents critères.

Dans cet exemple, les lignes du tableau sont regroupées par la colonne `categoryId`. La sortie est un tableau de champs dont la clé est la valeur de la colonne `categoryId`. Lisez les [instructions détaillées |cookbook/grouping].

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

Voir aussi [groupe de |filters#group] filtres.


hasBlock(string $name): bool .[method]{data-version:3.0.10}
-----------------------------------------------------------
Vérifie si le bloc du nom spécifié existe :

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

Voir aussi [vérification de l'existence du bloc |template-inheritance#Checking Block Existence].


last(string|array $value): mixed .[method]
------------------------------------------
Renvoie le dernier élément du tableau ou le dernier caractère de la chaîne :

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

Voir aussi [first |#first], [filter last |filters#last].


odd(int $value): bool .[method]
-------------------------------
Vérifie si le nombre donné est impair.

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


slice(string|array $value, int $start, ?int $length=null, bool $preserveKeys=false): string|array .[method]
-----------------------------------------------------------------------------------------------------------
Extrait une tranche d'un tableau ou d'une chaîne de caractères.

```latte
{=slice('hello', 1, 2)}           {* sorties 'el' *}
{=slice(['a', 'b', 'c'], 1, 2)}   {* sorties ['b', 'c'] *}
```

Le filtre de tranche fonctionne comme la fonction PHP `array_slice` pour les tableaux et `mb_substr` pour les chaînes de caractères, avec un retour à `iconv_substr` en mode UTF-8.

Si start est non négatif, la séquence commencera à ce point de départ dans la variable. Si start est négatif, la séquence commencera à cette distance de la fin de la variable.

Si length est donné et est positif, alors la séquence aura jusqu'à ce nombre d'éléments. Si la variable est plus courte que la longueur, seuls les éléments disponibles de la variable seront présents. Si la longueur est donnée et qu'elle est négative, la séquence s'arrêtera à ce nombre d'éléments à partir de la fin de la variable. Si elle est omise, alors la séquence contiendra tous les éléments depuis le décalage jusqu'à la fin de la variable.

Filter réordonnera et réinitialisera les clés du tableau d'entiers par défaut. Ce comportement peut être modifié en définissant preserveKeys à true. Les clés des chaînes de caractères sont toujours préservées, quel que soit ce paramètre.