Latte szűrők

A sablonokban olyan függvényeket használhatunk, amelyek segítenek az adatok módosításában vagy újraformázásában a végső formába. Ezeket szűrőknek nevezzük.

Átalakítás
batch lineáris adatok kiírása táblázatba
breakLines HTML sortörést ad a sorvégek elé
bytes méretet formáz bájtokban
clamp értéket korlátoz adott tartományba
dataStream konverzió Data URI protokollhoz
date dátumot és időt formáz
explode stringet tömbre bont elválasztó szerint
first visszaadja a tömb első elemét vagy a string első karakterét
group adatokat csoportosít különböző kritériumok szerint
implode tömböt stringgé fűz össze
indent szöveget behúz balról adott számú tabulátorral
join tömböt stringgé fűz össze
last visszaadja a tömb utolsó elemét vagy a string utolsó karakterét
length visszaadja a string hosszát karakterekben vagy a tömb hosszát
localDate dátumot és időt formáz a nemzeti beállítások szerint
number számot formáz
padLeft stringet balról kiegészít a kívánt hosszúságra
padRight stringet jobbról kiegészít a kívánt hosszúságra
random visszaadja a tömb véletlen elemét vagy a string véletlen karakterét
repeat string ismétlése
replace lecseréli a keresett string előfordulásait
replaceRE lecseréli az előfordulásokat reguláris kifejezés szerint
reverse megfordítja az UTF‑8 stringet vagy tömböt
slice kivon egy részt a tömbből vagy stringből
sort rendezi a tömböt
spaceless eltávolítja a fehér szóközt, hasonlóan a spaceless taghez
split stringet tömbre bont elválasztó szerint
strip eltávolítja a fehér szóközt
stripHtml eltávolítja a HTML tageket és a HTML entitásokat karakterekké alakítja
substr visszaadja a string egy részét
trim eltávolítja a kezdő és záró szóközöket vagy más karaktereket
translate fordítás más nyelvekre
truncate rövidíti a hosszt a szavak megőrzésével
webalize UTF‑8 stringet URL-ben használt formára alakít
Kis- és nagybetűk
capitalize kisbetűk, a szavak első betűje nagy
firstUpper az első betűt naggyá alakítja
lower kisbetűssé alakít
upper nagybetűssé alakít
Kerekítés
ceil számot felfelé kerekít adott pontosságra
floor számot lefelé kerekít adott pontosságra
round számot adott pontosságra kerekít
Escapelés
escapeUrl escapeli a paramétert az URL-ben
noescape kiírja a változót escapelés nélkül
query query stringet generál az URL-ben

Továbbá léteznek escapelő szűrők HTML-hez (escapeHtml és escapeHtmlComment), XML-hez (escapeXml), JavaScripthez (escapeJs), CSS-hez (escapeCss) és iCalendarhez (escapeICal), amelyeket a Latte maga használ a kontextusérzékeny escapelés révén, és nem kell őket kiírni.

Biztonság
checkUrl megtisztítja az URL címet a veszélyes bemenetektől
nocheck megakadályozza az URL cím automatikus tisztítását

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

Minden alapértelmezett szűrő UTF‑8 kódolású stringekhez készült.

Használat

A szűrőket függőleges vonal után írjuk (előtte lehet szóköz):

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

A szűrőket (régebbi verziókban helper-eket) láncolni lehet, és balról jobbra kerülnek alkalmazásra:

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

A paramétereket a szűrő neve után adjuk meg, kettősponttal vagy vesszővel elválasztva:

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

A szűrőket kifejezésre is lehet alkalmazni:

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

Egyéni szűrőket így lehet regisztrálni:

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

A sablonban pedig így hívjuk meg:

<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ő kiírását. Visszaad egy tömbökből álló tömböt a megadott számú elemmel. Ha megadja a második paramétert, azt használja a hiányzó elemek pótlására az utolsó sorban.

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

Kiírja:

<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 group és a iterateWhile taget.

breakLines

Minden új sor karakter elé beszúrja a <br> HTML taget.

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

bytes (int $precision=2)

