Latte-Funktionen
****************

.[perex]
In Templates können wir neben den üblichen PHP-Funktionen auch diese zusätzlichen Funktionen verwenden.

.[table-latte-filters]
| `clamp`      | [begrenzt einen Wert auf einen bestimmten Bereich |#clamp]
| `divisibleBy`| [prüft, ob eine Variable durch eine Zahl teilbar ist |#divisibleBy]
| `even`       | [prüft, ob eine gegebene Zahl gerade ist |#even]
| `first`      | [gibt das erste Element eines Arrays oder das erste Zeichen einer Zeichenkette zurück |#first]
| `group`      | [gruppiert Daten nach verschiedenen Kriterien |#group]
| `hasBlock`   | [prüft die Existenz eines Blocks |#hasBlock]
| `last`       | [gibt das letzte Element eines Arrays oder das letzte Zeichen einer Zeichenkette zurück |#last]
| `odd`        | [prüft, ob eine gegebene Zahl ungerade ist |#odd]
| `slice`      | [extrahiert einen Teil eines Arrays oder einer Zeichenkette |#slice]


Verwendung
==========

Funktionen werden genauso wie übliche PHP-Funktionen verwendet und können in allen Ausdrücken eingesetzt werden:

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

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

[Benutzerdefinierte Funktionen |custom-functions] können auf diese Weise registriert werden:

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

Im Template wird sie dann so aufgerufen:

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


Funktionen
==========


clamp(int|float $value, int|float $min, int|float $max): int|float .[method]
----------------------------------------------------------------------------
Begrenzt einen Wert auf den angegebenen inklusiven Bereich von min und max.

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

Siehe auch der [Filter clamp |filters#clamp].


divisibleBy(int $value, int $by): bool .[method]
------------------------------------------------
Prüft, ob eine Variable durch eine Zahl teilbar ist.

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


even(int $value): bool .[method]
--------------------------------
Prüft, ob eine gegebene Zahl gerade ist.

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


first(string|iterable $value): mixed .[method]
----------------------------------------------
Gibt das erste Element eines Arrays oder das erste Zeichen einer Zeichenkette zurück:

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

Siehe auch [#last], [Filter first |filters#first].


group(iterable $data, string|int|\Closure $by): array .[method]{data-version:3.0.16}
------------------------------------------------------------------------------------
Die Funktion gruppiert Daten nach verschiedenen Kriterien.

In diesem Beispiel werden die Zeilen in der Tabelle nach der Spalte `categoryId` gruppiert. Die Ausgabe ist ein Array von Arrays, wobei der Schlüssel der Wert in der Spalte `categoryId` ist. [Lesen Sie die detaillierte Anleitung |cookbook/grouping].

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

Siehe auch der Filter [group |filters#group].


hasBlock(string $name): bool .[method]{data-version:3.0.10}
-----------------------------------------------------------
Prüft, ob ein Block mit dem angegebenen Namen existiert:

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

Siehe auch [Überprüfung der Existenz von Blöcken |template-inheritance#Existenzprüfung von Blöcken].


last(string|array $value): mixed .[method]
------------------------------------------
Gibt das letzte Element eines Arrays oder das letzte Zeichen einer Zeichenkette zurück:

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

Siehe auch [#first], [Filter last |filters#last].


odd(int $value): bool .[method]
-------------------------------
Prüft, ob eine gegebene Zahl ungerade ist.

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


slice(string|array $value, int $start, ?int $length=null, bool $preserveKeys=false): string|array .[method]
-----------------------------------------------------------------------------------------------------------
Extrahiert einen Teil eines Arrays oder einer Zeichenkette.

```latte
{=slice('hallo', 1, 2)}           {* gibt 'al' aus *}
{=slice(['a', 'b', 'c'], 1, 2)}   {* gibt ['b', 'c'] aus *}
```

Die Funktion funktioniert wie die PHP-Funktion `array_slice` für Arrays oder `mb_substr` für Zeichenketten mit einem Fallback auf die Funktion `iconv_substr` im UTF-8-Modus.

Wenn `start` positiv ist, beginnt die Sequenz um diese Anzahl vom Anfang des Arrays/der Zeichenkette verschoben. Wenn es negativ ist, beginnt die Sequenz um so viel vom Ende verschoben.

Wenn der Parameter `length` angegeben ist und positiv ist, enthält die Sequenz so viele Elemente. Wenn dieser Funktion ein negativer Parameter `length` übergeben wird, enthält die Sequenz alle Elemente des ursprünglichen Arrays, beginnend bei der Position `start` und endend bei einer Position, die um `length` Elemente kleiner ist als das Ende des Arrays. Wenn Sie diesen Parameter nicht angeben, enthält die Sequenz alle Elemente des ursprünglichen Arrays, beginnend bei der Position `start`.

Standardmäßig ändert der Filter die Reihenfolge und setzt die Ganzzahl-Schlüssel des Arrays zurück. Dieses Verhalten kann durch Setzen von `preserveKeys` auf `true` geändert werden. Zeichenketten-Schlüssel bleiben immer erhalten, unabhängig von diesem Parameter.