Funcții Latte
*************

.[perex]
În plus față de funcțiile PHP obișnuite, le puteți utiliza și în șabloane.

.[table-latte-filters]
| `clamp` | [fixează valoarea în interval |#clamp]
| `divisibleBy`| [verifică dacă o variabilă este divizibilă cu un număr |#divisibleBy]
| `even` | [verifică dacă numărul dat este par |#even]
| `first` | [returnează primul element al unui array sau caracterul unui șir de caractere|#first]
| `group` | [grupează datele în funcție de diverse criterii |#group]
| `hasBlock` | [detectează existența unui bloc |#hasBlock]
| `last` | [returnează ultimul element al unui array sau caracter al unui șir de caractere|#last]
| `odd` | [verifică dacă numărul dat este impar |#odd]
| `slice` | [extrage o porțiune dintr-un tablou sau un șir de caractere |#slice]


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

Funcțiile sunt utilizate în același mod ca și funcțiile obișnuite din PHP și pot fi utilizate în toate expresiile:

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

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

[Funcțiile personalizate |extending-latte#functions] pot fi înregistrate în acest mod:

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

Le folosim într-un șablon ca acesta:

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


Funcții .[#toc-functions]
=========================


clamp(int|float $value, int|float $min, int|float $max): int|float .[method]
----------------------------------------------------------------------------
Returnează valoarea fixată în intervalul inclusiv dintre min și max.

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

A se vedea, de asemenea, [filter clamp |filters#clamp]:


divisibleBy(int $value, int $by): bool .[method]
------------------------------------------------
Verifică dacă o variabilă este divizibilă cu un număr.

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


even(int $value): bool .[method]
--------------------------------
Verifică dacă numărul dat este par.

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


first(string|iterable $value): mixed .[method]
----------------------------------------------
Returnează primul element al unui tablou sau caracterul unui șir de caractere:

```latte
{=first([1, 2, 3, 4])}    {* ieșiri 1 *}
{=first('abcd')}          {* iese "a" *}
```

A se vedea, de asemenea, [last |#last], [filter first |filters#first].


group(iterable $data, string|int|\Closure $by): array .[method]{data-version:3.0.16}
------------------------------------------------------------------------------------
Această funcție grupează datele în funcție de diferite criterii.

În acest exemplu, rândurile din tabel sunt grupate în funcție de coloana `categoryId`. Rezultatul este o matrice de câmpuri în care cheia este valoarea din coloana `categoryId`. Citiți [instrucțiunile detaliate |cookbook/grouping].

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

A se vedea, de asemenea, [grupul de |filters#group] filtre.


hasBlock(string $name): bool .[method]{data-version:3.0.10}
-----------------------------------------------------------
Verifică dacă blocul cu numele specificat există:

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

A se vedea, de asemenea, [verificarea existenței blocului |template-inheritance#Checking Block Existence].


last(string|array $value): mixed .[method]
------------------------------------------
Returnează ultimul element al unui array sau caracter al unui șir de caractere:

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

A se vedea, de asemenea, [first |#first], [filter last |filters#last].


odd(int $value): bool .[method]
-------------------------------
Verifică dacă numărul dat este impar.

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


slice(string|array $value, int $start, ?int $length=null, bool $preserveKeys=false): string|array .[method]
-----------------------------------------------------------------------------------------------------------
Extrage o porțiune dintr-un tablou sau un șir de caractere.

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

Filtrul de felie funcționează ca funcția PHP `array_slice` pentru array-uri și `mb_substr` pentru șiruri de caractere, cu o revenire la `iconv_substr` în modul UTF-8.

În cazul în care startul nu este negativ, secvența va începe de la acel start în variabilă. Dacă start este negativ, secvența va începe la acea distanță de la sfârșitul variabilei.

În cazul în care lungimea este dată și este pozitivă, atunci secvența va avea până la numărul de elemente din ea. În cazul în care variabila este mai scurtă decât lungimea, atunci vor fi prezente numai elementele disponibile ale variabilei. În cazul în care lungimea este dată și este negativă, secvența se va opri la atâtea elemente de la sfârșitul variabilei. În cazul în care este omisă, secvența va conține toate elementele de la offset până la sfârșitul variabilei.

Filter reordonează și resetează implicit cheile tabloului de numere întregi. Acest comportament poate fi modificat prin setarea preserveKeys la true. Cheile șirurilor de caractere sunt întotdeauna păstrate, indiferent de acest parametru.