A bájtban megadott méretet ember által olvasható formátumra alakítja. Ha a nemzeti beállítások be vannak állítva, a megfelelő tizedes- és ezreselválasztókat használja.

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

ceil (int $precision=0)

Felfelé kerekíti a számot a megadott pontosságra.

{=3.4|ceil}         {* kiírja: 4      *}
{=135.22|ceil:1}    {* kiírja: 135.3  *}
{=135.22|ceil:3}    {* kiírja: 135.22 *}

Lásd még floor, round.

capitalize

A szavak nagybetűvel kezdődnek, az összes többi karakter kisbetűs lesz. Szükséges a mbstring PHP kiterjesztés.

{='i like LATTE'|capitalize}  {* kiírja: 'I Like Latte' *}

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

checkUrl

Kikényszeríti az URL cím tisztítását. Ellenőrzi, hogy a változó webes URL-t tartalmaz-e (azaz HTTP/HTTPS protokollt), és megakadályozza az olyan linkek kiírását, amelyek biztonsági kockázatot jelenthetnek.

{var $link = 'javascript:window.close()'}
<a data-href={$link|checkUrl}>ellenőrzött</a>
<a data-href={$link}>nem ellenőrzött</a>

Kiírja:

<a data-href="">ellenőrzött</a>
<a data-href="javascript:window.close()">nem ellenőrzött</a>

Lásd még nocheck.

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

Az értéket a megadott inkluzív min és max tartományba korlátozza.

{$level|clamp: 0, 255}

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

dataStream (string $mimetype=detect)

A tartalmat data URI scheme-re konvertálja. Segítségével képeket lehet beágyazni HTML-be vagy CSS-be külső fájlok linkelése nélkül.

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

<img src={$img|dataStream}>

Kiírja például:

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

Szükséges a fileinfo PHP kiterjesztés.

date (string $format)

Dátumot és időt formáz a PHP date függvény által használt maszk szerint. A szűrő elfogadja a dátumot UNIX timestamp formátumban, stringként vagy DateTimeInterface típusú objektumként.

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

Lásd még localDate.

escapeUrl

Escapeli a változót URL paraméterként való használatra.

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

Lásd még query.

explode (string $separator='')

Stringet tömbre bont elválasztó szerint. Alias a split-re.

{='one,two,three'|explode:','}    {* visszaadja: ['one', 'two', 'three'] *}

Ha az elválasztó üres string (alapértelmezett érték), a bemenet egyes karakterekre lesz bontva:

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

Használhatja a split aliast is:

{='1,2,3'|split:','}              {* visszaadja: ['1', '2', '3'] *}

Lásd még implode.

first

Visszaadja a tömb első elemét vagy a string első karakterét:

{=[1, 2, 3, 4]|first}    {* kiírja: 1 *}
{='abcd'|first}          {* kiírja: 'a' *}

Lásd még last, random.

floor (int $precision=0)

Lefelé kerekíti a számot a megadott pontosságra.

{=3.5|floor}        {* kiírja: 3      *}
{=135.79|floor:1}   {* kiírja: 135.7  *}
{=135.79|floor:3}   {* kiírja: 135.79 *}

Lásd még ceil, round.

firstUpper

Az első betűt naggyá alakítja. Szükséges a mbstring PHP kiterjesztés.

{='the latte'|firstUpper}  {* kiírja: 'The latte' *}

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

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

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

Ebben a példában a táblázat sorai a categoryId oszlop szerint vannak csoportosítva. A kimenet egy tömbökből álló tömb, ahol a kulcs a categoryId oszlop értéke. Olvassa el a részletes útmutatót.

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

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

implode (string $glue='')

Visszaad egy stringet, amely a szekvencia elemeinek összefűzése. Alias a join-ra.

{=[1, 2, 3]|implode}      {* kiírja: '123' *}
{=[1, 2, 3]|implode:'|'}  {* kiírja: '1|2|3' *}

Használhatja a join aliast is:

{=[1, 2, 3]|join}         {* kiírja: '123' *}

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

A szöveget balról behúzza a megadott számú tabulátorral vagy más karakterrel, amelyet a második argumentumban adhatunk meg. Az üres sorok nincsenek behúzva.

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

