Latte funkciók
**************

.[perex]
Az általános PHP-funkciók mellett ezeket is használhatod a sablonokban.

.[table-latte-filters]
| `clamp` | [az értéket a tartományba szorítja |#clamp]
| `divisibleBy`| [ellenőrzi, hogy egy 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 karakterlánc első karakterét |#first]
| `group` | [adatok csoportosítása különböző kritériumok szerint|#group]
| `hasBlock` | [érzékeli egy blokk létezését |#hasBlock]
| `last` | [visszaadja a tömb utolsó elemét vagy a karakterlánc utolsó karakterét |#last]
| `odd` | [ellenőrzi, hogy az adott szám páratlan-e |#odd]
| `slice` | [kivonja egy tömb vagy egy karakterlánc egy szeletét |#slice]


Használat .[#toc-usage]
=======================

A függvények ugyanúgy használhatók, mint az általános PHP függvények, és minden kifejezésben használhatók:

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

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

[Egyéni függvények |extending-latte#functions] így regisztrálhatók:

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

Egy sablonban így használjuk:

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


Funkciók .[#toc-functions]
==========================


clamp(int|float $value, int|float $min, int|float $max): int|float .[method]
----------------------------------------------------------------------------
Visszaadja a min és max tartományba szorított értéket.

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

Lásd még [szűrőbilincs |filters#clamp]:


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

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


even(int $value): bool .[method]
--------------------------------
Ellenőrzi, hogy az adott 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 karakterlánc első karakterét:

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

Lásd még [last |#last], [filter first |filters#first].


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

Ebben a példában a táblázat sorait a `categoryId` oszlop alapján csoportosítja. A kimenet egy mezőkből álló tömb, ahol a kulcs a `categoryId` oszlopban szereplő érték. Olvassa el a [részletes utasításokat |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 [szűrőcsoport |filters#group].


hasBlock(string $name): bool .[method]{data-version:3.0.10}
-----------------------------------------------------------
Ellenőrzi, hogy a megadott nevű blokk létezik-e:

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

Lásd még a [blokk létezésének ellenőrzése |template-inheritance#Checking Block Existence].


last(string|array $value): mixed .[method]
------------------------------------------
A tömb utolsó elemét vagy a karakterlánc utolsó karakterét adja vissza:

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

Lásd még [first |#first], [filter last |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]
-----------------------------------------------------------------------------------------------------------
Kivonja egy tömb vagy egy karakterlánc egy szeletét.

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

A slice-szűrő a `array_slice` PHP-funkcióként működik tömbök esetében, a `mb_substr` pedig karakterláncok esetében, UTF-8 módban pedig a `iconv_substr` funkcióra való visszalépéssel.

Ha a kezdet nem negatív, akkor a szekvencia a változóban ezzel a kezdőponttal kezdődik. Ha a start negatív, akkor a szekvencia a változó végétől ilyen messze kezdődik.

Ha a length értéke pozitív, akkor a szekvencia legfeljebb ennyi elemet tartalmaz. Ha a változó rövidebb, mint a hossz, akkor csak a rendelkezésre álló változóelemek lesznek jelen. Ha a hossz meg van adva és negatív, akkor a sorozat ennyi elemmel a változó vége előtt fog megállni. Ha nem adjuk meg, akkor a szekvencia az eltolódástól a változó végéig mindent tartalmazni fog.

A Filter alapértelmezés szerint átrendezi és visszaállítja az integer tömb kulcsát. Ez a viselkedés megváltoztatható a preserveKeys true értékre állításával. A string kulcsok ettől a paramétertől függetlenül mindig megmaradnak.