Latte Filters
*************

.[perex]
Filters are functions that change or format the data to a form we want. This is summary of the built-in filters which are available.

.[table-latte-filters]
|## String / array transformation
| `batch`      | [listing linear data in a table |#batch]
| `breakLines` | [Inserts HTML line breaks before all newlines |#breakLines]
| `bytes`      | [formats size in bytes |#bytes]
| `clamp`      | [clamps value to the range |#clamp]
| `dataStream` | [Data URI protocol conversion |#datastream]
| `date`       | [formats the date and time|#date]
| `explode`    | [splits a string by the given delimiter |#explode]
| `first`      | [returns first element of array or character of string |#first]
| `group`      | [groups data according to various criteria |#group]
| `implode`    | [joins an array to a string |#implode]
| `indent`     | [indents the text from left with number of tabs |#indent]
| `join`       | [joins an array to a string |#implode]
| `last`       | [returns last element of array or character of string |#last]
| `length`     | [returns length of a string or array |#length]
| `localDate`  | [formats the date and time according to the locale|#localDate]
| `number`     | [formats number |#number]
| `padLeft`    | [completes the string to given length from left |#padLeft]
| `padRight`   | [completes the string to given length from right |#padRight]
| `random`     | [returns random element of array or character of string |#random]
| `repeat`     | [repeats the string |#repeat]
| `replace`    | [replaces all occurrences of the search string with the replacement |#replace]
| `replaceRE`  | [replaces all occurrences according to regular expression |#replaceRE]
| `reverse`    | [reverses an UTF‑8 string or array |#reverse]
| `slice`      | [extracts a slice of an array or a string |#slice]
| `sort`       | [sorts an array |#sort]
| `spaceless`  | [removes whitespace |#spaceless], similar to [spaceless |tags] tag
| `split`      | [splits a string by the given delimiter |#explode]
| `strip`      | [removes whitespace |#spaceless]
| `stripHtml`  | [removes HTML tags and converts HTML entities to text |#stripHtml]
| `substr`     | [returns part of the string |#substr]
| `trim`       | [strips whitespace from the string |#trim]
| `translate`  | [translation into other languages |#translate]
| `truncate`   | [shortens the length preserving whole words |#truncate]
| `webalize`   | [adjusts the UTF‑8 string to the shape used in the URL |#webalize]

.[table-latte-filters]
|## Letter casing
| `capitalize` | [lower case, the first letter of each word upper case |#capitalize]
| `firstUpper` | [makes the first letter upper case |#firstUpper]
| `lower`      | [makes a string lower case |#lower]
| `upper`      | [makes a string upper case |#upper]

.[table-latte-filters]
|## Rounding numbers
| `ceil`       | [rounds a number up to a given precision |#ceil]
| `floor`      | [rounds a number down to a given precision |#floor]
| `round`      | [rounds a number to a given precision |#round]

.[table-latte-filters]
|## Escaping
| `escapeUrl`  | [escapes parameter in URL |#escapeUrl]
| `noescape`   | [prints a variable without escaping |#noescape]
| `query`      | [generates a query string in the URL |#query]

There are also escaping filters for HTML (`escapeHtml` and `escapeHtmlComment`), XML (`escapeXml`), JavaScript (`escapeJs`), CSS (`escapeCss`) and iCalendar (`escapeICal`), which Latte uses itself thanks to [context-aware escaping |safety-first#Context-aware escaping] and you do not need to write them.

.[table-latte-filters]
|## Security
| `checkUrl`   | [sanitizes string for use inside href attribute |#checkUrl]
| `nocheck`    | [prevents automatic URL sanitization |#nocheck]

Latte the `src` and `href` attributes [checks automatically |safety-first#link checking], so you almost don't need to use the `checkUrl` filter.


.[note]
All built-in filters work with UTF‑8 encoded strings.


Usage
=====

Latte allows calling filters by using the pipe sign notation (preceding space is allowed):

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

Filters can be chained, in that case they apply in order from left to right:

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

Parameters are put after the filter name separated by colon or comma:

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

Filters can be applied on expression:

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

[Custom filters|extending-latte#filters] can be registered this way:

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

We use it in a template like this:

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


Filters
=======


batch(int $length, mixed $item): array .[filter]
------------------------------------------------
Filter that simplifies the listing of linear data in the form of a table. It returns an array of array with the given number of items. If you provide a second parameter this is used to fill up missing items on the last row.

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

Prints:

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

See also [group |#group] and [iterateWhile |tags#iterateWhile] tag.


breakLines .[filter]
--------------------
Inserts HTML line breaks before all newlines.

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


bytes(int $precision=2) .[filter]
---------------------------------
Formats the size in bytes into a human-readable form. If the [locale |develop#locale] is set, the corresponding decimal and thousand separators are used.

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


ceil(int $precision=0) .[filter]
--------------------------------
Rounds a number up to a given precision.

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

See also [#floor], [#round].


capitalize .[filter]
--------------------
Returns a title-cased version of the value. Words will start with uppercase letters, all remaining characters are lowercase. Requires PHP extension `mbstring`.

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

See also [#firstUpper], [#lower], [#upper].


checkUrl .[filter]
------------------
Enforces URL sanitization. It checks if the variable contains a web URL (ie. HTTP/HTTPS protocol) and prevents the writing of links that may pose a security risk.

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

Prints:

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

See also [#nocheck].


clamp(int|float $min, int|float $max) .[filter]
-----------------------------------------------
Returns value clamped to the inclusive range of min and max.

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

Also exists as [function|functions#clamp].


dataStream(string $mimetype=detect) .[filter]
---------------------------------------------
Converts the content to data URI scheme. It can be used to insert images into HTML or CSS without the need to link external files.

Lets have an image in a variable `$img = Image::fromFile('obrazek.gif')`, then

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

Prints for example:

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

.[caution]
Requires PHP extension `fileinfo`.


date(string $format) .[filter]
------------------------------
Formats the date and time according to the mask used by the PHP function [php:date]. The filter accepts the date in UNIX timestamp format, as a string, or as a `DateTimeInterface` object.

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

See also [#localDate].


escapeUrl .[filter]
-------------------
Escapes a variable to be used as a parameter in URL.

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

See also [#query].


explode(string $separator='') .[filter]
---------------------------------------
Splits a string by the given delimiter and returns an array of strings. Alias for `split`.

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

If the delimiter is an empty string (default value), the input will be divided into individual characters:

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

You can use also alias `split`:

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

See also [#implode].


first .[filter]
---------------
Returns the first element of array or character of string:

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

See also [#last], [#random].


floor(int $precision=0) .[filter]
---------------------------------
Rounds a number down to a given precision.

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

See also [#ceil], [#round].


firstUpper .[filter]
--------------------
Converts a first letter of value to uppercase. Requires PHP extension `mbstring`.

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

See also [#capitalize], [#lower], [#upper].


group(string|int|\Closure $by): array .[filter]{data-version:3.0.16}
--------------------------------------------------------------------
The filter groups the data according to different criteria.

In this example, the rows in the table are grouped by the column `categoryId`. The output is an array of arrays where the key is the value in the column `categoryId`. Read the [detailed instructions |cookbook/grouping].

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

See also [batch |#batch], the [group |functions#group] function, and the [iterateWhile |tags#iterateWhile] tag.


implode(string $glue='') .[filter]
----------------------------------
Return a string which is the concatenation of the strings in the array. Alias for `join`.

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

You can also use an alias `join`:

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


indent(int $level=1, string $char="\t") .[filter]
-------------------------------------------------
Indents a text from left by a given number of tabs or other characters which we specify in the second optional argument. Blank lines are not indented.

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

Prints:

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


last .[filter]
--------------
Returns the last element of array or character of string:

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

See also [#first], [#random].


length .[filter]
----------------
Returns length of a string or array.

- for strings, it will return length in UTF‑8 characters
- for arrays, it will return count of items
- for objects that implement the Countable interface, it will use the return value of the count()
- for objects that implement the IteratorAggregate interface, it will use the return value of the iterator_count()


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


localDate(?string $format=null, ?string $date=null, ?string $time=null) .[filter]
---------------------------------------------------------------------------------
Formats date and time according to the [locale |develop#locale], ensuring consistent and localized display of time data across different languages and regions. The filter accepts the date as a UNIX timestamp, string, or `DateTimeInterface` object.

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

If you use the filter without any parameters, it will output the date in the long format level, as explained further.

**a) Using the format**

The `format` parameter describes which time components should be displayed. It uses letter codes, where the number of repetitions affects the width of the output:

| Year | `y` / `yy` / `yyyy` | `2024` / `24` / `2024`
| Month | `M` / `MM` / `MMM` / `MMMM` | `8` / `08` / `Aug` / `August`
| Day | `d` / `dd` / `E` / `EEEE` |  `1` / `01` / `Sun` / `Sunday`
| Hour | `j` / `H` / `h` | preferred / 24-hour / 12-hour
| Minute | `m` / `mm` | `5` / `05` <small>(2 digits when combined with seconds)</small>
| Second | `s` / `ss` | `8` / `08` <small>(2 digits when combined with minutes)</small>

The order of the codes in the format doesn’t matter, as the order of components will be displayed according to the locale's conventions. Therefore, the format is locale-independent. For example, the format `yyyyMMMMd` in the `en_US` locale outputs `April 15, 2024`, while in the `cs_CZ` locale it outputs `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) Using preset styles**

The `date` and `time` parameters determine the level of detail for the date and time display. You can choose from several levels: `full`, `long`, `medium`, `short`. You can display just the date, just the time, or both:

| 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

For the date, you can also use the prefix `relative-` (e.g., `relative-short`), which for dates close to the present will display `yesterday`, `today`, or `tomorrow`; otherwise, it will display in the standard way.

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

See also [#date].


lower .[filter]
---------------
Converts a value to lowercase. Requires PHP extension `mbstring`.

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

See also [#capitalize], [#firstUpper], [#upper].


nocheck .[filter]
-----------------
Prevents automatic URL sanitization. Latte [automatically checks|safety-first#Link checking] if the variable contains a web URL (ie. HTTP/HTTPS protocol) and prevents the writing of links that may pose a security risk.

If the link uses a different scheme, such as `javascript:` or `data:`, and you are sure of its contents, you can disable the check via `|nocheck`.

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

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

Prints:

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

See also [#checkUrl].


noescape .[filter]
------------------
Disables automatic escaping.

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

Prints:

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

.[warning]
Misuse of the `noescape` filter can lead to an XSS vulnerability! Never use it unless you are **absolutely sure** what you are doing and that the string you are printing comes from a trusted source.


number(int $decimals=0, string $decPoint='.', string $thousandsSep=',') .[filter]
---------------------------------------------------------------------------------
Formats a number to a specified number of decimal places. If the [locale |develop#locale] is set, the corresponding decimal and thousand separators are used.

```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]
--------------------------------
The `format` parameter allows you to define the appearance of numbers exactly according to your needs. It requires a set [locale |develop#locale]. The format consists of several special characters, the complete description of which can be found in the "DecimalFormat":https://unicode.org/reports/tr35/tr35-numbers.html#Number_Format_Patterns documentation:

- `0` mandatory digit, always displayed even if it's zero
- `#` optional digit, displayed only if the number has a digit in that place
- `@` significant digit, helps to display the number with a certain number of significant digits
- `.` marks where the decimal separator should be (comma or dot, depending on the locale)
- `,` used to separate groups of digits, usually thousands
- `%` multiplies the number by 100 and adds the percent sign

Let's look at some examples. In the first example, two decimal places are mandatory; in the second, they are optional. The third example shows padding with zeros on both sides, and the fourth displays only the existing digits:

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

Significant digits determine how many digits, regardless of the decimal point, should be displayed, rounding the number if necessary:

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

An easy way to display a number as a percentage. The number is multiplied by 100 and the `%` sign is added:

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

We can define a different format for positive and negative numbers, separated by a `;` character. This way, for example, positive numbers can be displayed with a `+` sign:

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

Remember that the actual appearance of numbers may vary depending on the locale settings. For example, in some countries, a comma is used instead of a dot as a decimal separator. This filter automatically accounts for this, so you don't need to worry about it.


padLeft(int $length, string $pad=' ') .[filter]
-----------------------------------------------
Pads a string to a certain length with another string from left.

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


padRight(int $length, string $pad=' ') .[filter]
------------------------------------------------
Pads a string to a certain length with another string from right.

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


query  .[filter]
----------------
Dynamically generates a query string in the 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>
```

Prints:

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

Keys with a value of `null` are omitted.

See also [#escapeUrl].


random .[filter]
----------------
Returns random element of array or character of string:

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

See also [#first], [#last].


repeat(int $count) .[filter]
----------------------------
Repeats the string x-times.

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


replace(string|array $search, string $replace='') .[filter]
-----------------------------------------------------------
Replaces all occurrences of the search string with the replacement string.

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

Multiple replacements can be made at once:

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


replaceRE(string $pattern, string $replace='') .[filter]
--------------------------------------------------------
Replaces all occurrences according to regular expression.

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


reverse .[filter]
-----------------
Reverses given string or array.

```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]
---------------------------------
Rounds a number to a given precision.

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

See also [#ceil], [#floor].


slice(int $start, ?int $length=null, bool $preserveKeys=false) .[filter]
------------------------------------------------------------------------
Extracts a slice of an array or a string.

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

The slice filter works as the `array_slice` PHP function for arrays and `mb_substr` for strings with a fallback to `iconv_substr` in UTF‑8 mode.

If the start is non-negative, the sequence will start at that start in the variable. If start is negative, the sequence will start that far from the end of the variable.

If length is given and is positive, then the sequence will have up to that many elements in it. If the variable is shorter than the length, then only the available variable elements will be present. If length is given and is negative then the sequence will stop that many elements from the end of the variable. If it is omitted, then the sequence will have everything from offset up until the end of the variable.

Filter will reorder and reset the integer array keys by default. This behaviour can be changed by setting preserveKeys to true. String keys are always preserved, regardless of this parameter.


sort(?Closure $comparison, string|int|\Closure|null $by=null, string|int|\Closure|bool $byKey=false) .[filter]
--------------------------------------------------------------------------------------------------------------
The filter sorts elements of an array or iterator while preserving their associative keys. When a [locale |develop#locale] is set, the sorting follows its rules unless a custom comparison function is specified.

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

Array sorted in reverse order.

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

You can specify a custom comparison function for sorting (the example shows how to reverse the sort from largest to smallest):

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

The `|sort` filter also allows you to sort elements by key:

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

If you need to sort a table by a specific column, you can use the `by` parameter. The value `'name'` in the example specifies that sorting will be done by `$row->name` or `$row['name']`, depending on whether `$row` is an array or an object:

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

You can also define a callback function that determines the value to sort by:

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

The `byKey` parameter can be used in the same way.


spaceless  .[filter]
--------------------
Removes unnecessary whitespace from the output. You can also use alias `strip`.

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

Prints:

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


stripHtml .[filter]
-------------------
Converts HTML to plain text. That is, it removes HTML tags and converts HTML entities to text.

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

The resulting plain text can naturally contain characters that represent HTML tags, for example `'&lt;p&gt;'|stripHtml` is converted to `<p>`. Never output the resulting text with `|noescape`, as this may lead to a security vulnerability.


substr(int $offset, ?int $length=null) .[filter]
------------------------------------------------
Extracts a slice of a string. This filter has been replaced by a [#slice] filter.

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


translate(string $message, ...$args) .[filter]
----------------------------------------------
It translates expressions into other languages. To make the filter available, you need [set up translator|develop#TranslatorExtension]. You can also use the [tags for translation|tags#Translation].

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


trim(string $charlist=" \t\n\r\0\x0B\u{A0}") .[filter]
------------------------------------------------------
Strip leading and trailing characters, by default whitespace.

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


truncate(int $length, string $append='…') .[filter]
---------------------------------------------------
Shortens a string to the maximum given length but tries to preserve whole words. If the string is truncated it adds ellipsis at the end (this can be changed by the second parameter).

```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]
---------------
Converts a value to uppercase. Requires PHP extension `mbstring`.

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

See also [#capitalize], [#firstUpper], [#lower].


webalize .[filter]
------------------
Converts to ASCII.

Converts spaces to hyphens. Removes characters that aren’t alphanumerics, underscores, or hyphens. Converts to lowercase. Also strips leading and trailing whitespace.

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

.[caution]
Requires package [nette/utils|utils:].