Filtri za latte
***************

.[perex]
Filtri so funkcije, ki spremenijo ali oblikujejo podatke v želeno obliko. To je povzetek vgrajenih filtrov, ki so na voljo.

.[table-latte-filters]
|## Preoblikovanje nizov / polj
| `batch` | [izpis linearnih podatkov v tabeli |#batch]
| `breakLines` | [Vstavi prelome vrstic HTML pred vse nove vrstice |#breakLines]
| `bytes` | [oblikuje velikost v bajtih |#bytes]
| `clamp` | [vpne vrednost v območje |#clamp]
| `dataStream` | [Pretvorba protokola URI podatkov |#datastream]
| `date` | [oblikuje datum |#date]
| `explode` | [razdeli niz z danim ločilom |#explode]
| `first` | [vrne prvi element polja ali znak niza |#first]
| `implode` | [združi polje z nizom |#implode]
| `indent` | [besedilo z leve strani odriva s številom tabulatorjev |#indent]
| `join` | [združi polje z nizom |#implode]
| `last` | [vrne zadnji element polja ali znak niza |#last]
| `length` | [vrne dolžino niza ali polja |#length]
| `number` | [oblikovanje števila |#number]
| `padLeft` | [dopolni niz do dane dolžine z leve |#padLeft]
| `padRight` | [dopolni niz do dane dolžine od desne |#padRight]
| `random` | [vrne naključni element polja ali znak niza |#random]
| `repeat` | [ponovi niz |#repeat]
| `replace` | [nadomesti vse pojavitve iskanega niza z zamenjavo |#replace]
| `replaceRE` | [nadomesti vse pojavitve v skladu z regularnim izrazom |#replaceRE]
| `reverse` | [obrne niz ali polje UTF-8 |#reverse]
| `slice` | [izvleče rezino polja ali niza |#slice]
| `sort` | [razvrsti polje |#sort]
| `spaceless` | [odstrani bele presledke |#spaceless], podobno kot pri oznaki [brez presledkov |tags]
| `split` | [razdeli niz z danim ločilom |#explode]
| `strip` | [odstrani bele prostore |#spaceless]
| `stripHtml` | [odstrani oznake HTML in pretvori entitete HTML v besedilo |#stripHtml]
| `substr` | [vrne del niza |#substr]
| `trim` | [odstrani bele prostore iz niza |#trim]
| `translate` | [prevajanje v druge jezike |#translate]
| `truncate` | [skrajša dolžino, pri čemer ohrani cele besede |#truncate]
| `webalize` | [prilagodi niz UTF-8 obliki, ki se uporablja v naslovu URL |#webalize]

.[table-latte-filters]
|### Oblikovanje črk
| `capitalize` | [male črke, prva črka vsake besede velika črka |#capitalize]
| `firstUpper` | [prva črka je velika |#firstUpper]
| `lower` | [niz postane mala črka|#lower]
| `upper` | [spremeni niz v velike črke |#upper]

.[table-latte-filters]
|## Zaokroževanje številk
| `ceil` | [zaokroži število do določene natančnosti |#ceil]
| `floor` | [zaokroži število navzdol na določeno natančnost |#floor]
| `round` | [zaokroži število na določeno natančnost |#round]

.[table-latte-filters]
|### Escaping
| `escapeUrl` | [pobegne parameter v naslovu URL |#escapeUrl]
| `noescape` | [natisne spremenljivko brez umika |#noescape]
| `query` | [ustvari poizvedbeni niz v naslovu URL |#query]

Na voljo so tudi filtri za eskapiranje za HTML (`escapeHtml` in `escapeHtmlComment`), XML (`escapeXml`), JavaScript (`escapeJs`), CSS (`escapeCss`) in iCalendar (`escapeICal`), ki jih Latte uporablja sam zaradi [kontekstnega eskapiranja |safety-first#Context-aware escaping] in vam jih ni treba pisati.

.[table-latte-filters]
|## Varnost
| `checkUrl` | [odpravi niz za uporabo znotraj atributa href |#checkUrl]
| `nocheck` | [preprečuje samodejno čiščenje URL |#nocheck]

Latte atributa `src` in `href` [preverja samodejno |safety-first#link checking], zato vam skoraj ni treba uporabljati filtra `checkUrl`.


.[note]
Vsi vgrajeni filtri delujejo z nizi, kodiranimi v UTF-8.


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

Latte omogoča klicanje filtrov z uporabo zapisa z znakom pipe (pred njim je dovoljen presledek):

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

Filtri se lahko verižijo, v tem primeru se uporabljajo po vrstnem redu od leve proti desni:

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

Parametri so navedeni za imenom filtra, ločeni z dvopičjem ali vejico:

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

Filtre je mogoče uporabiti na izrazu:

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

[Filtre po meri |extending-latte#filters] je mogoče registrirati na ta način:

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

Uporabimo ga v predlogi, kot je ta:

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


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


batch(int length, mixed item): array .[filter]
----------------------------------------------
Filter, ki poenostavi navajanje linearnih podatkov v obliki tabele. Vrne polje z danim številom elementov. Če navedete drugi parameter, se ta uporabi za dopolnitev manjkajočih elementov v zadnji vrstici.

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

Izpisuje:

```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]
--------------------
Pred vse nove vrstice vstavi prelome vrstic HTML.

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


bytes(int precision = 2) .[filter]
----------------------------------
Oblikuje velikost v bajtih v človeku berljivo obliko.

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


ceil(int precision = 0) .[filter]
---------------------------------
Zaokroži število do določene natančnosti.

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

Glej tudi [floor |#floor], [round |#round].


capitalize .[filter]
--------------------
Vrne različico vrednosti, ki je označena z naslovi. Besede se začnejo z velikimi črkami, vsi preostali znaki so mali. Zahteva razširitev PHP `mbstring`.

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

Glej tudi [firstUpper |#firstUpper], [lower |#lower], [upper |#upper].


checkUrl .[filter]
------------------
Uveljavlja čiščenje URL-jev. Preveri, ali spremenljivka vsebuje spletni naslov URL (tj. protokol HTTP/HTTPS), in prepreči zapis povezav, ki bi lahko predstavljale varnostno tveganje.

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

Izpisuje:

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

Glej tudi [nocheck |#nocheck].


clamp(int|float min, int|float max) .[filter]
---------------------------------------------
Vrne vrednost, ki je omejena na vključujoče območje min in max.

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

Obstaja tudi kot [funkcija |functions#clamp].


dataStream(string mimetype = detect) .[filter]
----------------------------------------------
Pretvori vsebino v podatkovno shemo URI. Uporablja se lahko za vstavljanje slik v HTML ali CSS, ne da bi bilo treba povezovati zunanje datoteke.

Imejmo sliko v spremenljivki `$img = Image::fromFile('obrazek.gif')`, potem

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

natisne na primer:

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

.[caution]
Zahteva razširitev PHP `fileinfo`.


date(string format) .[filter]
-----------------------------
Vrne datum v danem formatu z uporabo možnosti funkcij PHP [php:strftime] ali [php:date]. Filter dobi datum kot časovni žig UNIX, niz ali objekt tipa `DateTime`.

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


escapeUrl .[filter]
-------------------
Izbriše spremenljivko, ki se uporabi kot parameter v naslovu URL.

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

Glej tudi [poizvedbo |#query].


explode(string separator = '') .[filter]
----------------------------------------
Razdeli niz z danim ločilom in vrne polje nizov. Vzdevek za `split`.

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

Če je ločilo prazen niz (privzeta vrednost), se vhodni niz razdeli na posamezne znake:

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

Uporabite lahko tudi vzdevek `split`:

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

Glej tudi [implode |#implode].


first .[filter]
---------------
Vrne prvi element polja ali znak niza:

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

Glej tudi [last |#last], [random |#random].


floor(int precision = 0) .[filter]
----------------------------------
Zaokroži število do določene natančnosti.

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

Glejte tudi [strop |#ceil], [zaokrožitev |#round].


firstUpper .[filter]
--------------------
Prvo črko vrednosti pretvori v veliko črko. Zahteva razširitev PHP `mbstring`.

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

Oglejte si tudi [velika začetnica |#capitalize], [mala |#lower] [začetnica |#capitalize], [velika |#upper] začetnica.


implode(string glue = '') .[filter]
-----------------------------------
Vrne niz, ki je sestavljen iz nizov v polju. Vzdevek za `join`.

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

Uporabite lahko tudi vzdevek `join`:

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


indent(int level = 1, string char = "\t") .[filter]
---------------------------------------------------
Odmakne besedilo od leve strani za določeno število tabulatorjev ali drugih znakov, ki jih določimo v drugem neobveznem argumentu. Prazne vrstice se ne odrivajo.

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

Natisne:

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


last .[filter]
--------------
Vrne zadnji element polja ali znak niza:

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

Glej tudi [first |#first], [random |#random].


length .[filter]
----------------
Vrne dolžino niza ali polja.

- za nize vrne dolžino v znakih UTF-8
- za polja vrne število elementov
- za predmete, ki implementirajo vmesnik Countable, bo uporabil povratno vrednost funkcije count()
- za predmete, ki implementirajo vmesnik IteratorAggregate, uporabi povratno vrednost iterator_count()


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


lower .[filter]
---------------
Pretvori vrednost v male črke. Zahteva razširitev PHP `mbstring`.

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

Glej tudi [capitalize |#capitalize], [firstUpper |#firstUpper], [upper |#upper].


nocheck .[filter]
-----------------
Preprečuje samodejno prečiščevanje URL. Latte [samodejno preveri, |safety-first#Link checking] ali spremenljivka vsebuje spletni naslov URL (tj. protokol HTTP/HTTPS), in prepreči zapis povezav, ki bi lahko predstavljale varnostno tveganje.

Če povezava uporablja drugo shemo, na primer `javascript:` ali `data:`, in ste prepričani o njeni vsebini, lahko preverjanje onemogočite prek `|nocheck`.

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

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

Izpisi:

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

Glej tudi [checkUrl |#checkUrl].


noescape .[filter]
------------------
Onemogoči samodejno izrivanje.

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

Natisne:

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

.[warning]
Zloraba filtra `noescape` lahko privede do ranljivosti XSS! Nikoli ga ne uporabljajte, razen če ste **trdno prepričani**, kaj počnete in da niz, ki ga tiskate, prihaja iz zaupanja vrednega vira.


number(int decimals = 0, string decPoint = '.', string thousandsSep = ',') .[filter]
------------------------------------------------------------------------------------
Oblikuje število na določeno število decimalnih mest. Določite lahko tudi znak za decimalno vejico in ločilo tisočic.

```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]
-----------------------------------------------
Podaljša niz do določene dolžine z drugim nizom z leve.

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


padRight(int length, string pad = ' ') .[filter]
------------------------------------------------
Podloži niz na določeno dolžino z drugim nizom z desne.

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


query  .[filter]
----------------
Dinamično ustvari poizvedbeni niz v naslovu 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>
```

Natisne:

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

Ključi z vrednostjo `null` so izpuščeni.

Glej tudi [escapeUrl |#escapeUrl].


random .[filter]
----------------
Vrne naključni element polja ali znak niza:

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

Glej tudi [first |#first], [last |#last].


repeat(int count) .[filter]
---------------------------
Ponovi niz x-krat.

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


replace(string|array search, string replace = '') .[filter]
-----------------------------------------------------------
Zamenja vse pojavitve iskanega niza z nadomestnim nizom.

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

Izvede se lahko več zamenjav naenkrat:

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


replaceRE(string pattern, string replace = '') .[filter]
--------------------------------------------------------
Zamenja vse pojavitve v skladu z regularnim izrazom.

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


reverse .[filter]
-----------------
Obrne dani niz ali polje.

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


round(int precision = 0) .[filter]
----------------------------------
Zaokroži število na določeno natančnost.

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

Glej tudi [strop |#ceil], [dno |#floor].


slice(int start, int length = null, bool preserveKeys = false) .[filter]
------------------------------------------------------------------------
Izvleče rezino polja ali niza.

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

Filter rezine deluje kot funkcija PHP `array_slice` za polja in `mb_substr` za nize s povratno funkcijo `iconv_substr` v načinu UTF-8.

Če je začetek nenegativen, se zaporedje v spremenljivki začne s tem začetkom. Če je start negativen, se zaporedje začne tako daleč od konca spremenljivke.

Če je podana dolžina in je pozitivna, bo imelo zaporedje do toliko elementov. Če je spremenljivka krajša od dolžine, bodo prisotni samo razpoložljivi elementi spremenljivke. Če je podana dolžina in je negativna, se bo zaporedje ustavilo toliko elementov od konca spremenljivke. Če je dolžina izpuščena, bo zaporedje vsebovalo vse od odmika do konca spremenljivke.

Filter bo privzeto spremenil vrstni red in ponastavil ključe celoštevilskega polja. To obnašanje lahko spremenite z nastavitvijo vrednosti preserveKeys na true. Vrstični ključi se vedno ohranijo, ne glede na ta parameter.


sort  .[filter]
---------------
Filter, ki razvrsti polje in ohrani povezavo indeksov.

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

Polje je razvrščeno v obratnem vrstnem redu.

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

Kot parameter lahko posredujete svojo primerjalno funkcijo:

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


spaceless  .[filter]
--------------------
Odstrani nepotrebne bele lise iz izpisa. Uporabite lahko tudi vzdevek `strip`.

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

Natisne:

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


stripHtml .[filter]
-------------------
Pretvarja HTML v navadno besedilo. To pomeni, da odstrani oznake HTML in pretvori entitete HTML v besedilo.

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

Dobljeno navadno besedilo lahko seveda vsebuje znake, ki predstavljajo oznake HTML, na primer `'&lt;p&gt;'|stripHtml` se pretvori v `<p>`. Dobljenega besedila nikoli ne izpišite s `|noescape`, saj to lahko povzroči varnostno ranljivost.


substr(int offset, int length = null) .[filter]
-----------------------------------------------
Izvleče rezino niza. Ta filter je bil nadomeščen s filtrom za [rezine |#slice].

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


translate(string message, ...args) .[filter]
--------------------------------------------
Prevaja izraze v druge jezike. Če želite, da je filter na voljo, morate [nastaviti prevajalnik |develop#TranslatorExtension]. Za [prevajanje |tags#Translation] lahko uporabite tudi [oznake |tags#Translation].

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


trim(string charlist = " \t\n\r\0\x0B\u{A0}") .[filter]
-------------------------------------------------------
Odstrani vodilne in končne znake, privzeto beli prostor.

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


truncate(int length, string append = '…') .[filter]
---------------------------------------------------
Skrajša niz na največjo dovoljeno dolžino, vendar poskuša ohraniti cele besede. Če je niz skrajšan, na koncu doda elipso (to lahko spremenite z drugim parametrom).

```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]
---------------
Pretvori vrednost v velike črke. Zahteva razširitev PHP `mbstring`.

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

Glej tudi [capitalize |#capitalize], [firstUpper |#firstUpper], [lower |#lower].


webalize .[filter]
------------------
Pretvarja v ASCII.

Prevede presledke v pomišljaje. Odstrani znake, ki niso alfanumerični znaki, podčrtaji ali pomišljaji. Pretvarja v male črke. Odstrani tudi začetni in končni beli presledek.

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

.[caution]
Zahteva paket [nette/utils |utils:].