Funciones Latte
***************

.[perex]
Además de las funciones comunes de PHP, también puede utilizarlas en plantillas.

.[table-latte-filters]
| `clamp` | [sujeta el valor al rango |#clamp]
| `divisibleBy`| [comprueba si una variable es divisible por un número |#divisibleBy]
| `even` | [comprueba si el número dado es par |#even]
| `first` | [devuelve el primer elemento de una matriz o un carácter de una cadena |#first]
| `group` | [agrupa los datos según varios criterios |#group]
| `hasBlock` | [detecta la existencia de un bloque |#hasBlock]
| `last` | [devuelve el último elemento de la matriz o carácter de la cadena|#last]
| `odd` | [comprueba si el número dado es impar|#odd]
| `slice` | [extrae un trozo de una matriz o de una cadena |#slice]


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

Las funciones se utilizan de la misma manera que las funciones comunes de PHP y se pueden utilizar en todas las expresiones:

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

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

Las funciones [personalizadas |extending-latte#functions] se pueden registrar de esta manera:

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

La usamos en una plantilla como esta:

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


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


clamp(int|float $value, int|float $min, int|float $max): int|float .[method]
----------------------------------------------------------------------------
Devuelve el valor ajustado al rango inclusivo de mín y máx.

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

Véase también [abrazadera de filtro |filters#clamp]:


divisibleBy(int $value, int $by): bool .[method]
------------------------------------------------
Comprueba si una variable es divisible por un número.

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


even(int $value): bool .[method]
--------------------------------
Comprueba si el número dado es par.

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


first(string|iterable $value): mixed .[method]
----------------------------------------------
Devuelve el primer elemento de un array o carácter de una cadena:

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

Véase también [last |#last], [filter first |filters#first].


group(iterable $data, string|int|\Closure $by): array .[method]{data-version:3.0.16}
------------------------------------------------------------------------------------
Esta función agrupa los datos según diferentes criterios.

En este ejemplo, las filas de la tabla se agrupan por la columna `categoryId`. La salida es una matriz de campos donde la clave es el valor de la columna `categoryId`. Lea las [instrucciones detalladas |cookbook/grouping].

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

Véase también [grupo de |filters#group] filtros.


hasBlock(string $name): bool .[method]{data-version:3.0.10}
-----------------------------------------------------------
Comprueba si existe el bloque del nombre especificado:

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

Véase también [comprobación |template-inheritance#Checking Block Existence] de existencia de bloque.


last(string|array $value): mixed .[method]
------------------------------------------
Devuelve el último elemento del array o carácter de la cadena:

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

Véase también [first |#first], [filter last |filters#last].


odd(int $value): bool .[method]
-------------------------------
Comprueba si el número dado es impar.

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


slice(string|array $value, int $start, ?int $length=null, bool $preserveKeys=false): string|array .[method]
-----------------------------------------------------------------------------------------------------------
Extrae una porción de un array o de una cadena.

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

El filtro de rebanada funciona como la función PHP `array_slice` para matrices y `mb_substr` para cadenas con un fallback a `iconv_substr` en modo UTF-8.

Si start es no negativo, la secuencia comenzará en ese inicio de la variable. Si start es negativo, la secuencia comenzará a esa distancia del final de la variable.

Si la longitud es positiva, la secuencia tendrá hasta ese número de elementos. Si la variable es más corta que la longitud, sólo estarán presentes los elementos disponibles de la variable. Si la longitud es negativa, la secuencia se detendrá a esa cantidad de elementos del final de la variable. Si se omite, entonces la secuencia tendrá todo desde offset hasta el final de la variable.

Filter reordenará y restablecerá las claves de la matriz de enteros por defecto. Este comportamiento puede cambiarse estableciendo preserveKeys a true. Las claves de cadena siempre se conservan, independientemente de este parámetro.