Latte Funktionen
****************

.[perex]
Zusätzlich zu den üblichen PHP-Funktionen können Sie diese auch in Vorlagen verwenden.

.[table-latte-filters]
| `clamp` | [klemmt den Wert auf den Bereich |#clamp]
| `divisibleBy`| [prüft ob eine Variable durch eine Zahl teilbar ist |#divisibleBy]
| `even` | [prüft ob die angegebene Zahl gerade ist |#even]
| `first` | [gibt das erste Element eines Arrays oder ein Zeichen einer Zeichenkette zurück |#first]
| `group` | [gruppiert Daten nach verschiedenen Kriterien |#group]
| `hasBlock` | [erkennt das Vorhandensein eines Blocks |#hasBlock]
| `last` | [gibt das letzte Element eines Arrays oder ein Zeichen einer Zeichenkette zurück |#last]
| `odd` | [prüft ob die angegebene Zahl ungerade ist |#odd]
| `slice` | [extrahiert einen Ausschnitt aus einem Array oder einer Zeichenkette|#slice]


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

Funktionen werden auf die gleiche Weise verwendet wie die üblichen PHP-Funktionen und können in allen Ausdrücken verwendet werden:

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

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

[Benutzerdefinierte Funktionen |extending-latte#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));
```

Wir verwenden sie in einer Vorlage wie dieser:

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


Funktionen .[#toc-functions]
============================


clamp(int|float $value, int|float $min, int|float $max): int|float .[method]
----------------------------------------------------------------------------
Gibt einen Wert zurück, der auf den gesamten Bereich von min und max begrenzt ist.

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

Siehe auch [Filter Klammer |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 die angegebene Zahl gerade ist.

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


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

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

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


group(iterable $data, string|int|\Closure $by): array .[method]{data-version:3.0.16}
------------------------------------------------------------------------------------
Diese 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 Feldern, wobei der Schlüssel der Wert in der Spalte `categoryId` ist. Lesen Sie die [ausführliche 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 [Filtergruppe |filters#group].


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

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

Siehe auch [Blockexistenzprüfung |template-inheritance#Checking Block Existence].


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

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

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


odd(int $value): bool .[method]
-------------------------------
Prüft, ob die angegebene 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 Ausschnitt aus einem Array oder einer Zeichenkette.

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

Der Slice-Filter funktioniert wie die PHP-Funktion `array_slice` für Arrays und `mb_substr` für Strings mit einem Fallback auf `iconv_substr` im UTF-8-Modus.

Wenn start nicht negativ ist, beginnt die Sequenz an diesem Anfang in der Variablen. Wenn start negativ ist, beginnt die Sequenz so weit vom Ende der Variablen entfernt.

Wenn length angegeben wird und positiv ist, wird die Sequenz bis zu dieser Anzahl von Elementen enthalten. Wenn die Variable kürzer als die Länge ist, werden nur die verfügbaren Elemente der Variablen angezeigt. Wenn length angegeben wird und negativ ist, endet die Sequenz so viele Elemente vor dem Ende der Variablen. Wird sie weggelassen, enthält die Sequenz alle Elemente vom Offset bis zum Ende der Variablen.

Filter ordnet die Schlüssel des Integer-Arrays standardmäßig neu an und setzt sie zurück. Dieses Verhalten kann geändert werden, indem preserveKeys auf true gesetzt wird. String-Schlüssel werden immer beibehalten, unabhängig von diesem Parameter.