Nette Documentation Preview

syntax
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]
| `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|array $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].


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.

Fonctions de Latte

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

clamp fixe la valeur à l'intervalle
divisibleBy vérifie si une variable est divisible par un nombre
even vérifie si le nombre donné est pair
first renvoie le premier élément d'un tableau ou un caractère d'une chaîne de caractères
hasBlock détecte l'existence d'un bloc
last renvoie le dernier élément d'un tableau ou un caractère d'une chaîne de caractères
odd vérifie si le nombre donné est impair
slice extrait une tranche d'un tableau ou d'une chaîne de caractères

Utilisation

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 :

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

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

Les fonctions personnalisées peuvent être enregistrées de cette façon :

$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 :

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

Fonctions

clamp(int|float $value, int|float $min, int|float $max): int|float

Renvoie une valeur limitée à l'intervalle inclusif de min et max.

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

Voir également le filtre clamp:

divisibleBy(int $value, int $by)bool

Vérifie si une variable est divisible par un nombre.

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

even(int $value): bool

Vérifie si le nombre donné est pair.

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

first(string|array $value)mixed

Retourne le premier élément d'un tableau ou le premier caractère d'une chaîne de caractères :

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

Voir aussi last, filter first.

hasBlock(string $name): bool

Vérifie si le bloc du nom spécifié existe :

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

Voir aussi vérification de l'existence du bloc.

last(string|array $value)mixed

Renvoie le dernier élément du tableau ou le dernier caractère de la chaîne :

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

Voir aussi first, filter last.

odd(int $value): bool

Vérifie si le nombre donné est impair.

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

slice(string|array $value, int $start, int $length=null, bool $preserveKeys=false): string|array

Extrait une tranche d'un tableau ou d'une chaîne de caractères.

{=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.