Kiírja:

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

last

Visszaadja a tömb utolsó elemét vagy a string utolsó karakterét:

{=[1, 2, 3, 4]|last}    {* kiírja: 4 *}
{='abcd'|last}          {* kiírja: 'd' *}

Lásd még first, random.

length

Visszaadja a string vagy a tömb hosszát.

  • stringek esetén visszaadja a hosszt UTF‑8 karakterekben
  • tömbök esetén visszaadja az elemek számát
  • a Countable interfészt implementáló objektumok esetén a count() metódus visszatérési értékét használja
  • az IteratorAggregate interfészt implementáló objektumok esetén az iterator_count() függvény visszatérési értékét használja
{if ($users|length) > 10}
	...
{/if}

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

Dátumot és időt formáz a nemzeti beállítások szerint, ami biztosítja az időadatok következetes és lokalizált megjelenítését a különböző nyelveken és régiókban. A szűrő elfogadja a dátumot UNIX timestampként, stringként vagy DateTimeInterface típusú objektumként.

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

Ha a szűrőt paraméterek nélkül használja, a dátum a long szinten kerül kiírásra, lásd alább.

a) formátum használata

A format paraméter leírja, hogy mely időösszetevőket kell megjeleníteni. Ehhez betűkódokat használ, amelyek ismétlődésének 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
óra j / H / h preferált / 24 órás / 12 órás
perc m / mm 5 / 05 (2 számjegy másodpercekkel kombinálva)
másodperc s / ss 8 / 08 (2 számjegy percekkel kombinálva)

A kódok sorrendje a formátumban nem számít, mert az összetevők sorrendje a nemzeti beállítások szokásai szerint kerül kiírásra. A formátum tehát független tőle. Például a yyyyMMMMd formátum en_US környezetben April 15, 2024-et ír ki, míg hu_HU környezetben 2024. április 15.-öt:

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:22 5:22 PM
format: 'Hm' 17:22 17:22
format: 'hm' du. 5:22 5:22 PM

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

A date és time paraméterek határozzák meg, hogy milyen részletességgel kell a dátumot és az időt kiírni. Több szint közül választhat: full, long, medium, short. Kiíratható csak a dátum, csak az idő, vagy mindkettő:

locale: hu_HU en_US
date: short 78. 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 78. 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átumnál ezenkívül használható a relative- előtag (pl. relative-short), amely a jelenhez közeli dátumok esetén tegnap, ma vagy holnap szöveget jelenít meg, egyébként a standard módon írja ki.

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

Lásd még date.

lower

A stringet kisbetűssé alakítja. Szükséges a mbstring PHP kiterjesztés.

{='LATTE'|lower}   {* kiírja: 'latte' *}

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

nocheck

Megakadályozza az URL cím automatikus tisztítását. A Latte automatikusan ellenőrzi, hogy a változó webes URL-t tartalmaz-e (azaz HTTP/HTTPS protokollt), és megakadályozza az olyan linkek kiírását, amelyek biztonsági kockázatot jelenthetnek.

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

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

<a href={$link}>ellenőrzött</a>
<a href={$link|nocheck}>nem ellenőrzött</a>

Kiírja:

<a href="">ellenőrzött</a>
<a href="javascript:window.close()">nem ellenőrzött</a>

Lásd még checkUrl.

noescape

Letiltja az automatikus escapelést.

{var $trustedHtmlString = '<b>hello</b>'}
Escapelt: {$trustedHtmlString}
Nem escapelt: {$trustedHtmlString|noescape}

Kiírja:

Escapelt: &lt;b&gt;hello&lt;/b&gt;
Nem escapelt: <b>hello</b>

A noescape szűrő helytelen használata XSS sebezhetőséghez vezethet! Soha ne használja, ha nem teljesen biztos abban, amit csinál, és hogy a kiírt string megbízható forrásból származik.

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

