Nette Documentation Preview

syntax
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.

Latte függvények

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

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

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:

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

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

Egyéni függvényeket így lehet regisztrálni:

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

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

Függvények

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

Az értéket a megadott inkluzív min és max tartományba korlátozza.

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

Lásd még a clamp szűrőt.

divisibleBy(int $value, int $by)bool

Ellenőrzi, hogy a változó osztható-e egy számmal.

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

even(int $value): bool

Ellenőrzi, hogy a megadott szám páros-e.

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

first(string|iterable $value)mixed

Visszaadja a tömb első elemét vagy a string első karakterét:

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

Lásd még last, a first szűrőt.

group(iterable $data, string|int|\Closure $by)array

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.

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

hasBlock(string $name): bool

Megállapítja, hogy a megadott nevű blokk létezik-e:

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

Lásd még a blokkok létezésének ellenőrzését.

last(string|array $value)mixed

Visszaadja a tömb utolsó elemét vagy a string utolsó karakterét:

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

Lásd még first, a last szűrőt.

odd(int $value): bool

Ellenőrzi, hogy a megadott szám páratlan-e.

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

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

Kivon egy részt a tömbből vagy stringből.

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