Latte Filter
************

.[perex]
In Templates können wir Funktionen verwenden, die bei der Anpassung oder Umformatierung von Daten in die endgültige Form helfen. Wir nennen sie *Filter*.

.[table-latte-filters]
|## Transformation
| `batch`      | [Auflistung linearer Daten in einer Tabelle |#batch]
| `breakLines` | [Fügt HTML-Zeilenumbrüche am Ende der Zeilen hinzu |#breakLines]
| `bytes`      | [formatiert die Größe in Bytes |#bytes]
| `clamp`      | [begrenzt einen Wert auf einen bestimmten Bereich |#clamp]
| `dataStream` | [Konvertierung für das Data URI-Protokoll |#datastream]
| `date`       | [formatiert Datum und Uhrzeit |#date]
| `explode`    | [teilt eine Zeichenkette in ein Array anhand eines Trennzeichens |#explode]
| `first`      | [gibt das erste Element eines Arrays oder Zeichen einer Zeichenkette zurück |#first]
| `group`      | [gruppiert Daten nach verschiedenen Kriterien |#group]
| `implode`    | [verbindet ein Array zu einer Zeichenkette |#implode]
| `indent`     | [rückt Text von links um eine bestimmte Anzahl von Tabulatoren ein |#indent]
| `join`       | [verbindet ein Array zu einer Zeichenkette |#implode]
| `last`       | [gibt das letzte Element eines Arrays oder Zeichen einer Zeichenkette zurück |#last]
| `length`     | [gibt die Länge einer Zeichenkette in Zeichen oder eines Arrays zurück |#length]
| `localDate`  | [formatiert Datum und Uhrzeit entsprechend den Ländereinstellungen |#localDate]
| `number`     | [formatiert eine Zahl |#number]
| `padLeft`    | [füllt eine Zeichenkette links auf eine bestimmte Länge auf |#padLeft]
| `padRight`   | [füllt eine Zeichenkette rechts auf eine bestimmte Länge auf |#padRight]
| `random`     | [gibt ein zufälliges Element eines Arrays oder Zeichen einer Zeichenkette zurück |#random]
| `repeat`     | [Wiederholung einer Zeichenkette |#repeat]
| `replace`    | [ersetzt Vorkommen einer gesuchten Zeichenkette |#replace]
| `replaceRE`  | [ersetzt Vorkommen anhand eines regulären Ausdrucks |#replaceRE]
| `reverse`    | [kehrt eine UTF-8 Zeichenkette oder ein Array um |#reverse]
| `slice`      | [extrahiert einen Teil eines Arrays oder einer Zeichenkette |#slice]
| `sort`       | [sortiert ein Array |#sort]
| `spaceless`  | [entfernt Leerzeichen |#spaceless], ähnlich wie das [spaceless |tags] Tag
| `split`      | [teilt eine Zeichenkette in ein Array anhand eines Trennzeichens |#explode]
| `strip`      | [entfernt Leerzeichen |#spaceless]
| `stripHtml`  | [entfernt HTML-Tags und konvertiert HTML-Entities in Zeichen |#stripHtml]
| `substr`     | [gibt einen Teil einer Zeichenkette zurück |#substr]
| `trim`       | [entfernt führende und abschließende Leerzeichen oder andere Zeichen |#trim]
| `translate`  | [Übersetzung in andere Sprachen |#translate]
| `truncate`   | [kürzt die Länge unter Beibehaltung von Wörtern |#truncate]
| `webalize`   | [passt eine UTF-8 Zeichenkette in eine in URLs verwendete Form an |#webalize]

.[table-latte-filters]
|## Groß-/Kleinschreibung
| `capitalize` | [Kleinbuchstaben, erste Buchstaben der Wörter groß |#capitalize]
| `firstUpper` | [konvertiert den ersten Buchstaben in einen Großbuchstaben |#firstUpper]
| `lower`      | [konvertiert in Kleinbuchstaben |#lower]
| `upper`      | [konvertiert in Großbuchstaben |#upper]

.[table-latte-filters]
|## Rundung
| `ceil`       | [rundet eine Zahl auf eine bestimmte Genauigkeit auf |#ceil]
| `floor`      | [rundet eine Zahl auf eine bestimmte Genauigkeit ab |#floor]
| `round`      | [rundet eine Zahl auf eine bestimmte Genauigkeit |#round]

.[table-latte-filters]
|## Escaping
| `escapeUrl`  | [escapet einen Parameter in einer URL |#escapeUrl]
| `noescape`   | [gibt eine Variable ohne Escaping aus |#noescape]
| `query`      | [generiert einen Query-String in einer URL |#query]

Es gibt außerdem Escaping-Filter für HTML (`escapeHtml` und `escapeHtmlComment`), XML (`escapeXml`), JavaScript (`escapeJs`), CSS (`escapeCss`) und iCalendar (`escapeICal`), die Latte selbst dank [kontextsensitivem Escaping |safety-first#Context-aware escaping] verwendet und die Sie nicht explizit schreiben müssen.

.[table-latte-filters]
|## Sicherheit
| `checkUrl`   | [behandelt eine URL-Adresse gegen gefährliche Eingaben |#checkUrl]
| `nocheck`    | [verhindert die automatische Behandlung einer URL-Adresse |#nocheck]

Latte [überprüft automatisch |safety-first#link checking] die Attribute `src` und `href`, sodass Sie den `checkUrl`-Filter fast nie verwenden müssen.


.[note]
Alle Standard-Filter sind für Zeichenketten in UTF-8-Kodierung ausgelegt.


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

Filter werden durch einen senkrechten Strich notiert (vor dem ein Leerzeichen stehen kann):

```latte
<h1>{$heading|upper}</h1>
```

Filter (in älteren Versionen Helper genannt) können verkettet werden und werden dann in der Reihenfolge von links nach rechts angewendet:

```latte
<h1>{$heading|lower|capitalize}</h1>
```

Parameter werden nach dem Filternamen durch Doppelpunkte oder Kommas getrennt angegeben:

```latte
<h1>{$heading|truncate:20,''}</h1>
```

Filter können auch auf Ausdrücke angewendet werden:

```latte
{var $name = ($title|upper) . ($subtitle|lower)}</h1>
```

[Benutzerdefinierte Filter |extending-latte#filters] können auf diese Weise registriert werden:

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

Im Template wird es dann so aufgerufen:

```latte
<p>{$text|shortify}</p>
<p>{$text|shortify:100}</p>
```


Filter .[#toc-filters]
======================


batch(int $length, mixed $item): array .[filter]
------------------------------------------------
Ein Filter, der die Ausgabe linearer Daten in Form einer Tabelle vereinfacht. Er gibt ein Array von Arrays mit der angegebenen Anzahl von Elementen zurück. Wenn Sie einen zweiten Parameter angeben, wird er verwendet, um fehlende Elemente in der letzten Zeile zu ergänzen.

```latte
{var $items = ['a', 'b', 'c', 'd', 'e']}
<table>
{foreach ($items|batch: 3, 'No item') as $row}
	<tr>
		{foreach $row as $column}
			<td>{$column}</td>
		{/foreach}
	</tr>
{/foreach}
</table>
```

Gibt aus:

```latte
<table>
	<tr>
		<td>a</td>
		<td>b</td>
		<td>c</td>
	</tr>
	<tr>
		<td>d</td>
		<td>e</td>
		<td>No item</td>
	</tr>
</table>
```

Siehe auch [#group] und das [iterateWhile |tags#iterateWhile] Tag.


breakLines .[filter]
--------------------
Fügt vor jedem Zeilenumbruchzeichen ein HTML-Tag `<br>` ein

```latte
{var $s = "Text & with \n newline"}
{$s|breakLines}    {* gibt "Text &amp; with <br>\n newline" aus *}
```


bytes(int $precision=2) .[filter]
---------------------------------
Formatiert die Größe in Bytes in eine menschenlesbare Form. Wenn [Ländereinstellungen |develop#locale] gesetzt sind, werden die entsprechenden Dezimal- und Tausendertrennzeichen verwendet.

```latte
{$size|bytes}     0 B, 1.25 GB, …
{$size|bytes:0}   10 B, 1 GB, …
```


ceil(int $precision=0) .[filter]
--------------------------------
Rundet eine Zahl auf eine bestimmte Genauigkeit auf.

```latte
{=3.4|ceil}         {* gibt 4      aus *}
{=135.22|ceil:1}    {* gibt 135.3  aus *}
{=135.22|ceil:3}    {* gibt 135.22 aus *}
```

Siehe auch [#floor], [#round].


capitalize .[filter]
--------------------
Wörter beginnen mit Großbuchstaben, alle verbleibenden Zeichen sind klein. Erfordert die PHP-Erweiterung `mbstring`.

```latte
{='i like LATTE'|capitalize}  {* gibt 'I Like Latte' aus *}
```

Siehe auch [#firstUpper], [#lower], [#upper].


checkUrl .[filter]
------------------
Erzwingt die Behandlung einer URL-Adresse. Überprüft, ob die Variable eine Web-URL enthält (d.h. HTTP/HTTPS-Protokoll) und verhindert die Ausgabe von Links, die ein Sicherheitsrisiko darstellen können.

```latte
{var $link = 'javascript:window.close()'}
<a data-href={$link|checkUrl}>geprüft</a>
<a data-href={$link}>ungeprüft</a>
```

Gibt aus:

```latte
<a data-href="">geprüft</a>
<a data-href="javascript:window.close()">ungeprüft</a>
```

Siehe auch [#nocheck].


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

```latte
{$level|clamp: 0, 255}
```

Existiert auch als [Funktion |functions#clamp].


dataStream(string $mimetype=detect) .[filter]
---------------------------------------------
Konvertiert den Inhalt in das Data URI-Schema. Damit können Bilder ohne die Notwendigkeit externer Dateien in HTML oder CSS eingebettet werden.

Angenommen, wir haben ein Bild in der Variable `$img = Image::fromFile('bild.gif')`, dann

```latte
<img src={$img|dataStream}>
```

Gibt beispielsweise aus:

```latte
<img src="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAUA
AAAFCAYAAACNbyblAAAAHElEQVQI12P4//8/w38GIAXDIBKE0DHxgljNBAAO
9TXL0Y4OHwAAAABJRU5ErkJggg==">
```

.[caution]
Erfordert die PHP-Erweiterung `fileinfo`.


date(string $format) .[filter]
------------------------------
Formatiert Datum und Uhrzeit gemäß der von der PHP-Funktion [php:date] verwendeten Maske. Der Filter akzeptiert Datum im UNIX-Timestamp-Format, als Zeichenkette oder als Objekt vom Typ `DateTimeInterface`.

```latte
{$today|date:'j. n. Y'}
```

Siehe auch [#localDate].


escapeUrl .[filter]
-------------------
Escapet eine Variable zur Verwendung als Parameter in einer URL.

```latte
<a href="http://example.com/{$name|escapeUrl}">{$name}</a>
```

Siehe auch [#query].


explode(string $separator='') .[filter]
---------------------------------------
Teilt eine Zeichenkette anhand eines Trennzeichens in ein Array. Alias für `split`.

```latte
{='one,two,three'|explode:','}    {* gibt ['one', 'two', 'three'] zurück *}
```

Wenn das Trennzeichen eine leere Zeichenkette ist (Standardwert), wird die Eingabe in einzelne Zeichen aufgeteilt:

```latte
{='123'|explode}                  {* gibt ['1', '2', '3'] zurück *}
```

Sie können auch den Alias `split` verwenden:

```latte
{='1,2,3'|split:','}              {* gibt ['1', '2', '3'] zurück *}
```

Siehe auch [#implode].


first .[filter]
---------------
Gibt das erste Element eines Arrays oder das erste Zeichen einer Zeichenkette zurück:

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

Siehe auch [#last], [#random].


floor(int $precision=0) .[filter]
---------------------------------
Rundet eine Zahl auf eine bestimmte Genauigkeit ab.

```latte
{=3.5|floor}        {* gibt 3      aus *}
{=135.79|floor:1}   {* gibt 135.7  aus *}
{=135.79|floor:3}   {* gibt 135.79 aus *}
```

Siehe auch [#ceil], [#round].


firstUpper .[filter]
--------------------
Konvertiert den ersten Buchstaben in einen Großbuchstaben. Erfordert die PHP-Erweiterung `mbstring`.

```latte
{='the latte'|firstUpper}  {* gibt 'The latte' aus *}
```

Siehe auch [#capitalize], [#lower], [#upper].


group(string|int|\Closure $by): array .[filter]{data-version:3.0.16}
--------------------------------------------------------------------
Filter, der Daten nach verschiedenen Kriterien gruppiert.

In diesem Beispiel werden die Tabellenzeilen 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 ($items|group: categoryId) as $categoryId => $categoryItems}
    <ul>
        {foreach $categoryItems as $item}
            <li>{$item->name}</li>
        {/foreach}
    </ul>
{/foreach}
```

Siehe auch [#batch], die Funktion [group |functions#group] und das Tag [iterateWhile |tags#iterateWhile].


implode(string $glue='') .[filter]
----------------------------------
Gibt eine Zeichenkette zurück, die eine Verkettung der Elemente einer Sequenz ist. Alias für `join`.

```latte
{=[1, 2, 3]|implode}      {* gibt '123' aus *}
{=[1, 2, 3]|implode:'|'}  {* gibt '1|2|3' aus *}
```

Sie können auch den Alias `join` verwenden:

```latte
{=[1, 2, 3]|join}         {* gibt '123' aus *}
```


indent(int $level=1, string $char="\t") .[filter]
-------------------------------------------------
Rückt Text von links um eine bestimmte Anzahl von Tabulatoren oder anderen Zeichen ein, die im zweiten Argument angegeben werden können. Leere Zeilen werden nicht eingerückt.

```latte
<div>
{block |indent}
<p>Hello</p>
{/block}
</div>
```

Gibt aus:

```latte
<div>
	<p>Hello</p>
</div>
```


last .[filter]
--------------
Gibt das letzte Element eines Arrays oder das letzte Zeichen einer Zeichenkette zurück:

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

Siehe auch [#first], [#random].


length .[filter]
----------------
Gibt die Länge einer Zeichenkette oder eines Arrays zurück.

- für Zeichenketten gibt es die Länge in UTF-8-Zeichen zurück
- für Arrays gibt es die Anzahl der Elemente zurück
- für Objekte, die das Countable-Interface implementieren, verwendet es den Rückgabewert der count()-Methode
- für Objekte, die das IteratorAggregate-Interface implementieren, verwendet es den Rückgabewert der iterator_count()-Funktion


```latte
{if ($users|length) > 10}
	...
{/if}
```


localDate(?string $format=null, ?string $date=null, ?string $time=null) .[filter]
---------------------------------------------------------------------------------
Formatiert Datum und Uhrzeit gemäß den [Ländereinstellungen |develop#locale], was eine konsistente und lokalisierte Darstellung von Zeitangaben in verschiedenen Sprachen und Regionen gewährleistet. Der Filter akzeptiert ein Datum als UNIX-Timestamp, Zeichenkette oder Objekt vom Typ `DateTimeInterface`.

```latte
{$date|localDate}                  {* 15. April 2024 *}
{$date|format: yM}                 {* 4/2024 *}
{$date|localDate: date: medium}    {* 15. 4. 2024 *}
```

Wenn Sie den Filter ohne Parameter verwenden, wird das Datum auf der Ebene `long` ausgegeben, siehe unten.

**a) Verwendung des Formats**

Der Parameter `format` beschreibt, welche Zeitkomponenten angezeigt werden sollen. Es verwendet Buchstabencodes dafür, deren Wiederholungsanzahl die Breite der Ausgabe beeinflusst:

| Jahr | `y` / `yy` / `yyyy` | `2024` / `24` / `2024`
| Monat | `M` / `MM` / `MMM` / `MMMM` | `8` / `08` / `Aug` / `August`
| Tag | `d` / `dd` / `E` / `EEEE` |  `1` / `01` / `So` / `Sonntag`
| Stunde | `j` /  `H` / `h` | bevorzugt / 24-Stunden / 12-Stunden
| Minute | `m` / `mm` | `5` / `05` <small>(2 Ziffern in Kombination mit Sekunden)</small>
| Sekunde | `s` / `ss` | `8` / `08` <small>(2 Ziffern in Kombination mit Minuten)</small>

Die Reihenfolge der Codes im Format spielt keine Rolle, da die Reihenfolge der Komponenten gemäß den Konventionen der Ländereinstellungen ausgegeben wird. Das Format ist also unabhängig davon. Zum Beispiel wird das Format `yyyyMMMMd` in der Umgebung `en_US` als `April 15, 2024` ausgegeben, während es in der Umgebung `de_DE` als `15. April 2024` ausgegeben wird:

| locale:  | de-DE | en_US
|---
| `format: 'dMy'` | 10.8.2024 | 8/10/2024
| `format: 'yM'` | 08/2024 | 8/2024
| `format: 'yyyyMMMM'` | August 2024 | August 2024
| `format: 'MMMM'` | August | August
| `format: 'jm'` | 17:54 | 5:54 PM
| `format: 'Hm'` | 17:54 | 17:54
| `format: 'hm'` | 5:54 PM | 5:54 PM


**b) Verwendung vordefinierter Stile**

Die Parameter `date` und `time` bestimmen, wie detailliert Datum und Uhrzeit ausgegeben werden sollen. Sie können aus mehreren Ebenen wählen: `full`, `long`, `medium`, `short`. Es ist möglich, nur das Datum, nur die Uhrzeit oder beides ausgeben zu lassen:

| locale:  | de-DE | en_US
|---
| `date: short` | 23.01.78 | 1/23/78
| `date: medium` | 23.01.1978 | Jan 23, 1978
| `date: long` | 23. Januar 1978 | January 23, 1978
| `date: full` | Montag, 23. Januar 1978 | Monday, January 23, 1978
| `time: short` | 08:30 | 8:30 AM
| `time: medium` | 08:30:59 | 8:30:59 AM
| `time: long` | 08:30:59 MEZ | 8:30:59 AM GMT+1
| `date: short, time: short` | 23.01.78, 08:30 | 1/23/78, 8:30 AM
| `date: medium, time: short` | 23.01.1978, 08:30 | Jan 23, 1978, 8:30 AM
| `date: long, time: short` | 23. Januar 1978 um 08:30 | January 23, 1978 at 8:30 AM

Für das Datum können Sie außerdem das Präfix `relative-` verwenden (z.B. `relative-short`), das für Daten nahe der Gegenwart `gestern`, `heute` oder `morgen` anzeigt, andernfalls wird es auf die Standardweise ausgegeben.

```latte
{$date|localDate: date: relative-short}    {* gestern *}
```

Siehe auch [#date].


lower .[filter]
---------------
Konvertiert eine Zeichenkette in Kleinbuchstaben. Erfordert die PHP-Erweiterung `mbstring`.

```latte
{='LATTE'|lower}   {* gibt 'latte' aus *}
```

Siehe auch [#capitalize], [#firstUpper], [#upper].


nocheck .[filter]
-----------------
Verhindert die automatische Behandlung einer URL-Adresse. Latte [überprüft automatisch |safety-first#Link checking], ob die Variable eine Web-URL enthält (d.h. HTTP/HTTPS-Protokoll) und verhindert die Ausgabe von Links, die ein Sicherheitsrisiko darstellen können.

Wenn der Link ein anderes Schema verwendet, z.B. `javascript:` oder `data:`, und Sie sich seines Inhalts sicher sind, können Sie die Überprüfung mit `|nocheck` deaktivieren.

```latte
{var $link = 'javascript:window.close()'}

<a href={$link}>geprüft</a>
<a href={$link|nocheck}>ungeprüft</a>
```

Gibt aus:

```latte
<a href="">geprüft</a>
<a href="javascript:window.close()">ungeprüft</a>
```

Siehe auch [#checkUrl].


noescape .[filter]
------------------
Deaktiviert automatisches Escaping.

```latte
{var $trustedHtmlString = '<b>hello</b>'}
Escaped: {$trustedHtmlString}
Unescaped: {$trustedHtmlString|noescape}
```

Gibt aus:

```latte
Escaped: &lt;b&gt;hello&lt;/b&gt;
Unescaped: <b>hello</b>
```

.[warning]
Falsche Verwendung des `noescape`-Filters kann zu XSS-Schwachstellen führen! Verwenden Sie ihn niemals, wenn Sie nicht **absolut sicher** sind, was Sie tun, und dass die ausgegebene Zeichenkette aus einer vertrauenswürdigen Quelle stammt.


number(int $decimals=0, string $decPoint='.', string $thousandsSep=',') .[filter]
---------------------------------------------------------------------------------
Formatiert eine Zahl auf eine bestimmte Anzahl von Dezimalstellen. Wenn [Ländereinstellungen |develop#locale] gesetzt sind, werden die entsprechenden Dezimal- und Tausendertrennzeichen verwendet.

```latte
{1234.20|number}              1,234
{1234.20|number:1}            1,234.2
{1234.20|number:2}            1,234.20
{1234.20|number:2, ',', ' '}  1 234,20
```


number(string $format) .[filter]
--------------------------------
Der Parameter `format` ermöglicht es Ihnen, das Aussehen von Zahlen genau nach Ihren Bedürfnissen zu definieren. Dafür müssen [Ländereinstellungen |develop#locale] gesetzt sein. Das Format besteht aus mehreren speziellen Zeichen, deren vollständige Beschreibung Sie in der Dokumentation "DecimalFormat":https://unicode.org/reports/tr35/tr35-numbers.html#Number_Format_Patterns finden:

- `0` obligatorische Ziffer, wird immer angezeigt, auch wenn es eine Null ist
- `#` optionale Ziffer, wird nur angezeigt, wenn an dieser Stelle tatsächlich eine Zahl steht
- `@` signifikante Ziffer, hilft, eine Zahl mit einer bestimmten Anzahl gültiger Ziffern anzuzeigen
- `.` kennzeichnet, wo das Dezimalkomma (oder -punkt, je nach Land) sein soll
- `,` dient zur Trennung von Zifferngruppen, meist Tausender
- `%` multipliziert die Zahl mit 100 und fügt das Prozentzeichen hinzu

Schauen wir uns einige Beispiele an. Im ersten Beispiel sind zwei Dezimalstellen obligatorisch, im zweiten optional. Das dritte Beispiel zeigt das Auffüllen mit Nullen links und rechts, das vierte zeigt nur existierende Ziffern:

```latte
{1234.5|number: '#,##0.00'}     {* 1,234.50 *}
{1234.5|number: '#,##0.##'}     {* 1,234.5 *}
{1.23  |number: '000.000'}      {* 001.230 *}
{1.2   |number: '##.##'}        {* 1.2 *}
```

Signifikante Ziffern bestimmen, wie viele Ziffern unabhängig vom Dezimalpunkt angezeigt werden sollen, wobei gerundet wird:

```latte
{1234|number: '@@'}             {* 1200 *}
{1234|number: '@@@'}            {* 1230 *}
{1234|number: '@@@#'}           {* 1234 *}
{1.2345|number: '@@@'}          {* 1.23 *}
{0.00123|number: '@@'}          {* 0.0012 *}
```

Ein einfacher Weg, eine Zahl als Prozentsatz anzuzeigen. Die Zahl wird mit 100 multipliziert und das `%`-Zeichen wird hinzugefügt:

```latte
{0.1234|number: '#.##%'}        {* 12.34% *}
```

Wir können unterschiedliche Formate für positive und negative Zahlen definieren, getrennt durch ein `;`-Zeichen. Auf diese Weise können wir zum Beispiel festlegen, dass positive Zahlen mit einem `+`-Zeichen angezeigt werden sollen:

```latte
{42|number: '#.##;(#.##)'}      {* 42 *}
{-42|number: '#.##;(#.##)'}     {* (42) *}
{42|number: '+#.##;-#.##'}      {* +42 *}
{-42|number: '+#.##;-#.##'}     {* -42 *}
```

Beachten Sie, dass das tatsächliche Aussehen der Zahlen je nach den Ländereinstellungen variieren kann. In einigen Ländern wird beispielsweise ein Komma statt eines Punkts als Dezimaltrennzeichen verwendet. Dieser Filter berücksichtigt dies automatisch, und Sie müssen sich um nichts kümmern.


padLeft(int $length, string $pad=' ') .[filter]
-----------------------------------------------
Füllt eine Zeichenkette auf eine bestimmte Länge mit einer anderen Zeichenkette von links auf.

```latte
{='hello'|padLeft: 10, '123'}  {* gibt '12312hello' aus *}
```


padRight(int $length, string $pad=' ') .[filter]
------------------------------------------------
Füllt eine Zeichenkette auf eine bestimmte Länge mit einer anderen Zeichenkette von rechts auf.

```latte
{='hello'|padRight: 10, '123'}  {* gibt 'hello12312' aus *}
```


query .[filter]
---------------
Generiert dynamisch einen Query-String in einer URL:

```latte
<a href="http://example.com/?{[name: 'John Doe', age: 43]|query}">klicken</a>
<a href="http://example.com/?search={$search|query}">suchen</a>
```

Gibt aus:

```latte
<a href="http://example.com/?name=John+Doe&amp;age=43">klicken</a>
<a href="http://example.com/?search=Foo+Bar">suchen</a>
```

Schlüssel mit dem Wert `null` werden weggelassen.

Siehe auch [#escapeUrl].


random .[filter]
----------------
Gibt ein zufälliges Element eines Arrays oder ein zufälliges Zeichen einer Zeichenkette zurück:

```latte
{=[1, 2, 3, 4]|random}    {* gibt z.B.: 3 aus *}
{='abcd'|random}          {* gibt z.B.: 'b' aus *}
```

Siehe auch [#first], [#last].


repeat(int $count) .[filter]
----------------------------
Wiederholt eine Zeichenkette x-mal.

```latte
{='hello'|repeat: 3}  {* gibt 'hellohellohello' aus *}
```


replace(string|array $search, string $replace='') .[filter]
-----------------------------------------------------------
Ersetzt alle Vorkommen der Suchzeichenkette durch die Ersatzzeichenkette.

```latte
{='hello world'|replace: 'world', 'friend'}  {* gibt 'hello friend' aus *}
```

Es können auch mehrere Ersetzungen auf einmal durchgeführt werden:

```latte
{='hello world'|replace: [h => l, l => h]}  {* gibt 'lehho worhd' aus *}
```


replaceRE(string $pattern, string $replace='') .[filter]
--------------------------------------------------------
Führt eine Suche und Ersetzung mit regulären Ausdrücken durch.

```latte
{='hello world'|replaceRE: '/l.*/', 'l'}  {* gibt 'hel' aus *}
```


reverse .[filter]
-----------------
Kehrt die gegebene Zeichenkette oder das Array um.

```latte
{var $s = 'Nette'}
{$s|reverse}    {* gibt 'etteN' aus *}
{var $a = ['N', 'e', 't', 't', 'e']}
{$a|reverse}    {* gibt ['e', 't', 't', 'e', 'N'] zurück *}
```


round(int $precision=0) .[filter]
---------------------------------
Rundet eine Zahl auf die angegebene Genauigkeit.

```latte
{=3.4|round}        {* gibt 3      aus *}
{=3.5|round}        {* gibt 4      aus *}
{=135.79|round:1}   {* gibt 135.8  aus *}
{=135.79|round:3}   {* gibt 135.79 aus *}
```

Siehe auch [#ceil], [#floor].


slice(int $start, ?int $length=null, bool $preserveKeys=false) .[filter]
------------------------------------------------------------------------
Extrahiert einen Teil eines Arrays oder einer Zeichenkette.

```latte
{='hello'|slice: 1, 2}           {* gibt 'el' aus *}
{=['a', 'b', 'c']|slice: 1, 2}   {* gibt ['b', 'c'] aus *}
```

Der Filter funktioniert wie die PHP-Funktion `array_slice` für Arrays oder `mb_substr` für Zeichenketten mit 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 diese Anzahl vom Ende verschoben.

Wenn der Parameter length angegeben und positiv ist, enthält die Sequenz so viele Elemente. Wenn ein negativer length-Parameter an diese Funktion übergeben wird, enthält die Sequenz alle Elemente des ursprünglichen Arrays, beginnend an der Position start und endend an der Position, die um length Elemente vom Ende des Arrays entfernt ist. Wenn Sie diesen Parameter weglassen, enthält die Sequenz alle Elemente des ursprünglichen Arrays, beginnend an der Position start.

Standardmäßig ändert der Filter die Reihenfolge und setzt die ganzzahligen Schlüssel des Arrays 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.


sort(?Closure $comparison, string|int|\Closure|null $by=null, string|int|\Closure|bool $byKey=false) .[filter]
--------------------------------------------------------------------------------------------------------------
Der Filter sortiert die Elemente eines Arrays oder Iterators und behält ihre assoziativen Schlüssel bei. Bei gesetzten [Ländereinstellungen |develop#locale] folgt die Sortierung deren Regeln, wenn keine eigene Vergleichsfunktion angegeben ist.

```latte
{foreach ($names|sort) as $name}
	...
{/foreach}
```

Sortiertes Array in umgekehrter Reihenfolge:

```latte
{foreach ($names|sort|reverse) as $name}
	...
{/foreach}
```

Sie können eine eigene Vergleichsfunktion für die Sortierung angeben (das Beispiel zeigt, wie die Sortierung von größter zu kleinster umgekehrt wird):

```latte
{var $reverted = ($names|sort: fn($a, $b) => $b <=> $a)}
```

Der Filter `|sort` ermöglicht auch die Sortierung von Elementen nach Schlüsseln:

```latte
{foreach ($names|sort: byKey: true) as $name}
	...
{/foreach}
```

Wenn Sie eine Tabelle nach einer bestimmten Spalte sortieren müssen, können Sie den Parameter `by` verwenden. Der Wert `'name'` im Beispiel gibt an, dass nach `$item->name` oder `$item['name']` sortiert wird, je nachdem, ob `$item` ein Array oder ein Objekt ist:

```latte
{foreach ($items|sort: by: 'name') as $item}
	{$item->name}
{/foreach}
```

Sie können auch eine Callback-Funktion definieren, die den Wert bestimmt, nach dem sortiert werden soll:

```latte
{foreach ($items|sort: by: fn($items) => $items->category->name) as $item}
	{$item->name}
{/foreach}
```

Der Parameter `byKey` kann auf die gleiche Weise verwendet werden.


spaceless .[filter]
-------------------
Entfernt überflüssige Leerzeichen aus der Ausgabe. Sie können auch den Alias `strip` verwenden.

```latte
{block |spaceless}
	<ul>
		<li>Hello</li>
	</ul>
{/block}
```

Gibt aus:

```latte
<ul> <li>Hello</li> </ul>
```


stripHtml .[filter]
-------------------
Konvertiert HTML in reinen Text. Das heißt, es entfernt HTML-Tags und konvertiert HTML-Entities in Text.

```latte
{='<p>one &lt; two</p>'|stripHtml}  {* gibt 'one < two' aus *}
```

Der resultierende reine Text kann natürlich Zeichen enthalten, die HTML-Tags darstellen, zum Beispiel wird `'&lt;p&gt;'|stripHtml` zu `<p>` konvertiert. Geben Sie den so erzeugten Text auf keinen Fall mit `|noescape` aus, da dies zu einer Sicherheitslücke führen kann.


substr(int $offset, ?int $length=null) .[filter]
------------------------------------------------
Extrahiert einen Teil einer Zeichenkette. Dieser Filter wurde durch den Filter [#slice] ersetzt.

```latte
{$string|substr: 1, 2}
```


translate(string $message, ...$args) .[filter]
----------------------------------------------
Übersetzt Ausdrücke in andere Sprachen. Damit der Filter verfügbar ist, muss ein [Übersetzer eingerichtet |develop#TranslatorExtension] sein. Sie können auch [Tags für Übersetzungen |tags#Translation] verwenden.

```latte
<a href="basket">{='Cart'|translate}</a>
<span>{$item|translate}</span>
```


trim(string $charlist=" \t\n\r\0\x0B\u{A0}") .[filter]
------------------------------------------------------
Entfernt Leerzeichen (oder andere Zeichen) vom Anfang und Ende einer Zeichenkette.

```latte
{='  I like Latte.  '|trim}    {* gibt 'I like Latte.' aus *}
{='  I like Latte.'|trim: '.'}  {* gibt '  I like Latte' aus *}
```


truncate(int $length, string $append='…') .[filter]
---------------------------------------------------
Kürzt eine Zeichenkette auf die angegebene maximale Länge, wobei versucht wird, ganze Wörter zu erhalten. Wenn die Zeichenkette gekürzt wird, wird am Ende ein Auslassungszeichen hinzugefügt (kann mit dem zweiten Parameter geändert werden).

```latte
{var $title = 'Hello, how are you?'}
{$title|truncate:5}   {* Hell… *}
{$title|truncate:17}  {* Hello, how are… *}
{$title|truncate:30}  {* Hello, how are you? *}
```


upper .[filter]
---------------
Konvertiert eine Zeichenkette in Großbuchstaben. Erfordert die PHP-Erweiterung `mbstring`.

```latte
{='latte'|upper}  {* gibt 'LATTE' aus *}
```

Siehe auch [#capitalize], [#firstUpper], [#lower].


webalize .[filter]
------------------
Konvertiert eine UTF-8-Zeichenkette in die in URLs verwendete Form.

Es wird in ASCII konvertiert. Konvertiert Leerzeichen in Bindestriche. Entfernt Zeichen, die nicht alphanumerisch, Unterstriche oder Bindestriche sind. Konvertiert in Kleinbuchstaben. Entfernt auch führende und abschließende Leerzeichen.

```latte
{var $s = 'Unser 10. Produkt'}
{$s|webalize}   {* gibt 'unser-10-produkt' aus *}
```

.[caution]
Erfordert die Bibliothek [nette/utils |utils:].