Számot formáz adott számú tizedesjegyre. Ha a nemzeti beállítások be vannak állítva, a megfelelő tizedes- és ezreselválasztókat 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 a számok megjelenésének pontos meghatározását az Ön igényei szerint. Ehhez be kell állítani a nemzeti beállításokat. A formátum több speciális karakterből áll, amelyek teljes leírását a DecimalFormat dokumentációban találja:

  • 0 kötelező számjegy, mindig megjelenik, még akkor is, ha nulla
  • # opcionális számjegy, csak akkor jelenik meg, ha ezen a helyen valóban van számjegy
  • @ jelentős számjegy, segít a szám megjelenítésében adott számú érvényes számjeggyel
  • . jelzi, hol legyen a tizedesvessző (vagy pont, országtól függően)
  • , a számjegycsoportok, leggyakrabban ezresek elválasztására szolgál
  • % a számot 100-zal szorozza és hozzáadja a százalékjelet

Nézzünk néhány példát. Az első példában két tizedesjegy kötelező, a másodikban opcionális. A harmadik példa a nullákkal való kiegészítést mutatja balról és jobbról, a negyedik csak a létező 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 jelentős számjegyek határozzák meg, hogy hány számjegy jelenjen meg a tizedesvesszőtől függetlenül, kerekítéssel:

{1234|number: '@@'}             {* 1200 *}
{1234|number: '@@@'}            {* 1230 *}
{1234|number: '@@@#'}           {* 1234 *}
{1.2345|number: '@@@'}          {* 1,23 *}
{0.00123|number: '@@'}          {* 0,0012 *}

Egyszerű módja a szám százalékként való megjelenítésének. A számot 100-zal szorozza és hozzáadja a % jelet:

{0.1234|number: '#.##%'}        {* 12,34% *}

Definiálhatunk eltérő formátumot a pozitív és negatív számokra, ezeket a ; jel választja el. Ezzel a módszerrel például beállítható, hogy a pozitív számok + jellel jelenjenek meg:

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

Ne feledje, hogy a számok tényleges megjelenése eltérhet az ország beállításaitól függően. Például néhány országban vesszőt használnak pont helyett tizedesjelként. Ez a szűrő ezt automatikusan figyelembe veszi, és nem kell semmiről gondoskodnia.

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

A stringet balról kiegészíti egy másik stringgel a megadott hosszúságra.

{='hello'|padLeft: 10, '123'}  {* kiírja: '12312hello' *}

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

A stringet jobbról kiegészíti egy másik stringgel a megadott hosszúságra.

{='hello'|padRight: 10, '123'}  {* kiírja: 'hello12312' *}

query

Dinamikusan generál query stringet az URL-ben:

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

Kiírja:

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

A null értékű kulcsok kimaradnak.

Lásd még escapeUrl.

random

Visszaadja a tömb véletlen elemét vagy a string véletlen karakterét:

{=[1, 2, 3, 4]|random}    {* kiírja pl.: 3 *}
{='abcd'|random}          {* kiírja pl.: 'b' *}

Lásd még first, last.

repeat (int $count)

A stringet x-szer ismétli.

{='hello'|repeat: 3}  {* kiírja: 'hellohellohello' *}

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

A keresett string összes előfordulását lecseréli a helyettesítő stringre.

{='hello world'|replace: 'world', 'friend'}  {* kiírja: 'hello friend' *}

Több cserét is végre lehet hajtani egyszerre:

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

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

Reguláris kifejezés keresést végez cserével.

{='hello world'|replaceRE: '/l.*/', 'l'}  {* kiírja: 'hel' *}

reverse

Megfordítja a megadott stringet vagy tömböt.

{var $s = 'Nette'}
{$s|reverse}    {* kiírja: 'etteN' *}
{var $a = ['N', 'e', 't', 't', 'e']}
{$a|reverse}    {* visszaadja: ['e', 't', 't', 'e', 'N'] *}

round (int $precision=0)

A számot a megadott pontosságra kerekíti.

{=3.4|round}        {* kiírja: 3      *}
{=3.5|round}        {* kiírja: 4      *}
{=135.79|round:1}   {* kiírja: 135.8  *}
{=135.79|round:3}   {* kiírja: 135.79 *}

Lásd még ceil, floor.

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

Kivon egy részt a tömbből vagy stringből.

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

