Latte filtry
************

.[perex]
Filtry v šablonách Latte pomáhají upravit nebo přeformátovat data do požadované podoby

.[table-latte-filters]
|## Transformace
| `batch`      | [rozdělí lineární data do bloků |#batch]
| `breakLines` | [přidá HTML odřádkování za konce řádků |#breakLines]
| `bytes`      | [formátuje velikost v bajtech |#bytes]
| `clamp`      | [omezí hodnotu do daného rozsahu |#clamp]
| `dataStream` | [převede data do formátu Data URI |#datastream]
| `date`       | [formátuje datum a čas |#date]
| `explode`    | [rozdělí řetězec na pole podle oddělovače |#explode]
| `first`      | [vrátí první prvek pole nebo znak řetězce |#first]
| `group`      | [seskupí data podle zadaných kritérií |#group]
| `implode`    | [spojí pole do řetězce |#implode]
| `indent`     | [odsadí text zleva |#indent]
| `join`       | [spojí pole do řetězce |#implode]
| `last`       | [vrátí poslední prvek pole nebo znak řetězce |#last]
| `length`     | [vrátí délku řetězce nebo počet prvků pole |#length]
| `localDate`  | [formátuje datum a čas podle národního prostředí |#localDate]
| `number`     | [formátuje číslo |#number]
| `padLeft`    | [doplní řetězec zleva na požadovanou délku |#padLeft]
| `padRight`   | [doplní řetězec zprava na požadovanou délku |#padRight]
| `random`     | [vrátí náhodný prvek pole nebo znak řetězce |#random]
| `repeat`     | [opakuje řetězec |#repeat]
| `replace`    | [nahradí výskyty hledaného řetězce |#replace]
| `replaceRE`  | [nahradí výskyty podle regulárního výrazu |#replaceRE]
| `reverse`    | [obrátí pořadí znaků v řetězci nebo prvků v poli |#reverse]
| `slice`      | [extrahuje část pole nebo řetězce |#slice]
| `sort`       | [seřadí pole |#sort]
| `spaceless`  | [odstraní nadbytečné bílé znaky |#spaceless]
| `split`      | [rozdělí řetězec na pole podle oddělovače |#explode]
| `strip`      | [odstraní nadbytečné bílé znaky |#spaceless]
| `stripHtml`  | [odstraní HTML značky a převede entity na znaky |#stripHtml]
| `substr`     | [vrátí část řetězce |#substr]
| `trim`       | [odstraní bílé znaky na začátku a konci řetězce |#trim]
| `translate`  | [přeloží text do jiného jazyka |#translate]
| `truncate`   | [zkrátí text na danou délku se zachováním slov |#truncate]
| `webalize`   | [upraví řetězec pro použití v URL |#webalize]

.[table-latte-filters]
|## Velikost písmen
| `capitalize` | [převede první písmeno každého slova na velké |#capitalize]
| `firstUpper` | [převede první písmeno na velké |#firstUpper]
| `lower`      | [převede text na malá písmena |#lower]
| `upper`      | [převede text na velká písmena |#upper]

.[table-latte-filters]
|## Zaokrouhlování
| `ceil`       | [zaokrouhlí číslo nahoru |#ceil]
| `floor`      | [zaokrouhlí číslo dolů |#floor]
| `round`      | [zaokrouhlí číslo |#round]

.[table-latte-filters]
|## Escapování
| `escapeUrl`  | [escapuje parametr v URL |#escapeUrl]
| `noescape`   | [vypne automatické escapování |#noescape]
| `query`      | [generuje query string v URL |#query]

Latte automaticky používá escapovací filtry pro HTML (`escapeHtml` a `escapeHtmlComment`), XML (`escapeXml`), JavaScript (`escapeJs`), CSS (`escapeCss`) a iCalendar (`escapeICal`) díky [kontextově sensitivnímu escapování|safety-first#Kontextově sensitivní escapování]. Tyto filtry není třeba explicitně zapisovat.

.[table-latte-filters]
|## Bezpečnost
| `checkUrl`   | [zkontroluje a případně upraví URL adresu |#checkUrl]
| `nocheck`    | [vypne automatickou kontrolu URL adresy |#nocheck]


.[note]
Všechny výchozí filtry jsou navrženy pro práci s řetězci v kódování UTF-8.


Použití
=======

Filtry se aplikují pomocí svislítka za proměnnou nebo výrazem:

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

Filtry lze řetězit, v takovém případě se aplikují zleva doprava:

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

Parametry filtrů se zadávají za dvojtečkou:

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

Filtry lze použít i na výrazy:

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

[Vlastní filtry|extending-latte#filtry] se registrují následovně:

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

V šabloně se pak volají stejně jako vestavěné filtry:

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


Filtry
======


batch(int $length, mixed $item): array .[filter]
------------------------------------------------
Filtr `batch` usnadňuje výpis lineárních dat do tabulkové struktury. Vrací pole polí s požadovaným počtem položek. Pokud zadáte druhý parametr, použije se k doplnění chybějících položek v posledním řádku.

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

Výstup:

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

Viz také [#group] a značka [iterateWhile|tags#iterateWhile].


breakLines .[filter]
--------------------
Filtr `breakLines` vkládá HTML značku `<br>` před každý znak nového řádku.

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


bytes(int $precision=2) .[filter]
---------------------------------
Filtr `bytes` formátuje velikost v bajtech do lidsky čitelné podoby. Pokud je nastaveno [národní prostředí |develop#locale], použijí se odpovídající oddělovače desetinných míst a tisíců.

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

Viz také [#number].


ceil(int $precision=0) .[filter]
--------------------------------
Filtr `ceil` zaokrouhlí číslo nahoru na danou přesnost.

```latte
{=3.4|ceil}         {* vypíše 4      *}
{=135.22|ceil:1}    {* vypíše 135.3  *}
{=135.22|ceil:3}    {* vypíše 135.22 *}
```

Viz také [#floor], [#round].


capitalize .[filter]
--------------------
Filtr `capitalize` upraví text tak, že první písmeno každého slova bude velké a zbývající malá. Vyžaduje PHP rozšíření `mbstring`.

```latte
{='i like LATTE'|capitalize}  {* vypíše 'I Like Latte' *}
```

Viz také [#firstUpper], [#lower], [#upper].


checkUrl .[filter]
------------------
Filtr `checkUrl` zajistí kontrolu a případné ošetření URL adresy. Ověří, zda proměnná obsahuje webovou URL (tj. protokol HTTP/HTTPS) a zabrání vypsání odkazů, které by mohly představovat bezpečnostní riziko.

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

Výstup:

```latte
<a data-href="">kontrolované</a>
<a data-href="javascript:window.close()">nekontrolované</a>
```

Latte automaticky [kontroluje atributy |safety-first#Kontrola odkazů] `src` a `href`, takže filtr `checkUrl` většinou není nutné explicitně uvádět.

Viz také [#nocheck].


clamp(int|float $min, int|float $max) .[filter]
-----------------------------------------------
Filtr `clamp` omezí hodnotu do zadaného inkluzivního rozsahu min a max.

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

K dispozici je také jako [funkce|functions#clamp].


dataStream(string $mimetype=detect) .[filter]
---------------------------------------------
Filtr `dataStream` konvertuje obsah do schématu data URI. To umožňuje vkládat obrázky přímo do HTML nebo CSS bez nutnosti odkazovat na externí soubory.

Pokud máme v proměnné obrázek `$img = Image::fromFile('obrazek.gif')`, potom

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

vypíše například:

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

.[caution]
Vyžaduje PHP rozšíření `fileinfo`.


date(string $format) .[filter]
------------------------------
Filtr `date` formátuje datum a čas podle zadané masky, kterou používá PHP funkce [php:date]. Filtr akceptuje datum ve formátu UNIX timestamp, jako řetězec nebo objekt typu `DateTimeInterface`.

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

Viz také [#localDate].


escapeUrl .[filter]
-------------------
Filtr `escapeUrl` escapuje proměnnou pro bezpečné použití jako parametr v URL.

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

Viz také [#query].


explode(string $separator='') .[filter]
---------------------------------------
Filtr `explode` rozdělí řetězec na pole podle zadaného oddělovače. Je to alias pro `split`.

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

Pokud je oddělovač prázdný řetězec (výchozí hodnota), vstup se rozdělí na jednotlivé znaky:

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

Můžete také použít alias `split`:

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

Viz také [#implode].


first .[filter]
---------------
Filtr `first` vrací první prvek pole nebo první znak řetězce:

```latte
{=[1, 2, 3, 4]|first}    {* vypíše 1 *}
{='abcd'|first}          {* vypíše 'a' *}
```

Viz také [#last], [#random].


floor(int $precision=0) .[filter]
---------------------------------
Filtr `floor` zaokrouhlí číslo dolů na danou přesnost.

```latte
{=3.5|floor}        {* vypíše 3      *}
{=135.79|floor:1}   {* vypíše 135.7  *}
{=135.79|floor:3}   {* vypíše 135.79 *}
```

Viz také [#ceil], [#round].


firstUpper .[filter]
--------------------
Filtr `firstUpper` převede první písmeno na velké. Vyžaduje PHP rozšíření `mbstring`.

```latte
{='the latte'|firstUpper}  {* vypíše 'The latte' *}
```

Viz také [#capitalize], [#lower], [#upper].


group(string|int|\Closure $by): array .[filter]{data-version:3.0.16}
--------------------------------------------------------------------
Filtr `group` umožňuje seskupit data podle různých kritérií.

V tomto příkladu se řádky v tabulce seskupují podle sloupce `categoryId`. Výstupem je pole polí, kde klíčem je hodnota ve sloupci `categoryId`. [Přečtěte si podrobný návod|cookbook/grouping].

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

Viz také [#batch], funkce [group|functions#group] a značka [iterateWhile|tags#iterateWhile].


implode(string $glue='') .[filter]
----------------------------------
Filtr `implode` spojí prvky pole do řetězce. Je to alias pro `join`.

```latte
{=[1, 2, 3]|implode}      {* vypíše '123' *}
{=[1, 2, 3]|implode:'|'}  {* vypíše '1|2|3' *}
```

Můžete také použít alias `join`:

```latte
{=[1, 2, 3]|join}         {* vypíše '123' *}
```


indent(int $level=1, string $char="\t") .[filter]
-------------------------------------------------
Filtr `indent` odsadí text zleva o zadaný počet tabulátorů nebo jiných znaků. Prázdné řádky nejsou odsazeny.

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

Výstup:

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


last .[filter]
--------------
Filtr `last` vrací poslední prvek pole nebo poslední znak řetězce:

```latte
{=[1, 2, 3, 4]|last}    {* vypíše 4 *}
{='abcd'|last}          {* vypíše 'd' *}
```

Viz také [#first], [#random].


length .[filter]
----------------
Filtr `length` vrátí délku řetězce nebo počet prvků v poli.

- pro řetězce vrátí počet unicode znaků
- pro pole vrátí počet prvků
- pro objekty implementující rozhraní Countable použije návratovou hodnotu metody count()
- pro objekty implementující rozhraní IteratorAggregate použije návratovou hodnotu funkce iterator_count()

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


localDate(?string $format=null, ?string $date=null, ?string $time=null) .[filter]
---------------------------------------------------------------------------------
Filtr `localDate` formátuje datum a čas podle [národního prostředí |develop#locale]. To zajišťuje konzistentní a lokalizované zobrazení časových údajů napříč různými jazyky a regiony. Filtr přijímá datum jako UNIX timestamp, řetězec nebo objekt typu `DateTimeInterface`.

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

Bez parametrů se datum vypíše v úrovni `long` (viz dále).

**a) použití formátu**

Parametr `format` definuje, které časové složky se mají zobrazit. Používá písmena jako kódy, jejichž počet opakování ovlivňuje šířku výstupu:

| rok | `y` / `yy` / `yyyy` | `2024` / `24` / `2024`
| měsíc | `M` / `MM` / `MMM` / `MMMM` | `8` / `08` / `srp` / `srpen`
| den | `d` / `dd` / `E` / `EEEE` |  `1` / `01` / `ne` / `neděle`
| hodina | `j` /  `H` / `h` | preferovaná / 24hodinová / 12hodinová
| minuta | `m` / `mm` | `5` / `05` <small>(2 číslice v kombinaci se sekundami)</small>
| sekunda | `s` / `ss` | `8` / `08` <small>(2 číslice v kombinaci s minutami)</small>

Pořadí kódů ve formátu nemá vliv na pořadí složek ve výstupu, protože to se řídí zvyklostmi národního prostředí. Formát je tedy na něm nezávislý. Například formát `yyyyMMMMd` v prostředí `en_US` vypíše `April 15, 2024`, zatímco v prostředí `cs_CZ` vypíše `15. dubna 2024`:

| locale: | cs_CZ | en_US
|---
| `format: 'dMy'` | 10. 8. 2024 | 8/10/2024
| `format: 'yM'` | 8/2024 | 8/2024
| `format: 'yyyyMMMM'` | srpen 2024 | August 2024
| `format: 'MMMM'` | srpen | August
| `format: 'jm'` | 17:22 | 5:22 PM
| `format: 'Hm'` | 17:22 | 17:22
| `format: 'hm'` | 5:22 odp. | 5:22 PM


**b) použití přednastavených stylů**

Parametry `date` a `time` určují úroveň podrobnosti pro výpis data a času. K dispozici jsou úrovně: `full`, `long`, `medium`, `short`. Můžete nechat vypsat jen datum, jen čas, nebo obojí:

| locale: | cs_CZ | en_US
|---
| `date: short` | 23.01.78 | 1/23/78
| `date: medium` | 23. 1. 1978 | Jan 23, 1978
| `date: long` | 23. ledna 1978 | January 23, 1978
| `date: full` | pondělí 23. ledna 1978 | Monday, January 23, 1978
| `time: short` | 8:30 | 8:30 AM
| `time: medium` | 8:30:59 | 8:30:59 AM
| `time: long` | 8:30:59 SEČ | 8:30:59 AM GMT+1
| `date: short, time: short` | 23.01.78 8:30 | 1/23/78, 8:30 AM
| `date: medium, time: short` | 23. 1. 1978 8:30 | Jan 23, 1978, 8:30 AM
| `date: long, time: short` | 23. ledna 1978 v 8:30 | January 23, 1978 at 8:30 AM

Pro datum lze použít prefix `relative-` (např. `relative-short`), který pro data blízká současnosti zobrazí `včera`, `dnes` nebo `zítra`, jinak se vypíše standardním způsobem.

```latte
{$date|localDate: date: relative-short}    {* včera *}
```

Viz také [#date].


lower .[filter]
---------------
Filtr `lower` převede řetězec na malá písmena. Vyžaduje PHP rozšíření `mbstring`.

```latte
{='LATTE'|lower}   {* vypíše 'latte' *}
```

Viz také [#capitalize], [#firstUpper], [#upper].


nocheck .[filter]
-----------------
Filtr `nocheck` vypne automatickou kontrolu URL adresy. Latte standardně [kontroluje |safety-first#Kontrola odkazů], zda proměnná obsahuje webovou URL (tj. protokol HTTP/HTTPS) a brání vypsání potenciálně nebezpečných odkazů.

Pokud odkaz používá jiné schéma, např. `javascript:` nebo `data:`, a jste si jisti jeho obsahem, můžete kontrolu vypnout pomocí `|nocheck`.

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

<a href={$link}>kontrolované</a>
<a href={$link|nocheck}>nekontrolované</a>
```

Výstup:

```latte
<a href="">kontrolované</a>
<a href="javascript:window.close()">nekontrolované</a>
```

Viz také [#checkUrl].


noescape .[filter]
------------------
Filtr `noescape` vypne automatické escapování.

```latte
{var $trustedHtmlString = '<b>hello</b>'}
Escapovaný: {$trustedHtmlString}
Neescapovaný: {$trustedHtmlString|noescape}
```

Výstup:

```latte
Escapovaný: &lt;b&gt;hello&lt;/b&gt;
Neescapovaný: <b>hello</b>
```

.[warning]
Nesprávné použití filtru `noescape` může vést ke zranitelnosti XSS! Používejte jej pouze tehdy, když si jste **naprosto jisti**, že vypisovaný řetězec pochází z důvěryhodného zdroje.


number(int $decimals=0, string $decPoint='.', string $thousandsSep=',') .[filter]
---------------------------------------------------------------------------------
Filtr `number` formátuje číslo na zadaný počet desetinných míst. Pokud je nastaveno [národní prostředí |develop#locale], použijí se odpovídající oddělovače desetinných míst a tisíců.

```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]
--------------------------------
Parametr `format` umožňuje přesně definovat vzhled čísel podle vašich potřeb. K tomu je nutné mít nastavené [národní prostředí |develop#locale]. Formát se skládá z několika speciálních znaků, jejichž kompletní popis najdete v dokumentaci "DecimalFormat":https://unicode.org/reports/tr35/tr35-numbers.html#Number_Format_Patterns:

- `0` povinná číslice, vždy se zobrazí, i kdyby to byla nula
- `#` volitelná číslice, zobrazí se jen tehdy, pokud na tomto místě číslo skutečně je
- `@` významná číslice, pomáhá zobrazit číslo s určitým počtem platných číslic
- `.` označuje pozici desetinné čárky (nebo tečky, podle země)
- `,` slouží k oddělení skupin číslic, nejčastěji tisíců
- `%` číslo vynásobí 100× a přidá znak procenta

Podívejme se na příklady. V prvním příkladu jsou dvě desetinná místa povinná, ve druhém volitelná. Třetí příklad ukazuje doplnění nulami zleva i zprava, čtvrtý zobrazuje jen existující číslice:

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

Významné číslice určují, kolik číslic bez ohledu na desetinnou čárku má být zobrazeno, přičemž dochází k zaokrouhlování:

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

Snadný způsob, jak zobrazit číslo jako procenta. Číslo se vynásobí 100× a přidá se znak `%`:

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

Můžeme definovat odlišný formát pro kladná a záporná čísla, oddělené znakem `;`. Tímto způsobem lze například nastavit, že kladná čísla se mají zobrazovat se znaménkem `+`:

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

Nezapomeňte, že skutečný vzhled čísel se může lišit podle nastavení země. Například v některých zemích se používá čárka místo tečky jako oddělovač desetinných míst. Tento filtr to automaticky zohlední, takže se o to nemusíte starat.


padLeft(int $length, string $pad=' ') .[filter]
-----------------------------------------------
Filtr `padLeft` doplní řetězec zleva na požadovanou délku jiným řetězcem.

```latte
{='hello'|padLeft: 10, '123'}  {* vypíše '12312hello' *}
```


padRight(int $length, string $pad=' ') .[filter]
------------------------------------------------
Filtr `padRight` doplní řetězec zprava na požadovanou délku jiným řetězcem.

```latte
{='hello'|padRight: 10, '123'}  {* vypíše 'hello12312' *}
```


query .[filter]
---------------
Filtr `query` dynamicky generuje query string v URL:

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

Výstup:

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

Klíče s hodnotou `null` se vynechají.

Viz také [#escapeUrl].


random .[filter]
----------------
Filtr `random` vrací náhodný prvek pole nebo náhodný znak řetězce:

```latte
{=[1, 2, 3, 4]|random}    {* vypíše např.: 3 *}
{='abcd'|random}          {* vypíše např.: 'b' *}
```

Viz také [#first], [#last].


repeat(int $count) .[filter]
----------------------------
Filtr `repeat` opakuje řetězec zadaný počet krát.

```latte
{='hello'|repeat: 3}  {* vypíše 'hellohellohello' *}
```


replace(string|array $search, string $replace='') .[filter]
-----------------------------------------------------------
Filtr `replace` nahradí všechny výskyty hledaného řetězce náhradním řetězcem.

```latte
{='hello world'|replace: 'world', 'friend'}  {* vypíše 'hello friend' *}
```

Lze provést i více záměn najednou:

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


replaceRE(string $pattern, string $replace='') .[filter]
--------------------------------------------------------
Filtr `replaceRE` provádí nahrazování podle regulárních výrazů.

```latte
{='hello world'|replaceRE: '/l.*/', 'l'}  {* vypíše 'hel' *}
```


reverse .[filter]
-----------------
Filtr `reverse` obrátí pořadí znaků v řetězci nebo prvků v poli.

```latte
{var $s = 'Nette'}
{$s|reverse}    {* vypíše 'etteN' *}
{var $a = ['N', 'e', 't', 't', 'e']}
{$a|reverse}    {* vrátí ['e', 't', 't', 'e', 'N'] *}
```


round(int $precision=0) .[filter]
---------------------------------
Filtr `round` zaokrouhlí číslo na zadanou přesnost.

```latte
{=3.4|round}        {* vypíše 3      *}
{=3.5|round}        {* vypíše 4      *}
{=135.79|round:1}   {* vypíše 135.8  *}
{=135.79|round:3}   {* vypíše 135.79 *}
```

Viz také [#ceil], [#floor].


slice(int $start, ?int $length=null, bool $preserveKeys=false) .[filter]
------------------------------------------------------------------------
Filtr `slice` extrahuje část pole nebo řetězce.

```latte
{='hello'|slice: 1, 2}           {* vypíše 'el' *}
{=['a', 'b', 'c']|slice: 1, 2}   {* vypíše ['b', 'c'] *}
```

Tento filtr funguje jako funkce PHP `array_slice` pro pole nebo `mb_substr` pro řetězce s fallbackem na funkci `iconv_substr` v režimu UTF-8.

Pokud je `start` kladný, posloupnost začíná posunutá o tento počet od začátku pole/řetězce. Pokud je záporný, posloupnost začíná posunutá o tolik od konce.

Pokud je zadán parametr `length` a je kladný, posloupnost bude obsahovat tolik prvků. Pokud je do této funkce předán záporný parametr `length`, posloupnost bude obsahovat všechny prvky původního pole, začínající na pozici `start` a končící na pozici menší o `length` prvků od konce pole. Pokud tento parametr nezadáte, posloupnost bude obsahovat všechny prvky původního pole, začínající pozicí `start`.

Ve výchozím nastavení filtr změní pořadí a resetuje celočíselné klíče pole. Toto chování lze změnit nastavením `preserveKeys` na true. Řetězcové klíče jsou vždy zachovány, bez ohledu na tento parametr.


sort(?Closure $comparison, string|int|\Closure|null $by=null, string|int|\Closure|bool $byKey=false) .[filter]
--------------------------------------------------------------------------------------------------------------
Filtr `sort` seřadí prvky pole nebo iterátoru a zachová jejich asociační klíče. Při nastaveném [národním prostředí |develop#locale] se řazení řídí jeho pravidly, pokud není specifikována vlastní porovnávací funkce.

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

Pro řazení pole v opačném pořadí:

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

Můžete specifikovat vlastní porovnávací funkci pro řazení (příklad ukazuje, jak obrátit řazení od největší po nejmenší):

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

Filtr `|sort` také umožňuje řadit prvky podle klíčů:

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

Pokud potřebujete seřadit tabulku podle konkrétního sloupce, můžete použít parametr `by`. Hodnota `'name'` v ukázce určuje, že se bude řadit podle `$item->name` nebo `$item['name']`, v závislosti na tom, zda je `$item` objekt nebo pole:

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

Můžete také definovat callback funkci, která určí hodnotu, podle které se má řadit:

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

Stejným způsobem lze využít i parametr `byKey`.


spaceless .[filter]
-------------------
Filtr `spaceless` odstraní nadbytečné bílé znaky z výstupu. Můžete také použít alias `strip`.

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

Výstup:

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


stripHtml .[filter]
-------------------
Filtr `stripHtml` převádí HTML na čistý text. Odstraní HTML značky a převede HTML entity na jejich textovou reprezentaci.

```latte
{='<p>one &lt; two</p>'|stripHtml}  {* vypíše 'one < two' *}
```

Výsledný čistý text může přirozeně obsahovat znaky, které představují HTML značky, například `'&lt;p&gt;'|stripHtml` se převede na `<p>`. V žádném případě nevypisujte takto vzniklý text s `|noescape`, protože to může vést ke vzniku bezpečnostní díry.


substr(int $offset, ?int $length=null) .[filter]
------------------------------------------------
Filtr `substr` extrahuje část řetězce. Tento filtr byl nahrazen filtrem [#slice].

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


translate(string $message, ...$args) .[filter]
----------------------------------------------
Filtr `translate` překládá výrazy do jiných jazyků. Aby byl filtr k dispozici, je potřeba [nastavit překladač|develop#TranslatorExtension]. Můžete také použít [tagy pro překlad|tags#Překlady].

```latte
<a href="basket">{='Košík'|translate}</a>
<span>{$item|translate}</span>
```


trim(string $charlist=" \t\n\r\0\x0B\u{A0}") .[filter]
------------------------------------------------------
Filtr `trim` odstraní bílé znaky (nebo jiné zadané znaky) od začátku a konce řetězce.

```latte
{='  I like Latte.  '|trim}    {* vypíše 'I like Latte.' *}
{='  I like Latte.'|trim: '.'} {* vypíše '  I like Latte' *}
```


truncate(int $length, string $append='…') .[filter]
---------------------------------------------------
Filtr `truncate` zkrátí řetězec na uvedenou maximální délku, přičemž se snaží zachovávat celá slova. Pokud dojde ke zkrácení řetězce, přidá nakonec trojtečku (lze změnit druhým parametrem).

```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]
---------------
Filtr `upper` převede řetězec na velká písmena. Vyžaduje PHP rozšíření `mbstring`.

```latte
{='latte'|upper}  {* vypíše 'LATTE' *}
```

Viz také [#capitalize], [#firstUpper], [#lower].


webalize .[filter]
------------------
Filtr `webalize` upraví UTF-8 řetězec do tvaru používaného v URL.

Převádí znaky na ASCII ekvivalenty. Převádí mezery na pomlčky. Odstraní znaky, které nejsou alfanumerické, podtržítka ani pomlčky. Převádí text na malá písmena. Také odstraní úvodní a koncové bílé znaky.

```latte
{var $s = 'Náš 10. produkt'}
{$s|webalize}   {* vypíše 'nas-10-produkt' *}
```

.[caution]
Vyžaduje knihovnu [nette/utils|utils:].