Latte Filtern
*************

.[perex]
Filter sind Funktionen, die die Daten in der gewünschten Form verändern oder formatieren. Dies ist eine Zusammenfassung der eingebauten Filter, die verfügbar sind.

.[table-latte-filters]
|## String / Array Transformation
| `batch` | [Auflistung linearer Daten in einer Tabelle |#batch]
| `breakLines` | [fügt HTML-Zeilenumbrüche vor allen Zeilenumbrüchen ein |#breakLines]
| `bytes` | [formatiert Größe in Bytes |#bytes]
| `clamp` | [klemmt Wert auf den Bereich |#clamp]
| `dataStream` | [Konvertierung des Daten-URI-Protokolls |#datastream]
| `date` | [formatiert Datum |#date]
| `explode` | [trennt eine Zeichenkette durch das angegebene Trennzeichen auf |#explode]
| `first` | [gibt das erste Element eines Arrays oder ein Zeichen einer Zeichenkette zurück |#first]
| `implode` | [fügt ein Array zu einer Zeichenkette zusammen |#implode]
| `indent` | [rückt den Text von links mit einer Anzahl von Tabulatorenein |#indent]
| `join` | [verbindet ein Array mit einer Zeichenkette|#implode]
| `last` | [gibt das letzte Element eines Arrays oder ein Zeichen einer Zeichenkette zurück |#last]
| `length` | [gibt die Länge einer Zeichenkette oder eines Arrays zurück |#length]
| `number` | [formatiert Zahlen |#number]
| `padLeft` | [vervollständigt die Zeichenkette auf die angegebene Länge von links |#padLeft]
| `padRight` | [vervollständigt die Zeichenkette auf die angegebene Länge von rechts |#padRight]
| `random` | [gibt zufällige Elemente eines Arrays oder Zeichen einer Zeichenkette zurück |#random]
| `repeat` | [Wiederholt die Zeichenkette |#repeat]
| `replace` | [ersetzt alle Vorkommen der gesuchten Zeichenkette durch die Ersetzung |#replace]
| `replaceRE` | [ersetzt alle Vorkommen entsprechend dem regulären Ausdruck |#replaceRE]
| `reverse` | [kehrt eine UTF-8 Zeichenkette oder ein Array um |#reverse]
| `slice` | [extrahiert einen Ausschnitt aus einem Array oder einer Zeichenkette |#slice]
| `sort` | [sortiert ein Array |#sort]
| `spaceless` | [entfernt Leerzeichen |#spaceless], ähnlich dem [spaceless |tags] tag
| `split` | [trennt eine Zeichenkette durch das angegebene Trennzeichen auf |#explode]
| `strip` | [Entfernt Leerzeichen |#spaceless]
| `stripHtml` | [entfernt HTML-Tags und konvertiert HTML-Entities in Text |#stripHtml]
| `substr` | [gibt einen Teil der Zeichenkette zurück |#substr]
| `trim` | [entfernt Leerzeichen aus der Zeichenkette |#trim]
| `translate` | [Übersetzung in andere Sprachen |#translate]
| `truncate` | [verkürzt die Länge unter Beibehaltung ganzer Wörter |#truncate]
| `webalize` | [passt die UTF-8-Zeichenfolge an die in der URL verwendete Forman |#webalize]

.[table-latte-filters]
|## Buchstabenumbruch
| `capitalize` | [Kleinschreibung, der erste Buchstabe eines jeden Wortes wird großgeschrieben |#capitalize]
| `firstUpper` | [macht den ersten Buchstaben zu einem Großbuchstaben |#firstUpper]
| `lower` | [macht eine Zeichenfolge klein |#lower]
| `upper` | [macht eine Zeichenkette zu einem Großbuchstaben |#upper]

.[table-latte-filters]
|## Rundung von Zahlen
| `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` | [gibt einen Parameter in der URL als Escapezeichen aus|#escapeUrl]
| `noescape` | [druckt eine Variable ohne Escaping |#noescape]
| `query` | [erzeugt eine Abfragezeichenfolge in der URL |#query]

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

.[table-latte-filters]
|## Sicherheit
| `checkUrl` | [säubert Zeichenketten für die Verwendung im href-Attribut |#checkUrl]
| `nocheck` | [verhindert automatische URL-Sanitisierung |#nocheck]

Latte der `src` und `href` Attribute [prüft automatisch |safety-first#link checking], so dass Sie den `checkUrl` Filter fast nicht verwenden müssen.


.[note]
Alle eingebauten Filter arbeiten mit UTF-8 kodierten Zeichenketten.


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

Latte erlaubt den Aufruf von Filtern unter Verwendung der Pipe-Schreibweise (vorangestelltes Leerzeichen ist erlaubt):

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

Filter können verkettet werden, in diesem Fall gelten sie in der Reihenfolge von links nach rechts:

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

Die Parameter werden durch Doppelpunkt oder Komma getrennt hinter den Filternamen gesetzt:

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

Filter können 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));
```

Wir verwenden sie in einer Vorlage wie dieser:

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


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


batch(int length, mixed item): array .[filter]
----------------------------------------------
Filter, der die Auflistung von linearen 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 dieser verwendet, um fehlende Elemente in der letzten Zeile aufzufüllen.

```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>
```

Druckt:

```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>
```


breakLines .[filter]
--------------------
Fügt HTML-Zeilenumbrüche vor allen Zeilenumbrüchen ein.

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


bytes(int precision = 2) .[filter]
----------------------------------
Formatiert eine Größe in Bytes in eine für Menschen lesbare Form.

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


ceil(int precision = 0) .[filter]
---------------------------------
Rundet eine Zahl bis zu einer bestimmten Genauigkeit.

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

Siehe auch [Stockwerk |#floor], [Runden |#round].


capitalize .[filter]
--------------------
Gibt eine Version des Wertes in Großbuchstaben zurück. Die Wörter beginnen mit Großbuchstaben, alle übrigen Zeichen sind Kleinbuchstaben. Erfordert die PHP-Erweiterung `mbstring`.

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

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


checkUrl .[filter]
------------------
Erzwingt URL-Sanitization. Sie prüft, ob die Variable eine Web-URL enthält (d. h. HTTP/HTTPS-Protokoll) und verhindert das Schreiben von Links, die ein Sicherheitsrisiko darstellen könnten.

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

Druckt:

```latte
<a data-href="">checked</a>
<a data-href="javascript:window.close()">unchecked</a>
```

Siehe auch [nocheck |#nocheck].


clamp(int|float min, int|float max) .[filter]
---------------------------------------------
Gibt einen Wert zurück, der auf den einschließenden Bereich von min und max geklemmt ist.

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

Existiert auch als [Funktion |functions#clamp].


dataStream(string mimetype = detect) .[filter]
----------------------------------------------
Konvertiert den Inhalt in ein Daten-URI-Schema. Es kann verwendet werden, um Bilder in HTML oder CSS einzufügen, ohne dass externe Dateien verlinkt werden müssen.

Nehmen wir an, ein Bild befindet sich in einer Variablen `$img = Image::fromFile('obrazek.gif')`, dann

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

Druckt zum Beispiel:

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

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


date(string format) .[filter]
-----------------------------
Liefert ein Datum im angegebenen Format unter Verwendung der Optionen der PHP-Funktionen [php:strftime] oder [php:date]. Der Filter erhält ein Datum als UNIX-Zeitstempel, als String oder als Objekt vom Typ `DateTime`.

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


escapeUrl .[filter]
-------------------
Entfernt eine Variable, die als Parameter in einer URL verwendet werden soll.

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

Siehe auch [Abfrage |#query].


explode(string separator = '') .[filter]
----------------------------------------
Teilt eine Zeichenkette durch den angegebenen Begrenzer und gibt ein Array von Zeichenketten zurück. Alias für `split`.

```latte
{='one,two,three'|explode:','}    {* liefert ['one', 'two', 'three'] *}
```

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

```latte
{='123'|explode}                  {* liefert ['1', '2', '3'] *}
```

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

```latte
{='1,2,3'|split:','}              {* liefert ['1', '2', '3'] *}
```

Siehe auch [implode |#implode].


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

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

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


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

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

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


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

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

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


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

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

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

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


indent(int level = 1, string char = "\t") .[filter]
---------------------------------------------------
Rückt einen Text von links um eine bestimmte Anzahl von Tabulatoren oder anderen Zeichen ein, die wir im zweiten optionalen Argument angeben. Leerzeilen werden nicht eingerückt.

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

Druckt:

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


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

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

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


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

- bei Strings wird die Länge in UTF-8 Zeichen zurückgegeben
- für Arrays wird die Anzahl der Elemente zurückgegeben
- bei Objekten, die die Schnittstelle Countable implementieren, wird der Rückgabewert der Funktion count() verwendet
- für Objekte, die die Schnittstelle IteratorAggregate implementieren, wird der Rückgabewert von iterator_count() verwendet.


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


lower .[filter]
---------------
Konvertiert einen Wert in Kleinbuchstaben. Erfordert die PHP-Erweiterung `mbstring`.

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

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


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

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

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

<a href={$link}>checked</a>
<a href={$link|nocheck}>unchecked</a>
```

Drucke:

```latte
<a href="">checked</a>
<a href="javascript:window.close()">unchecked</a>
```

Siehe auch [checkUrl |#checkUrl].


noescape .[filter]
------------------
Deaktiviert das automatische Escaping.

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

Druckt:

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

.[warning]
Die missbräuchliche Verwendung des `noescape` Filters kann zu einer XSS-Schwachstelle führen! Verwenden Sie ihn nur, wenn Sie **absolut sicher** sind, was Sie tun und dass die Zeichenfolge, die Sie drucken, aus einer vertrauenswürdigen Quelle stammt.


number(int decimals = 0, string decPoint = '.', string thousandsSep = ',') .[filter]
------------------------------------------------------------------------------------
Formatiert eine Zahl auf eine bestimmte Anzahl von Dezimalstellen. Sie können auch ein Zeichen für den Dezimalpunkt und das Tausendertrennzeichen angeben.

```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
```


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

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


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

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


query  .[filter]
----------------
Erzeugt dynamisch eine Abfragezeichenfolge in der URL:

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

Druckt:

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

Tasten mit einem Wert von `null` werden ausgelassen.

Siehe auch [escapeUrl |#escapeUrl].


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

```latte
{=[1, 2, 3, 4]|random}    {* example output: 3 *}
{='abcd'|random}          {* example output: 'b' *}
```

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


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

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


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

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

Es können mehrere Ersetzungen auf einmal vorgenommen werden:

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


replaceRE(string pattern, string replace = '') .[filter]
--------------------------------------------------------
Ersetzt alle Vorkommen entsprechend dem regulären Ausdruck.

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


reverse .[filter]
-----------------
Kehrt eine gegebene Zeichenkette oder ein gegebenes Array um.

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


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

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

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


slice(int start, int length = null, bool preserveKeys = false) .[filter]
------------------------------------------------------------------------
Extrahiert einen Ausschnitt aus einem Array oder einer Zeichenkette.

```latte
{='hello'|slice: 1, 2}           {* gibt 'el' *}
{=['a', 'b', 'c']|slice: 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.


sort  .[filter]
---------------
Filter, der ein Array sortiert und die Indexzuordnung beibehält.

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

Array in umgekehrter Reihenfolge sortiert.

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

Sie können Ihre eigene Vergleichsfunktion als Parameter übergeben:

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


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

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

Druckt:

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


stripHtml .[filter]
-------------------
Konvertiert HTML in einfachen Text. Das heißt, es werden HTML-Tags entfernt und HTML-Elemente in Text umgewandelt.

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

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


substr(int offset, int length = null) .[filter]
-----------------------------------------------
Extrahiert einen Ausschnitt aus einer Zeichenkette. Dieser Filter wurde durch einen [Slice-Filter |#slice] ersetzt.

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


translate(string message, ...args) .[filter]
--------------------------------------------
Er übersetzt Ausdrücke in andere Sprachen. Um den Filter verfügbar zu machen, müssen Sie den [Übersetzer ein richten|develop#TranslatorExtension]. Sie können auch die [Tags für die Übersetzung |tags#Translation] verwenden.

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


trim(string charlist = " \t\n\r\0\x0B\u{A0}") .[filter]
-------------------------------------------------------
Entfernen Sie führende und nachgestellte Zeichen, standardmäßig Leerzeichen.

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


truncate(int length, string append = '…') .[filter]
---------------------------------------------------
Kürzt eine Zeichenkette auf die maximal angegebene Länge, versucht aber, ganze Wörter zu erhalten. Wenn die Zeichenkette abgeschnitten ist, wird am Ende ein Auslassungszeichen hinzugefügt (dies kann durch den 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 einen Wert in Großbuchstaben. Erfordert die PHP-Erweiterung `mbstring`.

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

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


webalize .[filter]
------------------
Konvertiert nach ASCII.

Konvertiert Leerzeichen in Bindestriche. Entfernt Zeichen, die keine alphanumerischen Zeichen, Unterstriche oder Bindestriche sind. Konvertiert in Kleinbuchstaben. Entfernt auch führende und nachfolgende Leerzeichen.

```latte
{var $s = 'Our 10. product'}
{$s|webalize}    {* gibt 'our-10-product' *}
```

.[caution]
Erfordert das Paket [nette/utils |utils:].