Филтри за Latte
***************

.[perex]
Филтрите са функции, които променят или форматират данните в желаната от нас форма. Това е кратко описание на наличните вградени филтри.

.[table-latte-filters]
|## Конвертиране на редове/масиви
| `batch` | [линейно изброяване на данни в таблица |#batch]
| `breakLines` | [вмъква прекъсвания на редове в HTML преди всички нови редове |#breakLines]
| `bytes` | [форматира размера в байтове |#bytes]
| `clamp` | [ограничава стойността до определен диапазон |#clamp]
| `dataStream` | [Конвертиране на протокола за данни URI |#dataStream]
| `date` | [форматиране на датата и часа |#date]
| `explode` | [разделя низа с даден разделител |#explode]
| `first` | [връща първия елемент на масив или символен низ |#first]
| `group` | [групиране на данни по различни критерии |#group]
| `implode` | [свързва масива с низ |#implode]
| `indent` | [отстъпи на текста наляво с броя на табулаторите |#indent]
| `join` | [обединяване на масив в низ |#implode]
| `last` | [връща последния елемент на масив или символен низ |#last]
| `length` | [връща дължината на низ или масив |#length]
| `localDate` | [форматиране на датата и часа в съответствие с местността |#localDate]
| `number` | [форматира число |#number]
| `padLeft` | [допълва низа вляво |#padLeft]
| `padRight` | [допълва низа до зададена дължина надясно |#padRight]
| `random` | [връща произволен елемент от масив или символен низ |#random]
| `repeat` | [повтаря символния низ |#repeat]
| `replace` | [замества всички срещания на търсения низ със заместител |#replace]
| `replaceRE` | [замества всички срещания в съответствие с регулярен израз |#replaceRE]
| `reverse` | [инвертира низ или масив във формат UTF-8 |#reverse]
| `slice` | [извлича масив или фрагмент от низ |#slice]
| `sort` | [сортира масива |#sort]
| `spaceless` | [изтрива символите за бял интервал |#spaceless], като тага [без интервал |tags]
| `split` | [разделя низ по зададен разделител |#explode]
| `strip` | [изтриване на бели интервали |#spaceless]
| `stripHtml` | [изтрива HTML тагове и преобразува HTML обекти в текст |#stripHtml]
| `substr` | [връща част от низ |#substr]
| `trim` | [изтрива интервалите от символния низ |#trim]
| `translate` | [превод на други езици |#translate]
| `truncate` | [съкращава дължината, като запазва цели думи |#truncate]
| `webalize` | [прави така, че низът UTF-8 |#webalize] да [съответства на формата, използвана в URL адреса |#webalize]

.[table-latte-filters]
|## Азбучен регистър
| `capitalize` | [малки букви, първата буква на всяка дума е главна |#capitalize]
| `firstUpper` | [прави първата буква главна |#firstUpper]
| `lower` | [прави реда малък |#lower]
| `upper` | [прави реда главен |#upper]

.[table-latte-filters]
|## Закръгляне на числата
| `ceil` | [закръгляне на число до определена точност |#ceil]
| `floor` | [закръгляне на числото до определена точност|#floor]
| `round` | [закръгляне на число с определена точност|#round]

.[table-latte-filters]
|## ескейпинг
| `escapeUrl` | [изстъргва параметъра в URL адреса |#escapeUrl]
| `noescape` |00 | [отпечатва променливата без ескейпване |#noescape]
| `query` | [формира низ за заявка в URL адреса |#query]

Съществуват и филтри за ескапиране за HTML (`escapeHtml` и `escapeHtmlComment`), XML (`escapeXml`), JavaScript (`escapeJs`), CSS (`escapeCss`) и iCalendar (`escapeICal`), които Latte използва сам благодарение на [контекстно-осъзнатото ескапиране |safety-first#Context-aware escaping] и не е необходимо да ги пишете.

.[table-latte-filters]
|## Сигурност
| `checkUrl` | [дезинфекцира символния низ, който ще се използва в атрибута href |#checkUrl]
| `nocheck` | [предотвратява автоматичната обработка на URL |#nocheck]

Latte [проверява |safety-first#Link-Checking] атрибутите `src` и `href` [автоматично |safety-first#Link-Checking], така че почти не е необходимо да използвате филтъра `checkUrl`.


.[note]
Всички вградени филтри работят с низове, кодирани в UTF-8.


Употреба .[#toc-usage]
======================

Latte позволява извикване на филтри чрез използване на знака за тръба (позволен е предхождащ интервал):

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

Филтрите могат да бъдат верижно свързани, като в този случай се прилагат в ред от ляво на дясно:

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

Параметрите се поставят след името на филтъра, разделени с двоеточие или запетая:

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

Филтрите могат да се прилагат върху изрази:

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

[Потребителски филтри |extending-latte#filters] могат да бъдат регистрирани по този начин:

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

Използваме го в шаблон по следния начин:

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


Филтри .[#toc-filters]
======================


batch(int $length, mixed $item): array .[filter]
------------------------------------------------
Филтър, който опростява изписването на линейни данни под формата на таблица. Връща масив от масиви със зададения брой елементи. Ако предоставите втори параметър, той се използва за попълване на липсващите елементи на последния ред.

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

Отпечатва:

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

Вижте също таговете [group |#group] и [iterateWhile |tags#iterateWhile].


breakLines .[filter]
--------------------
Вмъква прекъсванията на HTML редове преди всички нови редове.

```latte
{var $s = "Text & with \n newline"}
{$s|breakLines}    {* списъци "Text & with <br>\n newline" *}
```


bytes(int $precision=2) .[filter]
---------------------------------
Форматира размера в байтове в удобна за четене от човека форма. Ако е зададена [локална среда |develop#locale], се използват съответните десетични и хилядни разделители.

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


ceil(int $precision=0) .[filter]
--------------------------------
Закръгляне на число до зададена точност.

```latte
{=3.4|ceil}         {* изходи 4 *}
{=135.22|ceil:1}    {* изходи 135.3 *}
{=135.22|ceil:3}    {* изходи 135.22 *}
```

Вижте също [floor |#floor], [round |#round].


capitalize .[filter]
--------------------
Връща версия на стойността, изписана със заглавие. Думите започват с главни букви, а всички останали символи са малки. Изисква PHP разширение `mbstring`.

```latte
{='i like LATTE'|capitalize} {* списъци 'I Like Latte' *}
```

Вижте също [firstUpper |#firstUpper], [lower |#lower], [upper |#upper].


checkUrl .[filter]
------------------
Принуждава URL адреса да се почиства. Той проверява дали променливата съдържа уеб URL адрес (т.е. протокол HTTP/HTTPS) и предотвратява записването на връзки, които могат да представляват риск за сигурността.

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

Отпечатва:

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

Вижте също [nocheck |#nocheck].


clamp(int|float $min, int|float $max) .[filter]
-----------------------------------------------
Връща стойността, която е вкарана в обхват от min и max.

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

Съществува и като [clamp |functions#clamp].


dataStream(string $mimetype=detect) .[filter]
---------------------------------------------
Конвертира съдържанието в схема URI за данни. Може да се използва за вмъкване на изображения в HTML или CSS, без да е необходимо да се свързват външни файлове.

Нека имаме изображение в променлива `$img = Image::fromFile('obrazek.gif')`, тогава

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

Отпечатва например:

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

.[caution]
Изисква PHP разширение `fileinfo`.


date(string $format) .[filter]
------------------------------
Форматира датата и часа в съответствие с маската, използвана от функцията на PHP [php:date]. Филтърът приема датата във формат UNIX timestamp, като низ или като обект `DateTimeInterface`.

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

Вижте също [localDate |#localDate].


escapeUrl .[filter]
-------------------
Избягва променлива, която да се използва като параметър в URL.

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

Вижте също [query |#query].


explode(string $separator='') .[filter]
---------------------------------------
Разделя низ по зададения разделител и връща масив от низове. Псевдоним за `split`.

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

Ако разделителят е празен низ (стойност по подразбиране), входът ще бъде разделен на отделни символи:

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

Можете да използвате и псевдонима `split`:

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

Вижте също [implode |#implode].


first .[filter]
---------------
Връща първия елемент от масив или символ от низ:

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

Вижте също [last |#last], [random |#random].


floor(int $precision=0) .[filter]
---------------------------------
Закръгляне на число до зададена точност.

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

Вижте също [ceil |#ceil], [round |#round].


firstUpper .[filter]
--------------------
Преобразува първата буква на стойността в главна буква. Изисква PHP разширение `mbstring`.

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

Вижте също [capitalize |#capitalize], [lower |#lower], [upper |#upper].


group(string|int|\Closure $by): array .[filter]{data-version:3.0.16}
--------------------------------------------------------------------
Филтърът групира данните по различни критерии.

В този пример редовете в таблицата са групирани по колоната `categoryId`. Изходът е масив от масиви, където ключът е стойността в колоната `categoryId`. Прочетете [подробните инструкции |cookbook/grouping].

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

Вижте също [batch |#batch], функцията [group |functions#group] и маркера [iterateWhile |tags#iterateWhile].


implode(string $glue='') .[filter]
----------------------------------
Връща низ, който е конкатенация на низовете в масива. Псевдоним за `join`.

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

Можете също така да използвате псевдонима `join`:

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


indent(int $level=1, string $char="\t") .[filter]
-------------------------------------------------
Отстъпва текста отляво с даден брой табулации или други символи, които посочваме във втория незадължителен аргумент. Празните редове не се отдръпват.

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

Отпечатва:

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


last .[filter]
--------------
Връща последния елемент от масив или символ от низ:

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

Вижте също [first |#first], [random |#random].


length .[filter]
----------------
Връща дължината на низ или масив.

- За низове връща дължина в UTF-8 символи.
- за масиви ще върне броя на елементите.
- за обекти, които имплементират интерфейса Countable, ще се използва върнатата стойност на функцията count()
- за обекти, които реализират интерфейса IteratorAggregate, ще се използва върнатата стойност на iterator_count()


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


localDate(?string $format=null, ?string $date=null, ?string $time=null) .[filter]
---------------------------------------------------------------------------------
Форматира датата и часа в зависимост от [локала, |develop#locale] като осигурява последователно и локализирано показване на данните за времето на различни езици и региони. Филтърът приема датата като времеви печат на UNIX, низ или обект `DateTimeInterface`.

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

Ако използвате филтъра без никакви параметри, той ще изведе датата на ниво дълъг формат, както е обяснено по-нататък.

**а) Използване на формата**

Параметърът `format` описва кои компоненти на времето трябва да се показват. Той използва буквени кодове, при които броят на повторенията влияе на ширината на изхода:

| Година | `y` / `yy` / `yyyy` | `2024` / `24` / `2024`
| Месец | `M` / `MM` / `MMM` / `MMMM` | `8` / `08` / `08` / `август`
| Ден | `d` / `dd` / `E` / `EEEE` | `1` / `01` / `нд` / `неделя`
| Час | `j` / `H` / `h` | предпочитан / 24-часов / 12-часов
| Минута | `m` / `mm` | `5` / `05` <small>(2 цифри, когато се комбинира със секунди)</small>
| Секунда | `s` / `ss` | `8` / `08` <small>(2 цифри, когато се комбинират с минути)</small>

Редът на кодовете във формата няма значение, тъй като редът на компонентите ще бъде показан в съответствие с конвенциите на локала. Следователно форматът е независим от локала. Например, форматът `yyyyMMMMd` в локала `en_US` извежда `April 15, 2024`, докато в локала `cs_CZ` извежда `15. dubna 2024`:

| locale:  | bg-BG | en_US
|---
| `format: 'dMy'` | 10.08.2024 г. | 8/10/2024
| `format: 'yM'` | 08.2024 г. | 8/2024
| `format: 'yyyyMMMM'` | август 2024 г. | August 2024
| `format: 'MMMM'` | август | August
| `format: 'jm'` | 17:54 ч. | 5:54 PM
| `format: 'Hm'` | 17:54 ч. | 17:54
| `format: 'hm'` | 5:54 ч. сл.об. | 5:54 PM


**б) Използване на предварително зададени стилове**

Параметрите `date` и `time` определят нивото на детайлност за показване на датата и часа. Можете да избирате от няколко нива: `full`, `long`, `medium`, `short`. Можете да показвате само датата, само часа или и двете:

| locale:  | bg-BG | en_US
|---
| `date: short` | 23.01.78 г. | 1/23/78
| `date: medium` | 23.01.1978 г. | Jan 23, 1978
| `date: long` | 23 януари 1978 г. | January 23, 1978
| `date: full` | понеделник, 23 януари 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 ч. Гринуич+1 | 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.01.1978 г., 8:30 ч. | Jan 23, 1978, 8:30 AM
| `date: long, time: short` | 23 януари 1978 г. в 8:30 ч. | January 23, 1978 at 8:30 AM

За датата можете да използвате и префикса `relative-` (например `relative-short`), който за дати, близки до настоящата, ще покаже `yesterday`, `today` или `tomorrow`; в противен случай ще се покаже по стандартния начин.

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

Вижте също [дата |#date].


lower .[filter]
---------------
Преобразува стойността в малки букви. Изисква PHP разширение `mbstring`.

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

Вижте също [capitalize |#capitalize], [firstUpper |#firstUpper], [upper |#upper].


nocheck .[filter]
-----------------
Предотвратява автоматичното почистване на URL адреси. Latte [автоматично проверява |safety-first#Link checking] дали променливата съдържа уеб URL адрес (т.е. протокол HTTP/HTTPS) и предотвратява записването на връзки, които могат да представляват риск за сигурността.

Ако връзката използва друга схема, например `javascript:` или `data:`, и сте сигурни в нейното съдържание, можете да деактивирате проверката чрез `|nocheck`.

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

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

Отпечатъци:

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

Вижте също [checkUrl |#checkUrl].


noescape .[filter]
------------------
Деактивира автоматичното ескапиране.

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

Отпечатва:

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

.[warning]
Злоупотребата с филтъра `noescape` може да доведе до уязвимост XSS! Никога не го използвайте, освен ако не сте **напълно сигурни** какво правите и че низът, който отпечатвате, идва от надежден източник.


number(int $decimals=0, string $decPoint='.', string $thousandsSep=',') .[filter]
---------------------------------------------------------------------------------
Форматира число до определен брой знаци след десетичната запетая. Ако е зададена [локална среда |develop#locale], се използват съответните разделители за десетични знаци и хиляди.

```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]
--------------------------------
Параметърът `format` ви позволява да определите външния вид на числата точно според вашите нужди. Той изисква зададена [локализация |develop#locale]. Форматът се състои от няколко специални знака, чието пълно описание можете да намерите в документацията на "DecimalFormat"::https://unicode.org/reports/tr35/tr35-numbers.html#Number_Format_Patterns

- <c id=6/> задължителна цифра, която винаги се показва, дори ако е нула
- `#` незадължителна цифра, показва се само ако числото има цифра на това място
- `@` значима цифра, помага за показване на числото с определен брой значими цифри
- `.` маркира мястото, където трябва да се намира десетичният разделител (запетая или точка, в зависимост от локала)
- `,` се използва за разделяне на групи от цифри, обикновено хиляди
- `%` умножава числото по 100 и добавя знака за процент

Нека разгледаме някои примери. В първия пример двата знака след десетичната запетая са задължителни; във втория те не са задължителни. Третият пример показва попълване с нули от двете страни, а четвъртият показва само съществуващите цифри:

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

Значимите цифри определят колко цифри, независимо от десетичната запетая, трябва да бъдат показани, като при необходимост числото се закръгля:

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

Лесен начин за показване на дадено число като процент. Числото се умножава по 100 и се добавя знакът `%`:

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

Можем да дефинираме различен формат за положителни и отрицателни числа, разделени със знака `;`. По този начин например положителните числа могат да се показват със знака `+`:

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

Не забравяйте, че действителният вид на числата може да се различава в зависимост от настройките на локала. Например в някои страни като десетичен разделител се използва запетая вместо точка. Този филтър автоматично отчита това, така че не е необходимо да се притеснявате за него.


padLeft(int $length, string $pad=' ') .[filter]
-----------------------------------------------
Попълва низ с определена дължина с друг низ отляво.

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


padRight(int $length, string $pad=' ') .[filter]
------------------------------------------------
Подвежда низ до определена дължина с друг низ отдясно.

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


query  .[filter]
----------------
Динамично генерира низ за заявка в 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>
```

Отпечатва:

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

Ключовете със стойност `null` се изпускат.

Вижте също [escapeUrl |#escapeUrl].


random .[filter]
----------------
Връща произволен елемент от масив или символ от низ:

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

Вижте също [first |#first], [last |#last].


repeat(int $count) .[filter]
----------------------------
Повтаря символния низ х пъти.

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


replace(string|array $search, string $replace='') .[filter]
-----------------------------------------------------------
Заменя всички срещания на търсения низ със заместващия низ.

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

Могат да бъдат извършени няколко замени едновременно:

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


replaceRE(string $pattern, string $replace='') .[filter]
--------------------------------------------------------
Заменя всички срещания според регулярен израз.

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


reverse .[filter]
-----------------
Обръща даден низ или масив.

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


round(int $precision=0) .[filter]
---------------------------------
Закръгляне на число до зададена точност.

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

Вижте също [таван, |#ceil] [етаж |#floor].


slice(int $start, ?int $length=null, bool $preserveKeys=false) .[filter]
------------------------------------------------------------------------
Извлича част от масив или низ.

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

Филтърът за парчета работи като функцията на PHP `array_slice` за масиви и `mb_substr` за низове с отпадане на `iconv_substr` в режим UTF-8.

Ако началото е неотрицателно, последователността ще започне от това начало в променливата. Ако стартът е отрицателен, последователността ще започне на това разстояние от края на променливата.

Ако е зададена дължина и тя е положителна, последователността ще има до толкова елемента в нея. Ако променливата е по-къса от дължината, тогава ще има само наличните елементи на променливата. Ако е зададена дължина и тя е отрицателна, последователността ще спре на толкова елемента от края на променливата. Ако тя е пропусната, последователността ще съдържа всичко от отместването до края на променливата.

По подразбиране Filter ще пренареди и нулира ключовете на целочислените масиви. Това поведение може да бъде променено чрез задаване на стойност preserveKeys на true. Ключовете на низове винаги се запазват, независимо от този параметър.


sort(?Closure $comparison, string|int|\Closure|null $by=null, string|int|\Closure|bool $byKey=false) .[filter]
--------------------------------------------------------------------------------------------------------------
Филтърът сортира елементите на масив или итератор, като запазва асоциативните им ключове. Когато е зададен [локал |develop#locale], сортирането следва неговите правила, освен ако не е зададена потребителска функция за сравнение.

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

Масивът се подрежда в обратен ред.

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

Можете да зададете потребителска функция за сравнение за сортиране (примерът показва как да обърнете сортирането от най-голям към най-малък):

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

Филтърът `|sort` също така ви позволява да сортирате елементите по ключ:

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

Ако трябва да сортирате таблица по определена колона, можете да използвате параметъра `by`. Стойността `'name'` в примера указва, че сортирането ще се извършва по `$row->name` или `$row['name']`, в зависимост от това дали `$row` е масив или обект:

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

Можете също така да дефинирате функция за обратно извикване, която определя стойността, по която да се сортира:

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

Параметърът `byKey` може да се използва по същия начин.


spaceless  .[filter]
--------------------
Премахва ненужните бели полета от изхода. Можете също така да използвате псевдонима `strip`.

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

Отпечатва:

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


stripHtml .[filter]
-------------------
Конвертира HTML в обикновен текст. Това означава, че премахва HTML таговете и преобразува HTML единиците в текст.

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

Полученият обикновен текст естествено може да съдържа символи, които представляват HTML тагове, например `'&lt;p&gt;'|stripHtml` се преобразува в `<p>`. Никога не извеждайте получения текст с `|noescape`, тъй като това може да доведе до уязвимост на сигурността.


substr(int $offset, ?int $length=null) .[filter]
------------------------------------------------
Извлича част от низ. Този филтър е заменен с филтър за [парчета |#slice].

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


translate(string $message, ...$args) .[filter]
----------------------------------------------
Той превежда изрази на други езици. За да направите филтъра достъпен, трябва да настроите [преводач |develop#TranslatorExtension]. Можете също така да използвате [таговете за превод |tags#Translation].

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


trim(string $charlist=" \t\n\r\0\x0B\u{A0}") .[filter]
------------------------------------------------------
Премахване на водещи и завършващи символи, по подразбиране бяло пространство.

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


truncate(int $length, string $append='…') .[filter]
---------------------------------------------------
Съкращава даден низ до максимално зададената дължина, но се опитва да запази цели думи. Ако низът е съкратен, той добавя елипса в края (това може да се промени с втория параметър).

```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]
---------------
Преобразува стойността в главни букви. Изисква PHP разширение `mbstring`.

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

Вижте също [capitalize |#capitalize], [firstUpper |#firstUpper], [lower |#lower].


webalize .[filter]
------------------
Преобразува в ASCII.

Превръща интервалите в тирета. Премахва знаци, които не са буквено-цифрови, подчертаващи или дефисни. Преобразува в малки букви. Също така премахва началните и крайните бели полета.

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

.[caution]
Изисква пакет [nette/utils |utils:].