A szűrő úgy működik, mint a PHP array_slice függvénye tömbökre vagy az mb_substr stringekre, fallbackként az iconv_substr függvénnyel UTF‑8 módban.

Ha a start pozitív, a szekvencia ennyivel eltolva kezdődik a tömb/string elejétől. Ha negatív, a szekvencia ennyivel eltolva kezdődik a végétől.

Ha a length paraméter meg van adva és pozitív, a szekvencia ennyi elemet fog tartalmazni. Ha negatív length paramétert adunk át ennek a függvénynek, a szekvencia az eredeti tömb összes elemét tartalmazza, a start pozíciótól kezdve és a tömb végétől számított length elemmel korábban végződve. Ha ezt a paramétert nem adja meg, a szekvencia az eredeti tömb összes elemét tartalmazza, a start pozíciótól kezdve.

Alapértelmezés szerint a szűrő megváltoztatja a sorrendet és visszaállítja a tömb egész számú kulcsait. Ez a viselkedés megváltoztatható a preserveKeys true-ra állításával. A string kulcsok mindig megmaradnak, ettől a paramétertől függetlenül.

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

A szűrő rendezi a tömb vagy iterátor elemeit, és megőrzi azok asszociatív kulcsait. Ha a nemzeti beállítások be vannak állítva, a rendezés annak szabályai szerint történik, hacsak nincs megadva saját összehasonlító függvény.

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

Rendezett tömb fordított sorrendben:

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

Megadhat saját összehasonlító függvényt a rendezéshez (a példa megmutatja, hogyan lehet fordítani a rendezést a legnagyobbtól a legkisebbig):

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

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

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

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

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

Definiálhat egy callback függvényt is, amely meghatározza az értéket, amely szerint rendezni kell:

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

Ugyanígy használható a byKey paraméter is.

spaceless

Eltávolítja a felesleges fehér szóközt (szóközöket) a kimenetből. Használhatja a strip aliast is.

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

Kiírja:

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

stripHtml

A HTML-t tiszta szöveggé alakítja. Tehát eltávolítja belőle a HTML tageket és a HTML entitásokat szöveggé alakítja.

{='<p>one &lt; two</p>'|stripHtml}  {* kiírja: 'one < two' *}

Az eredményül kapott tiszta szöveg természetesen tartalmazhat olyan karaktereket, amelyek HTML tageket képviselnek, például a '&lt;p&gt;'|stripHtml <p>-vé alakul. Semmi esetre se írja ki az így keletkezett szöveget |noescape-pel, mert ez biztonsági rés kialakulásához vezethet.

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

Kivon egy részt a stringből. Ezt a szűrőt felváltotta a slice szűrő.

{$string|substr: 1, 2}

translate (…$args)

Kifejezéseket fordít más nyelvekre. Ahhoz, hogy a szűrő elérhető legyen, be kell állítani a fordítót. Használhatja a fordítási tageket is.

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

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

Eltávolítja a szóközöket (vagy más karaktereket) a string elejéről és végéről.

{='  I like Latte.  '|trim}    {* kiírja: 'I like Latte.' *}
{='  I like Latte.'|trim: '.'} {* kiírja: '  I like Latte' *}

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

Levágja a stringet a megadott maximális hosszúságra, miközben megpróbálja megőrizni az egész szavakat. Ha a string rövidül, a végére három pontot tesz (ez a második paraméterrel megváltoztatható).

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

upper

A stringet nagybetűssé alakítja. Szükséges a mbstring PHP kiterjesztés.

{='latte'|upper}  {* kiírja: 'LATTE' *}

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

webalize

Az UTF‑8 stringet URL-ben használt formára alakítja.

ASCII-ra konvertálja. A szóközöket kötőjelekre cseréli. Eltávolítja azokat a karaktereket, amelyek nem alfanumerikusak, aláhúzások vagy kötőjelek. Kisbetűssé alakítja. Eltávolítja az elülső és hátsó szóközöket is.

{var $s = 'Náš 10. produkt'}
{$s|webalize}   {* kiírja: 'nas-10-produkt' *}

Szükséges a nette/utils könyvtár.

verzió: 3.0