Nette Documentation Preview

syntax
Latte szűrők
************

.[perex]
A szűrők olyan függvények, amelyek megváltoztatják vagy formázzák az adatokat a kívánt formára. Ez az összefoglaló a rendelkezésre álló beépített szűrőkről.

.[table-latte-filters]
|## String / tömb átalakítás
| `batch` | [lineáris adatok listázása egy táblázatban |#batch]
| `breakLines` | [HTML sorkizárt beillesztése az újsorok előtt |#breakLines]
| `bytes` | [méretformázás bájtban |#bytes]
| `clamp` | [az értéket a tartományba szorítja |#clamp]
| `dataStream` | [Adat URI protokoll átalakítás |#datastream]
| `date` | [dátum és idő formázása |#date]
| `explode` | [a karakterláncot a megadott elválasztóval osztja fel |#explode]
| `first` | [visszaadja a tömb első elemét vagy a karakterlánc első karakterét |#first]
| `group` | [adatok csoportosítása különböző kritériumok |#group] szerint
| `implode` | [egy tömböt egy karakterlánccal kapcsol össze |#implode]
| `indent` | [a szöveget balról behúzza a tabulátorok számával |#indent]
| `join` | [egy tömböt egy karakterlánchoz kapcsol |#implode]
| `last` | [visszaadja a tömb utolsó elemét vagy a karakterlánc utolsó karakterét |#last]
| `length` | [egy karakterlánc vagy tömb hosszát adja vissza |#length]
| `localDate` | [A dátum és az idő formázása a helyi beállításoknak megfelelően |#localDate]
| `number` | [formázza a számot |#number]
| `padLeft` | [balról balra kiegészíti a karakterláncot a megadott hosszúságúra |#padLeft]
| `padRight` | [a stringet jobbról a megadott hosszúságra egészíti ki |#padRight]
| `random` | [visszaadja a tömb véletlenszerű elemét vagy a karakterlánc karakterét |#random]
| `repeat` | [megismétli a karakterláncot |#repeat]
| `replace` | [a keresett karakterlánc minden előfordulását helyettesíti a helyettesítő karakterlánccal |#replace]
| `replaceRE` | [az összes előfordulást a reguláris kifejezésnek megfelelően helyettesíti |#replaceRE]
| `reverse` | [megfordítja az UTF-8 karakterláncot vagy tömböt |#reverse]
| `slice` | [kivonja egy tömb vagy egy karakterlánc egy szeletét |#slice]
| `sort` | [rendezi a tömböt |#sort]
| `spaceless` | [eltávolítja a szóközöket |#spaceless], hasonlóan a [spaceless |tags] taghez
| `split` | [egy karakterláncot a megadott elválasztójel alapján szétválaszt |#explode]
| `strip` | [eltávolítja a szóközöket |#spaceless]
| `stripHtml` | [eltávolítja a HTML-címkéket és a HTML-elemeket szöveggé alakítja át |#stripHtml]
| `substr` | [visszaadja a karakterlánc egy részét |#substr]
| `trim` | [eltávolítja a szóközöket a karakterláncból |#trim]
| `translate` | [fordítás más nyelvekre |#translate]
| `truncate` | [lerövidíti a hosszúságot, megőrizve az egész szavakat |#truncate]
| `webalize` | [az UTF-8 karakterláncot az URL-ben használt formához igazítja |#webalize]

.[table-latte-filters]
|## Betűhüvelyezés
| `capitalize` | [kisbetűs, minden szó első betűje nagybetűs |#capitalize]
| `firstUpper` | [az első betűt nagybetűvé teszi |#firstUpper]
| `lower` | [a karakterláncot kisbetűvé teszi |#lower]
| `upper` | [nagybetűvé teszi a karakterláncot |#upper]

.[table-latte-filters]
|## Számok kerekítése
| `ceil` | [kerekít egy számot egy adott pontosságig |#ceil]
| `floor` | [Egy számot adott pontosságra kerekít lefelé |#floor]
| `round` | [kerekít egy számot adott pontosságra |#round]

.[table-latte-filters]
|## Escaping
| `escapeUrl` | [az URL-ben szereplő paramétert elrejti |#escapeUrl]
| `noescape` | [változó nyomtatása szaggatás nélkül |#noescape]
| `query` | [lekérdezési karakterláncot generál az URL-ben |#query]

A HTML (`escapeHtml` és `escapeHtmlComment`), XML (`escapeXml`), JavaScript (`escapeJs`), CSS (`escapeCss`) és iCalendar (`escapeICal`) számára is vannak escaping szűrők, amelyeket a Latte a [kontextustudatos escapingnek |safety-first#Context-aware escaping] köszönhetően maga használ, és nem kell megírni őket.

.[table-latte-filters]
|## Biztonság
| `checkUrl` | [szanálja a href attribútumon belül használt karakterláncot |#checkUrl]
| `nocheck` | [megakadályozza az automatikus URL-szanálást |#nocheck]

A `src` és a `href` attribútumokat [automatikusan ellenőrzi |safety-first#link checking], így a `checkUrl` szűrőt szinte nem is kell használni.


.[note]
Minden beépített szűrő UTF-8 kódolású karakterláncokkal működik.


Használat .[#toc-usage]
=======================

A Latte lehetővé teszi a szűrők hívását a pipajel jelölés használatával (az előző szóköz megengedett):

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

A szűrők láncolhatók, ebben az esetben balról jobbra haladva alkalmazandók:

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

A paraméterek a szűrő neve után kerülnek, kettősponttal vagy vesszővel elválasztva:

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

A szűrők kifejezésekre alkalmazhatók:

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

[Egyéni szűrők |extending-latte#filters] így regisztrálhatók:

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

Egy sablonban így használjuk:

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


Szűrők .[#toc-filters]
======================


batch(int $length, mixed $item): array .[filter]
------------------------------------------------
Szűrő, amely leegyszerűsíti a lineáris adatok táblázatos formában történő felsorolását. Egy tömb tömböt ad vissza a megadott számú elemmel. Ha megad egy második paramétert, akkor ezt az utolsó sor hiányzó elemeinek kitöltésére használja.

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

Nyomtatás:

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

Lásd még a [group |#group] és az [iterateWhile |tags#iterateWhile] címkét.


breakLines .[filter]
--------------------
HTML-sorszünetet illeszt be minden újsor előtt.

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


bytes(int $precision=2) .[filter]
---------------------------------
A bájtokban megadott méretet ember által olvasható formába formázza. Ha a [nyelvi tartomány |develop#locale] be van állítva, akkor a megfelelő tizedes és ezres elválasztójeleket használja.

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


ceil(int $precision=0) .[filter]
--------------------------------
Egy számot adott pontosságra kerekít.

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

Lásd még [floor |#floor], [round |#round].


capitalize .[filter]
--------------------
Visszaadja az érték címsoros változatát. A szavak nagybetűkkel kezdődnek, az összes többi karakter kisbetűs. PHP-bővítményt igényel: `mbstring`.

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

Lásd még [firstUpper |#firstUpper], [lower |#lower], [upper |#upper].


checkUrl .[filter]
------------------
Kényszeríti az URL szanálását. Ellenőrzi, hogy a változó tartalmaz-e webes URL-t (azaz HTTP/HTTPS protokollt), és megakadályozza a biztonsági kockázatot jelentő linkek írását.

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

Nyomtat:

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

Lásd [mégeck |#nocheck].


clamp(int|float $min, int|float $max) .[filter]
-----------------------------------------------
A min és max tartományba szorított értéket adja vissza.

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

Létezik [függvényként |functions#clamp] is.


dataStream(string $mimetype=detect) .[filter]
---------------------------------------------
A tartalmat adat URI-sémává alakítja át. Használható képek HTML- vagy CSS-be való beillesztésére anélkül, hogy külső fájlokat kellene linkelni.

Legyen egy kép egy változóban `$img = Image::fromFile('obrazek.gif')`, akkor

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

Kinyomtatja például:

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

.[caution]
PHP-bővítményt igényel: `fileinfo`.


date(string $format) .[filter]
------------------------------
A dátumot és az időt a [php:date] PHP-funkció által használt maszknak megfelelően formázza. A szűrő elfogadja a dátumot UNIX időbélyeg formátumban, sztringként vagy `DateTimeInterface` objektumként.

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

Lásd még [localDate |#localDate].


escapeUrl .[filter]
-------------------
Kikerül egy változót, amelyet URL-ben paraméterként kell használni.

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

Lásd még [query |#query].


explode(string $separator='') .[filter]
---------------------------------------
Egy karakterláncot a megadott elválasztójel alapján szétválaszt, és karakterláncok tömbjét adja vissza. Alias a `split` számára.

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

Ha az elválasztó üres karakterlánc (alapértelmezett érték), akkor a bemenet különálló karakterekre lesz felosztva:

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

Használhatja a `split` aliast is:

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

Lásd még: [implode |#implode].


first .[filter]
---------------
Visszaadja a tömb első elemét vagy a karakterlánc első karakterét:

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

Lásd még [last |#last], [random |#random].


floor(int $precision=0) .[filter]
---------------------------------
Egy számot adott pontosságra kerekít.

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

Lásd még [ceil |#ceil], [round |#round].


firstUpper .[filter]
--------------------
Az érték első betűjét nagybetűvé alakítja. PHP-bővítményt igényel `mbstring`.

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

Lásd még [nagybetű |#capitalize], [kisbetű |#lower], [nagybetű |#upper].


group(string|int|\Closure $by): array .[filter]{data-version:3.0.16}
--------------------------------------------------------------------
A szűrő különböző kritériumok szerint csoportosítja az adatokat.

Ebben a példában a táblázat sorai a `categoryId` oszlop alapján vannak csoportosítva. A kimenet egy tömb tömbökből álló tömb, ahol a kulcs a `categoryId` oszlopban szereplő érték. Olvassa el a [részletes utasításokat |cookbook/grouping].

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

Lásd még a [batch |#batch], a [group |functions#group] függvény és az [iterateWhile |tags#iterateWhile] tag.


implode(string $glue='') .[filter]
----------------------------------
Visszaad egy stringet, amely a tömbben lévő stringek összevonása. Alias a következőhöz: `join`.

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

A `join` alias is használható:

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


indent(int $level=1, string $char="\t") .[filter]
-------------------------------------------------
A szöveg balról történő behúzása egy adott számú tabulátorral vagy más karakterrel, amelyet a második választható argumentumban adunk meg. Az üres sorok nem kerülnek behúzásra.

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

Nyomtatás:

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


last .[filter]
--------------
Visszaadja a tömb utolsó elemét vagy a karakterlánc utolsó karakterét:

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

Lásd még [first |#first], [random |#random].


length .[filter]
----------------
Egy karakterlánc vagy tömb hosszát adja vissza.

- a stringek esetében UTF-8 karakterekben adja vissza a hosszúságot.
- tömbök esetén az elemek számát adja vissza.
- a Countable interfészt megvalósító objektumok esetében a count() visszatérési értékét használja.
- az IteratorAggregate interfészt megvalósító objektumok esetében az iterator_count() visszatérési értékét használja.


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


localDate(?string $format=null, ?string $date=null, ?string $time=null) .[filter]
---------------------------------------------------------------------------------
A dátum és az idő formázása a [nyelvterületnek |develop#locale] megfelelően, így biztosítva az időadatok konzisztens és lokalizált megjelenítését a különböző nyelveken és régiókban. A szűrő a dátumot UNIX időbélyegként, stringként vagy `DateTimeInterface` objektumként fogadja el.

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

Ha a szűrőt paraméterek nélkül használja, akkor a dátumot hosszú formátumban adja ki, ahogyan azt a továbbiakban kifejtjük.

**a) A formátum használata**

A `format` paraméter leírja, hogy mely időösszetevőket kell megjeleníteni. Betűkódokat használ, ahol az ismétlések száma befolyásolja a kimenet szélességét:

| Év | `y` / `yy` / `yyyy` | `2024` / `24` / `2024`
| Hónap | `M` / `MM` / `MMM` / `MMMM` | `8` / `08` / `aug.` / `augusztus`
| Nap | `d` / `dd` / `E` / `EEEE` | `1` / `01` / `V` / `vasárnap`
| Hour | `j` / `H` / `h` | preferred / 24-hour / 12-hour
| Perc | `m` / `mm` | `5` / `05` <small>(2 számjegy, ha másodpercekkel kombinálják)</small>
| Másodperc | `s` / `ss` | `8` / `08` <small>(2 számjegy, ha percekkel kombinálva)</small>

A kódok sorrendje a formátumban nem számít, mivel az összetevők sorrendje a helyi konvencióknak megfelelően jelenik meg. Ezért a formátum helytől független. Például a `yyyyMMMMd` formátum a `en_US` nyelvjárásban a `April 15, 2024`, míg a `cs_CZ` nyelvjárásban a `15. dubna 2024` formátumot adja ki:

| locale:  | hu-HU | en_US
|---
| `format: 'dMy'` | 2024. 08. 10. | 8/10/2024
| `format: 'yM'` | 2024. 8. | 8/2024
| `format: 'yyyyMMMM'` | 2024. augusztus | August 2024
| `format: 'MMMM'` | augusztus | August
| `format: 'jm'` | 17:54 | 5:54 PM
| `format: 'Hm'` | 17:54 | 17:54
| `format: 'hm'` | du. 5:54 | 5:54 PM


**b) Előre beállított stílusok használata**

A `date` és a `time` paraméterek határozzák meg a dátum és az idő megjelenítésének részletességét. Több szint közül választhat: `full`, `long`, `medium`, `short`. Megjelenítheti csak a dátumot, csak az időt vagy mindkettőt:

| locale:  | hu-HU | en_US
|---
| `date: short` | 1978. 01. 23. | 1/23/78
| `date: medium` | 1978. jan. 23. | Jan 23, 1978
| `date: long` | 1978. január 23. | January 23, 1978
| `date: full` | 1978. január 23., hétfő | 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 CET | 8:30:59 AM GMT+1
| `date: short, time: short` | 1978. 01. 23. 8:30 | 1/23/78, 8:30 AM
| `date: medium, time: short` | 1978. jan. 23. 8:30 | Jan 23, 1978, 8:30 AM
| `date: long, time: short` | 1978. január 23. 8:30 | January 23, 1978 at 8:30 AM

A dátumhoz használhatja a `relative-` előtagot is (pl. `relative-short`), amely a jelenhez közeli dátumok esetében a `yesterday`, `today` vagy `tomorrow`, egyébként a szokásos módon jelenik meg.

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

Lásd még [dátum |#date].


lower .[filter]
---------------
Egy értéket kisbetűvé alakít. PHP-bővítményt igényel `mbstring`.

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

Lásd még [capitalize |#capitalize], [firstUpper |#firstUpper], [upper |#upper].


nocheck .[filter]
-----------------
Megakadályozza az automatikus URL-szanálást. A Latte [automatikusan ellenőrzi |safety-first#Link checking], hogy a változó tartalmaz-e webes URL-t (azaz HTTP/HTTPS protokollt), és megakadályozza a biztonsági kockázatot jelentő linkek írását.

Ha a hivatkozás más sémát használ, például `javascript:` vagy `data:`, és biztos a tartalmában, akkor a `|nocheck` segítségével kikapcsolhatja az ellenőrzést.

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

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

Nyomtatások:

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

Lásd még [checkUrl |#checkUrl].


noescape .[filter]
------------------
Letiltja az automatikus escapinget.

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

Nyomtat:

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

.[warning]
A `noescape` szűrő visszaélése XSS sebezhetőséghez vezethet! Soha ne használja, hacsak nem **teljesen biztos** abban, hogy mit csinál, és hogy a nyomtatott karakterlánc megbízható forrásból származik.


number(int $decimals=0, string $decPoint='.', string $thousandsSep=',') .[filter]
---------------------------------------------------------------------------------
Egy számot a megadott számú tizedesjegyig formáz. Ha a [nyelvi terület |develop#locale] be van állítva, akkor a megfelelő tizedes és ezres elválasztójeleket használja.

```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]
--------------------------------
A `format` paraméter lehetővé teszi, hogy a számok megjelenését pontosan az Ön igényei szerint határozza meg. Beállított [nyelvterületet |develop#locale] igényel. A formátum több speciális karakterből áll, amelyek teljes leírása a "DecimalFormat":https://unicode.org/reports/tr35/tr35-numbers.html#Number_Format_Patterns dokumentációban található:

- <c id=6/> kötelező számjegy, mindig megjelenik, még akkor is, ha nulla.
- `#` opcionális számjegy, csak akkor jelenik meg, ha a számnak van számjegye az adott helyen.
- `@` szignifikáns számjegy, segít a számot bizonyos számú szignifikáns számjeggyel megjeleníteni.
- `.` a tizedesvessző helyét jelöli (vessző vagy pont, a területi adattól függően).
- `,` számjegycsoportok, általában ezrek elválasztására szolgál.
- `%` megszorozza a számot 100-zal, és hozzáadja a százalékjelet.

Nézzünk néhány példát. Az első példában a két tizedesjegy kötelező, a másodikban opcionális. A harmadik példa mindkét oldalon nullákkal való kitöltést mutat, a negyedik példa pedig csak a meglévő számjegyeket jeleníti meg:

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

A szignifikáns számjegyek határozzák meg, hogy a tizedesvesszőtől függetlenül hány számjegyet kell megjeleníteni, szükség esetén kerekítve a számot:

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

Egy szám százalékban történő megjelenítésének egyszerű módja. A számot megszorozzuk 100-zal, és hozzáadjuk a `%` jelet:

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

A pozitív és negatív számok számára eltérő formátumot határozhatunk meg, amelyet egy `;` karakterrel választunk el. Így például a pozitív számok a `+` jellel jeleníthetők meg:

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

Ne feledje, hogy a számok tényleges megjelenése a helyi beállításoktól függően változhat. Egyes országokban például pont helyett vesszőt használnak tizedesválasztóként. Ez a szűrő automatikusan figyelembe veszi ezt, így nem kell aggódnia emiatt.


padLeft(int $length, string $pad=' ') .[filter]
-----------------------------------------------
Egy adott hosszúságú karakterláncot balról egy másik karakterlánccal kitölti.

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


padRight(int $length, string $pad=' ') .[filter]
------------------------------------------------
Egy adott hosszúságú karakterláncot egy másik, jobbról jövő karakterlánccal kitölti.

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


query  .[filter]
----------------
Dinamikusan generál egy lekérdezési karakterláncot az URL-ben:

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

Nyomtat:

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

A `null` értékű kulcsok nem szerepelnek.

Lásd még [escapeUrl |#escapeUrl].


random .[filter]
----------------
Visszaadja a tömb véletlenszerű elemét vagy a karakterlánc karakterét:

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

Lásd még [first |#first], [last |#last].


repeat(int $count) .[filter]
----------------------------
Megismétli a karakterláncot x-szer.

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


replace(string|array $search, string $replace='') .[filter]
-----------------------------------------------------------
A keresett karakterlánc minden előfordulását helyettesítő karakterlánccal helyettesíti.

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

Egyszerre több csere is elvégezhető:

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


replaceRE(string $pattern, string $replace='') .[filter]
--------------------------------------------------------
Az összes előfordulást helyettesíti a reguláris kifejezésnek megfelelően.

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


reverse .[filter]
-----------------
Megfordítja a megadott karakterláncot vagy tömböt.

```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]
---------------------------------
Egy számot adott pontosságra kerekít.

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

Lásd még [ceil |#ceil], [floor |#floor].


slice(int $start, ?int $length=null, bool $preserveKeys=false) .[filter]
------------------------------------------------------------------------
Egy tömb vagy egy karakterlánc egy szeletének kivonása.

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

A slice-szűrő a `array_slice` PHP-funkcióként működik tömbök esetében, a `mb_substr` pedig karakterláncok esetében, UTF-8 módban a `iconv_substr` -re való visszalépéssel.

Ha a kezdet nem negatív, akkor a szekvencia a változóban ezzel a kezdőponttal kezdődik. Ha a start negatív, akkor a szekvencia a változó végétől ilyen messze kezdődik.

Ha a length értéke pozitív, akkor a szekvencia legfeljebb ennyi elemet tartalmaz. Ha a változó rövidebb, mint a hossz, akkor csak a rendelkezésre álló változóelemek lesznek jelen. Ha a hossz meg van adva és negatív, akkor a sorozat ennyi elemmel a változó vége előtt fog megállni. Ha nem adjuk meg, akkor a szekvencia az eltolódástól a változó végéig mindent tartalmazni fog.

A Filter alapértelmezés szerint átrendezi és visszaállítja az integer tömb kulcsát. Ez a viselkedés megváltoztatható a preserveKeys true értékre állításával. A string kulcsok ettől a paramétertől függetlenül mindig megmaradnak.


sort(?Closure $comparison, string|int|\Closure|null $by=null, string|int|\Closure|bool $byKey=false) .[filter]
--------------------------------------------------------------------------------------------------------------
A szűrő egy tömb vagy iterátor elemeit rendezi, miközben megőrzi az asszociatív kulcsokat. Ha egy [területi |develop#locale] beállítás van megadva, a rendezés annak szabályait követi, kivéve, ha egyéni összehasonlító függvény van megadva.

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

A tömb fordított sorrendbe rendezve.

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

Megadhat egy egyéni összehasonlító függvényt a rendezéshez (a példa azt mutatja, hogyan lehet a legnagyobbtól a legkisebbig megfordítani a rendezést):

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

A `|sort` szűrő lehetővé teszi az elemek kulcs szerinti rendezését is:

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

Ha egy táblázatot egy adott oszlop szerint kell rendezni, használhatja a `by` paramétert. A példában szereplő `'name'` érték azt adja meg, hogy a rendezés a `$row->name` vagy a szerint történjen. `$row['name']`, attól függően, hogy a `$row` egy tömb vagy egy objektum:

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

Meghatározhat egy visszahívási függvényt is, amely meghatározza a rendezés értékét:

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

A `byKey` paraméter ugyanígy használható.


spaceless  .[filter]
--------------------
Eltávolítja a felesleges szóközöket a kimenetből. Használhatod a `strip` aliast is.

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

Nyomtat:

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


stripHtml .[filter]
-------------------
A HTML-t egyszerű szöveggé alakítja. Vagyis eltávolítja a HTML-címkéket, és a HTML-egységeket szöveggé alakítja.

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

Az így kapott sima szöveg természetesen tartalmazhat olyan karaktereket, amelyek HTML-címkéket képviselnek, például a `'&lt;p&gt;'|stripHtml` átváltozik `<p>`. Soha ne adja ki az eredményül kapott szöveget a `|noescape` címmel, mivel ez biztonsági réshez vezethet.


substr(int $offset, ?int $length=null) .[filter]
------------------------------------------------
Kivonja egy karakterlánc egy szeletét. Ezt a szűrőt felváltotta a [slice |#slice] szűrő.

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


translate(...$args) .[filter]
-----------------------------
Kifejezéseket fordít le más nyelvekre. Ahhoz, hogy a szűrő elérhető legyen, be kell [állítania a fordítót |develop#TranslatorExtension]. A [címkéket |tags#Translation] is használhatja [a fordításhoz |tags#Translation].

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


trim(string $charlist=" \t\n\r\0\x0B\u{A0}") .[filter]
------------------------------------------------------
Vezető és követő karakterek eltávolítása, alapértelmezés szerint szóköz.

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


truncate(int $length, string $append='…') .[filter]
---------------------------------------------------
Rövidíti a karakterláncot a megadott maximális hosszúságra, de megpróbálja megőrizni az egész szavakat. Ha a karakterlánc csonkolva van, ellipszist ad a végére (ez a második paraméterrel módosítható).

```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]
---------------
Egy értéket nagybetűvé alakít. A `mbstring` PHP-bővítményt igényli.

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

Lásd még [capitalize |#capitalize], [firstUpper |#firstUpper], [lower |#lower].


webalize .[filter]
------------------
Átalakítja ASCII-re.

A szóközöket kötőjelekké alakítja. Eltávolítja a nem alfanumerikus karaktereket, aláhúzásokat vagy kötőjeleket. Átalakítja kisbetűvé. Eltávolítja a vezető és az utolsó szóközöket is.

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

.[caution]
Szükséges a [nette/utils |utils:] csomag.

Latte szűrők

A szűrők olyan függvények, amelyek megváltoztatják vagy formázzák az adatokat a kívánt formára. Ez az összefoglaló a rendelkezésre álló beépített szűrőkről.

String / tömb átalakítás
batch lineáris adatok listázása egy táblázatban
breakLines HTML sorkizárt beillesztése az újsorok előtt
bytes méretformázás bájtban
clamp az értéket a tartományba szorítja
dataStream Adat URI protokoll átalakítás
date dátum és idő formázása
explode a karakterláncot a megadott elválasztóval osztja fel
first visszaadja a tömb első elemét vagy a karakterlánc első karakterét
group adatok csoportosítása különböző kritériumok szerint
implode egy tömböt egy karakterlánccal kapcsol össze
indent a szöveget balról behúzza a tabulátorok számával
join egy tömböt egy karakterlánchoz kapcsol
last visszaadja a tömb utolsó elemét vagy a karakterlánc utolsó karakterét
length egy karakterlánc vagy tömb hosszát adja vissza
localDate A dátum és az idő formázása a helyi beállításoknak megfelelően
number formázza a számot
padLeft balról balra kiegészíti a karakterláncot a megadott hosszúságúra
padRight a stringet jobbról a megadott hosszúságra egészíti ki
random visszaadja a tömb véletlenszerű elemét vagy a karakterlánc karakterét
repeat megismétli a karakterláncot
replace a keresett karakterlánc minden előfordulását helyettesíti a helyettesítő karakterlánccal
replaceRE az összes előfordulást a reguláris kifejezésnek megfelelően helyettesíti
reverse megfordítja az UTF-8 karakterláncot vagy tömböt
slice kivonja egy tömb vagy egy karakterlánc egy szeletét
sort rendezi a tömböt
spaceless eltávolítja a szóközöket, hasonlóan a spaceless taghez
split egy karakterláncot a megadott elválasztójel alapján szétválaszt
strip eltávolítja a szóközöket
stripHtml eltávolítja a HTML-címkéket és a HTML-elemeket szöveggé alakítja át
substr visszaadja a karakterlánc egy részét
trim eltávolítja a szóközöket a karakterláncból
translate fordítás más nyelvekre
truncate lerövidíti a hosszúságot, megőrizve az egész szavakat
webalize az UTF-8 karakterláncot az URL-ben használt formához igazítja
Betűhüvelyezés
capitalize kisbetűs, minden szó első betűje nagybetűs
firstUpper az első betűt nagybetűvé teszi
lower a karakterláncot kisbetűvé teszi
upper nagybetűvé teszi a karakterláncot
Számok kerekítése
ceil kerekít egy számot egy adott pontosságig
floor Egy számot adott pontosságra kerekít lefelé
round kerekít egy számot adott pontosságra
Escaping
escapeUrl az URL-ben szereplő paramétert elrejti
noescape változó nyomtatása szaggatás nélkül
query lekérdezési karakterláncot generál az URL-ben

A HTML (escapeHtml és escapeHtmlComment), XML (escapeXml), JavaScript (escapeJs), CSS (escapeCss) és iCalendar (escapeICal) számára is vannak escaping szűrők, amelyeket a Latte a kontextustudatos escapingnek köszönhetően maga használ, és nem kell megírni őket.

Biztonság
checkUrl szanálja a href attribútumon belül használt karakterláncot
nocheck megakadályozza az automatikus URL-szanálást

A src és a href attribútumokat automatikusan ellenőrzi, így a checkUrl szűrőt szinte nem is kell használni.

Minden beépített szűrő UTF-8 kódolású karakterláncokkal működik.

Használat

A Latte lehetővé teszi a szűrők hívását a pipajel jelölés használatával (az előző szóköz megengedett):

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

A szűrők láncolhatók, ebben az esetben balról jobbra haladva alkalmazandók:

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

A paraméterek a szűrő neve után kerülnek, kettősponttal vagy vesszővel elválasztva:

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

A szűrők kifejezésekre alkalmazhatók:

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

Egyéni szűrők így regisztrálhatók:

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

Egy sablonban így használjuk:

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

Szűrők

batch (int $length, mixed $item)array

Szűrő, amely leegyszerűsíti a lineáris adatok táblázatos formában történő felsorolását. Egy tömb tömböt ad vissza a megadott számú elemmel. Ha megad egy második paramétert, akkor ezt az utolsó sor hiányzó elemeinek kitöltésére használja.

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

Nyomtatás:

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

Lásd még a group és az iterateWhile címkét.

breakLines

HTML-sorszünetet illeszt be minden újsor előtt.

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

bytes (int $precision=2)

A bájtokban megadott méretet ember által olvasható formába formázza. Ha a nyelvi tartomány be van állítva, akkor a megfelelő tizedes és ezres elválasztójeleket használja.

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

ceil (int $precision=0)

Egy számot adott pontosságra kerekít.

{=3.4|ceil}         {* kimenet 4 *}
{=135.22|ceil:1}    {* kimenet 135.3 *}
{=135.22|ceil:3}    {* kimenet 135.22 *}

Lásd még floor, round.

capitalize

Visszaadja az érték címsoros változatát. A szavak nagybetűkkel kezdődnek, az összes többi karakter kisbetűs. PHP-bővítményt igényel: mbstring.

{='i like LATTE'|capitalize} {* kimenet 'I Like Latte' *}

Lásd még firstUpper, lower, upper.

checkUrl

Kényszeríti az URL szanálását. Ellenőrzi, hogy a változó tartalmaz-e webes URL-t (azaz HTTP/HTTPS protokollt), és megakadályozza a biztonsági kockázatot jelentő linkek írását.

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

Nyomtat:

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

Lásd mégeck.

clamp (int|float $min, int|float $max)

A min és max tartományba szorított értéket adja vissza.

{$level|clamp: 0, 255}

Létezik függvényként is.

dataStream (string $mimetype=detect)

A tartalmat adat URI-sémává alakítja át. Használható képek HTML- vagy CSS-be való beillesztésére anélkül, hogy külső fájlokat kellene linkelni.

Legyen egy kép egy változóban $img = Image::fromFile('obrazek.gif'), akkor

<img src={$img|dataStream}>

Kinyomtatja például:

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

PHP-bővítményt igényel: fileinfo.

date (string $format)

A dátumot és az időt a date PHP-funkció által használt maszknak megfelelően formázza. A szűrő elfogadja a dátumot UNIX időbélyeg formátumban, sztringként vagy DateTimeInterface objektumként.

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

Lásd még localDate.

escapeUrl

Kikerül egy változót, amelyet URL-ben paraméterként kell használni.

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

Lásd még query.

explode (string $separator='')

Egy karakterláncot a megadott elválasztójel alapján szétválaszt, és karakterláncok tömbjét adja vissza. Alias a split számára.

{='one,two,three'|explode:','}    {* visszatér ['one', 'two', 'three'] *}

Ha az elválasztó üres karakterlánc (alapértelmezett érték), akkor a bemenet különálló karakterekre lesz felosztva:

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

Használhatja a split aliast is:

{='1,2,3'|split:','}              {* visszatér ['1', '2', '3'] *}

Lásd még: implode.

first

Visszaadja a tömb első elemét vagy a karakterlánc első karakterét:

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

Lásd még last, random.

floor (int $precision=0)

Egy számot adott pontosságra kerekít.

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

Lásd még ceil, round.

firstUpper

Az érték első betűjét nagybetűvé alakítja. PHP-bővítményt igényel mbstring.

{='the latte'|firstUpper}  {* kimenetek 'The latte' *}

Lásd még nagybetű, kisbetű, nagybetű.

group (string|int|\Closure $by)array

A szűrő különböző kritériumok szerint csoportosítja az adatokat.

Ebben a példában a táblázat sorai a categoryId oszlop alapján vannak csoportosítva. A kimenet egy tömb tömbökből álló tömb, ahol a kulcs a categoryId oszlopban szereplő érték. Olvassa el a részletes utasításokat.

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

Lásd még a batch, a group függvény és az iterateWhile tag.

implode (string $glue='')

Visszaad egy stringet, amely a tömbben lévő stringek összevonása. Alias a következőhöz: join.

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

A join alias is használható:

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

indent (int $level=1, string $char="\t")

A szöveg balról történő behúzása egy adott számú tabulátorral vagy más karakterrel, amelyet a második választható argumentumban adunk meg. Az üres sorok nem kerülnek behúzásra.

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

Nyomtatás:

<div>
	<p>Hello</p>
</div>

last

Visszaadja a tömb utolsó elemét vagy a karakterlánc utolsó karakterét:

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

Lásd még first, random.

length

Egy karakterlánc vagy tömb hosszát adja vissza.

  • a stringek esetében UTF-8 karakterekben adja vissza a hosszúságot.
  • tömbök esetén az elemek számát adja vissza.
  • a Countable interfészt megvalósító objektumok esetében a count() visszatérési értékét használja.
  • az IteratorAggregate interfészt megvalósító objektumok esetében az iterator_count() visszatérési értékét használja.
{if ($users|length) > 10}
	...
{/if}

localDate (?string $format=null, ?string $date=null, ?string $time=null)

A dátum és az idő formázása a nyelvterületnek megfelelően, így biztosítva az időadatok konzisztens és lokalizált megjelenítését a különböző nyelveken és régiókban. A szűrő a dátumot UNIX időbélyegként, stringként vagy DateTimeInterface objektumként fogadja el.

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

Ha a szűrőt paraméterek nélkül használja, akkor a dátumot hosszú formátumban adja ki, ahogyan azt a továbbiakban kifejtjük.

a) A formátum használata

A format paraméter leírja, hogy mely időösszetevőket kell megjeleníteni. Betűkódokat használ, ahol az ismétlések száma befolyásolja a kimenet szélességét:

Év y / yy / yyyy 2024 / 24 / 2024
Hónap M / MM / MMMMMMM 8 / 08 / aug.augusztus
Nap d / dd / EEEEE 1 / 01 / Vvasárnap
Hour j / H / h preferred / 24-hour / 12-hour
Perc m / mm 5 / 05 (2 számjegy, ha másodpercekkel kombinálják)
Másodperc s / ss 8 / 08 (2 számjegy, ha percekkel kombinálva)

A kódok sorrendje a formátumban nem számít, mivel az összetevők sorrendje a helyi konvencióknak megfelelően jelenik meg. Ezért a formátum helytől független. Például a yyyyMMMMd formátum a en_US nyelvjárásban a April 15, 2024, míg a cs_CZ nyelvjárásban a 15. dubna 2024 formátumot adja ki:

locale: hu-HU en_US
format: 'dMy' 2024. 08. 10. 8/10/2024
format: 'yM' 2024. 8. 8/2024
format: 'yyyyMMMM' 2024. augusztus August 2024
format: 'MMMM' augusztus August
format: 'jm' 17:54 5:54 PM
format: 'Hm' 17:54 17:54
format: 'hm' du. 5:54 5:54 PM

b) Előre beállított stílusok használata

A date és a time paraméterek határozzák meg a dátum és az idő megjelenítésének részletességét. Több szint közül választhat: full, long, medium, short. Megjelenítheti csak a dátumot, csak az időt vagy mindkettőt:

locale: hu-HU en_US
date: short 1978. 01. 23. 1/23/78
date: medium 1978. jan. 23. Jan 23, 1978
date: long 1978. január 23. January 23, 1978
date: full 1978. január 23., hétfő 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 CET 8:30:59 AM GMT+1
date: short, time: short 1978. 01. 23. 8:30 1/23/78, 8:30 AM
date: medium, time: short 1978. jan. 23. 8:30 Jan 23, 1978, 8:30 AM
date: long, time: short 1978. január 23. 8:30 January 23, 1978 at 8:30 AM

A dátumhoz használhatja a relative- előtagot is (pl. relative-short), amely a jelenhez közeli dátumok esetében a yesterday, today vagy tomorrow, egyébként a szokásos módon jelenik meg.

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

Lásd még dátum.

lower

Egy értéket kisbetűvé alakít. PHP-bővítményt igényel mbstring.

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

Lásd még capitalize, firstUpper, upper.

nocheck

Megakadályozza az automatikus URL-szanálást. A Latte automatikusan ellenőrzi, hogy a változó tartalmaz-e webes URL-t (azaz HTTP/HTTPS protokollt), és megakadályozza a biztonsági kockázatot jelentő linkek írását.

Ha a hivatkozás más sémát használ, például javascript: vagy data:, és biztos a tartalmában, akkor a |nocheck segítségével kikapcsolhatja az ellenőrzést.

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

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

Nyomtatások:

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

Lásd még checkUrl.

noescape

Letiltja az automatikus escapinget.

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

Nyomtat:

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

A noescape szűrő visszaélése XSS sebezhetőséghez vezethet! Soha ne használja, hacsak nem teljesen biztos abban, hogy mit csinál, és hogy a nyomtatott karakterlánc megbízható forrásból származik.

number (int $decimals=0, string $decPoint='.', string $thousandsSep=',')

Egy számot a megadott számú tizedesjegyig formáz. Ha a nyelvi terület be van állítva, akkor a megfelelő tizedes és ezres elválasztójeleket használja.

{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)

A format paraméter lehetővé teszi, hogy a számok megjelenését pontosan az Ön igényei szerint határozza meg. Beállított nyelvterületet igényel. A formátum több speciális karakterből áll, amelyek teljes leírása a DecimalFormat dokumentációban található:

  • <c id=6/> kötelező számjegy, mindig megjelenik, még akkor is, ha nulla.
  • # opcionális számjegy, csak akkor jelenik meg, ha a számnak van számjegye az adott helyen.
  • @ szignifikáns számjegy, segít a számot bizonyos számú szignifikáns számjeggyel megjeleníteni.
  • . a tizedesvessző helyét jelöli (vessző vagy pont, a területi adattól függően).
  • , számjegycsoportok, általában ezrek elválasztására szolgál.
  • % megszorozza a számot 100-zal, és hozzáadja a százalékjelet.

Nézzünk néhány példát. Az első példában a két tizedesjegy kötelező, a másodikban opcionális. A harmadik példa mindkét oldalon nullákkal való kitöltést mutat, a negyedik példa pedig csak a meglévő számjegyeket jeleníti meg:

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

A szignifikáns számjegyek határozzák meg, hogy a tizedesvesszőtől függetlenül hány számjegyet kell megjeleníteni, szükség esetén kerekítve a számot:

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

Egy szám százalékban történő megjelenítésének egyszerű módja. A számot megszorozzuk 100-zal, és hozzáadjuk a % jelet:

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

A pozitív és negatív számok számára eltérő formátumot határozhatunk meg, amelyet egy ; karakterrel választunk el. Így például a pozitív számok a + jellel jeleníthetők meg:

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

Ne feledje, hogy a számok tényleges megjelenése a helyi beállításoktól függően változhat. Egyes országokban például pont helyett vesszőt használnak tizedesválasztóként. Ez a szűrő automatikusan figyelembe veszi ezt, így nem kell aggódnia emiatt.

padLeft (int $length, string $pad=' ')

Egy adott hosszúságú karakterláncot balról egy másik karakterlánccal kitölti.

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

padRight (int $length, string $pad=' ')

Egy adott hosszúságú karakterláncot egy másik, jobbról jövő karakterlánccal kitölti.

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

query

Dinamikusan generál egy lekérdezési karakterláncot az URL-ben:

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

Nyomtat:

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

A null értékű kulcsok nem szerepelnek.

Lásd még escapeUrl.

random

Visszaadja a tömb véletlenszerű elemét vagy a karakterlánc karakterét:

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

Lásd még first, last.

repeat (int $count)

Megismétli a karakterláncot x-szer.

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

replace (string|array $search, string $replace='')

A keresett karakterlánc minden előfordulását helyettesítő karakterlánccal helyettesíti.

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

Egyszerre több csere is elvégezhető:

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

replaceRE (string $pattern, string $replace='')

Az összes előfordulást helyettesíti a reguláris kifejezésnek megfelelően.

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

reverse

Megfordítja a megadott karakterláncot vagy tömböt.

{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)

Egy számot adott pontosságra kerekít.

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

Lásd még ceil, floor.

slice (int $start, ?int $length=null, bool $preserveKeys=false)

Egy tömb vagy egy karakterlánc egy szeletének kivonása.

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

A slice-szűrő a array_slice PHP-funkcióként működik tömbök esetében, a mb_substr pedig karakterláncok esetében, UTF-8 módban a iconv_substr -re való visszalépéssel.

Ha a kezdet nem negatív, akkor a szekvencia a változóban ezzel a kezdőponttal kezdődik. Ha a start negatív, akkor a szekvencia a változó végétől ilyen messze kezdődik.

Ha a length értéke pozitív, akkor a szekvencia legfeljebb ennyi elemet tartalmaz. Ha a változó rövidebb, mint a hossz, akkor csak a rendelkezésre álló változóelemek lesznek jelen. Ha a hossz meg van adva és negatív, akkor a sorozat ennyi elemmel a változó vége előtt fog megállni. Ha nem adjuk meg, akkor a szekvencia az eltolódástól a változó végéig mindent tartalmazni fog.

A Filter alapértelmezés szerint átrendezi és visszaállítja az integer tömb kulcsát. Ez a viselkedés megváltoztatható a preserveKeys true értékre állításával. A string kulcsok ettől a paramétertől függetlenül mindig megmaradnak.

sort (?Closure $comparison, string|int|\Closure|null $by=null, string|int|\Closure|bool $byKey=false)

A szűrő egy tömb vagy iterátor elemeit rendezi, miközben megőrzi az asszociatív kulcsokat. Ha egy területi beállítás van megadva, a rendezés annak szabályait követi, kivéve, ha egyéni összehasonlító függvény van megadva.

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

A tömb fordított sorrendbe rendezve.

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

Megadhat egy egyéni összehasonlító függvényt a rendezéshez (a példa azt mutatja, hogyan lehet a legnagyobbtól a legkisebbig megfordítani a rendezést):

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

A |sort szűrő lehetővé teszi az elemek kulcs szerinti rendezését is:

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

Ha egy táblázatot egy adott oszlop szerint kell rendezni, használhatja a by paramétert. A példában szereplő 'name' érték azt adja meg, hogy a rendezés a $row->name vagy a szerint történjen. $row['name'], attól függően, hogy a $row egy tömb vagy egy objektum:

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

Meghatározhat egy visszahívási függvényt is, amely meghatározza a rendezés értékét:

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

A byKey paraméter ugyanígy használható.

spaceless

Eltávolítja a felesleges szóközöket a kimenetből. Használhatod a strip aliast is.

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

Nyomtat:

<ul> <li>Hello</li> </ul>

stripHtml

A HTML-t egyszerű szöveggé alakítja. Vagyis eltávolítja a HTML-címkéket, és a HTML-egységeket szöveggé alakítja.

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

Az így kapott sima szöveg természetesen tartalmazhat olyan karaktereket, amelyek HTML-címkéket képviselnek, például a '&lt;p&gt;'|stripHtml átváltozik <p>. Soha ne adja ki az eredményül kapott szöveget a |noescape címmel, mivel ez biztonsági réshez vezethet.

substr (int $offset, ?int $length=null)

Kivonja egy karakterlánc egy szeletét. Ezt a szűrőt felváltotta a slice szűrő.

{$string|substr: 1, 2}

translate (…$args)

Kifejezéseket fordít le más nyelvekre. Ahhoz, hogy a szűrő elérhető legyen, be kell állítania a fordítót. A címkéket is használhatja a fordításhoz.

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

trim (string $charlist=" \t\n\r\0\x0B\u{A0}")

Vezető és követő karakterek eltávolítása, alapértelmezés szerint szóköz.

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

truncate (int $length, string $append='…')

Rövidíti a karakterláncot a megadott maximális hosszúságra, de megpróbálja megőrizni az egész szavakat. Ha a karakterlánc csonkolva van, ellipszist ad a végére (ez a második paraméterrel módosítható).

{var $title = 'Hello, how are you?'}
{$title|truncate:5}  {* Hell…                *}
{$title|truncate:17} {* Hello, how are…      *}
{$title|truncate:30} {* Hello, how are you?  *}

upper

Egy értéket nagybetűvé alakít. A mbstring PHP-bővítményt igényli.

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

Lásd még capitalize, firstUpper, lower.

webalize

Átalakítja ASCII-re.

A szóközöket kötőjelekké alakítja. Eltávolítja a nem alfanumerikus karaktereket, aláhúzásokat vagy kötőjeleket. Átalakítja kisbetűvé. Eltávolítja a vezető és az utolsó szóközöket is.

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

Szükséges a nette/utils csomag.