Latte függvények
****************

.[perex]
A sablonokban a szokásos PHP függvényeken kívül ezeket a továbbiakat is használhatjuk.

.[table-latte-filters]
| `clamp`      | [értéket korlátoz adott tartományba |#clamp]
| `divisibleBy`| [ellenőrzi, hogy a változó osztható-e egy számmal |#divisibleBy]
| `even`       | [ellenőrzi, hogy a megadott szám páros-e |#even]
| `first`      | [visszaadja a tömb első elemét vagy a string első karakterét |#first]
| `group`      | [adatokat csoportosít különböző kritériumok szerint |#group]
| `hasBlock`   | [megállapítja egy blokk létezését |#hasBlock]
| `last`       | [visszaadja a tömb utolsó elemét vagy a string utolsó karakterét |#last]
| `odd`        | [ellenőrzi, hogy a megadott szám páratlan-e |#odd]
| `slice`      | [kivon egy részt a tömbből vagy stringből |#slice]


Használat
=========

A függvényeket ugyanúgy használjuk, mint a szokásos PHP függvényeket, és minden kifejezésben használhatók:

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

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

[Egyéni függvényeket|custom-functions] így lehet regisztrálni:

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

A sablonban pedig így hívjuk meg:

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


Függvények
==========


clamp(int|float $value, int|float $min, int|float $max): int|float .[method]
----------------------------------------------------------------------------
Az értéket a megadott inkluzív min és max tartományba korlátozza.

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

Lásd még a [clamp szűrőt |filters#clamp].


divisibleBy(int $value, int $by): bool .[method]
------------------------------------------------
Ellenőrzi, hogy a változó osztható-e egy számmal.

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


even(int $value): bool .[method]
--------------------------------
Ellenőrzi, hogy a megadott szám páros-e.

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


first(string|iterable $value): mixed .[method]
----------------------------------------------
Visszaadja a tömb első elemét vagy a string első karakterét:

```latte
{=first([1, 2, 3, 4])}    {* kiírja: 1 *}
{=first('abcd')}          {* kiírja: 'a' *}
```

Lásd még [#last], a [first szűrőt |filters#first].


group(iterable $data, string|int|\Closure $by): array .[method]{data-version:3.0.16}
------------------------------------------------------------------------------------
A függvény csoportosítja az adatokat különböző kritériumok szerint.

Ebben a példában a táblázat sorai a `categoryId` oszlop szerint vannak csoportosítva. A kimenet egy tömbökből álló tömb, ahol a kulcs a `categoryId` oszlop értéke. [Olvassa el a részletes útmutatót|cookbook/grouping].

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

Lásd még a [group szűrőt |filters#group].


hasBlock(string $name): bool .[method]{data-version:3.0.10}
-----------------------------------------------------------
Megállapítja, hogy a megadott nevű blokk létezik-e:

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

Lásd még a [blokkok létezésének ellenőrzését |template-inheritance#Blokkok létezésének ellenőrzése ifset].


last(string|array $value): mixed .[method]
------------------------------------------
Visszaadja a tömb utolsó elemét vagy a string utolsó karakterét:

```latte
{=last([1, 2, 3, 4])}    {* kiírja: 4 *}
{=last('abcd')}          {* kiírja: 'd' *}
```

Lásd még [#first], a [last szűrőt |filters#last].


odd(int $value): bool .[method]
-------------------------------
Ellenőrzi, hogy a megadott szám páratlan-e.

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


slice(string|array $value, int $start, ?int $length=null, bool $preserveKeys=false): string|array .[method]
-----------------------------------------------------------------------------------------------------------
Kivon egy részt a tömbből vagy stringből.

```latte
{=slice('helló', 1, 2)}           {* kiírja: 'el' *}
{=slice(['a', 'b', 'c'], 1, 2)}   {* kiírja: ['b', 'c'] *}
```

A függvény úgy működik, mint a PHP `array_slice` függvénye tömbökre vagy az `mb_substr` stringekre, fallbackként az `iconv_substr` függvénnyel UTF‑8 módban.

Ha a start pozitív, a szekvencia ennyivel eltolva kezdődik a tömb/string elejétől. Ha negatív, a szekvencia ennyivel eltolva kezdődik a végétől.

Ha a length paraméter meg van adva és pozitív, a szekvencia ennyi elemet fog tartalmazni. Ha negatív length paramétert adunk át ennek a függvénynek, a szekvencia az eredeti tömb összes elemét tartalmazza, a start pozíciótól kezdve és a tömb végétől számított length elemmel korábban végződve. Ha ezt a paramétert nem adja meg, a szekvencia az eredeti tömb összes elemét tartalmazza, a start pozíciótól kezdve.

Alapértelmezés szerint a függvény megváltoztatja a sorrendet és visszaállítja a tömb egész számú kulcsait. Ez a viselkedés megváltoztatható a `preserveKeys` `true`-ra állításával. A string kulcsok mindig megmaradnak, ettől a paramétertől függetlenül.