Filtri di Latte

Nei template possiamo usare funzioni che aiutano a modificare o riformattare i dati nella loro forma finale. Le chiamiamo filtri.

Esistono anche i filtri di escaping per HTML (escapeHtml e escapeHtmlComment), XML (escapeXml), JavaScript (escapeJs), CSS (escapeCss) e iCalendar (escapeICal), che Latte usa da sé grazie all'escaping sensibile al contesto e che non dovete scrivere.

Latte controlla automaticamente gli attributi src e href, quindi non avete quasi mai bisogno del filtro checkUrl.

Tutti i filtri integrati sono pensati per stringhe con codifica UTF‑8.

Uso

I filtri si scrivono dopo il simbolo pipe (uno spazio prima è ammesso):

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

I filtri si possono concatenare e vengono applicati nell'ordine, da sinistra a destra:

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

I parametri si indicano dopo il nome del filtro, separati da due punti o da virgole:

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

I filtri si possono applicare anche a un'espressione:

{var $name = ($title|upper) . ($subtitle|lower)}

I filtri personalizzati si registrano così:

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

Nel template si chiamano poi in questo modo:

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

Filtri nullsafe

Qualsiasi filtro si può rendere nullsafe usando ?| al posto di |. Se il valore è null, il filtro non viene eseguito e viene restituito null. Anche i filtri successivi della catena vengono saltati.

È utile in combinazione con gli attributi HTML, che vengono omessi se il valore è null.

<div title={$title?|upper}>
{* se $title è null: <div> *}
{* se $title è 'hello': <div title="HELLO"> *}

Filtri

accept

Il filtro si usa durante la migrazione da Latte 3.0 per confermare che avete esaminato la modifica del comportamento degli attributi e che la accettate. Non modifica il valore.

È uno strumento temporaneo. Una volta completata la migrazione e disattivati gli avvisi di migrazione, dovreste rimuovere questo filtro dai vostri template.

batch (int $length, mixed $rest=null): Generator

Filtro che semplifica la presentazione di dati lineari in forma di tabella. Restituisce un generatore di array con il numero di elementi indicato. Se indicate un secondo parametro, verrà usato per completare gli elementi mancanti nell'ultima riga.

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

Stampa:

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

Vedi anche group e il tag iterateWhile.

breakLines

Inserisce un tag HTML <br> prima di ogni carattere di a capo.

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

bytes (int $precision=2)

Formatta una dimensione in byte in una forma leggibile. Se il locale è impostato, vengono usati i corrispondenti separatori decimale e delle migliaia.

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

ceil (int $precision=0)

Arrotonda un numero per eccesso alla precisione indicata.

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

Vedi anche floor, round.

capitalize

Le parole iniziano con una lettera maiuscola, tutti gli altri caratteri sono minuscoli. Richiede l'estensione PHP mbstring.

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

Vedi anche firstLower, firstUpper, lower, upper.

checkUrl

Forza la pulizia dell'URL. Controlla che l'URL usi uno schema sicuro (http, https, ftp, mailto, tel, sms) o che sia un link relativo, e blocca gli schemi pericolosi come javascript:, che potrebbero costituire un rischio per la sicurezza.

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

Stampa:

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

Vedi anche nocheck.

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

Limita un valore all'intervallo indicato, estremi min e max inclusi.

{$level|clamp: 0, 255}

Esiste anche come funzione.

column (string|int|null $columnKey, string|int|null $indexKey=null)

Restituisce come nuovo array i valori di una singola colonna $columnKey di un array multidimensionale. Si può usare anche su array di oggetti per estrarre i valori delle proprietà.

{var $users = [
	[id: 30, name: 'John', age: 30],
	[id: 32, name: 'Jane', age: 25],
	[id: 33, age: 35],
]}

{$users|column: 'name'}
{* restituisce ['John', 'Jane'] *}

{$users|column: 'name', 'id'}
{* restituisce [30 => 'John', 32 => 'Jane'] *}

Se passate null come chiave della colonna, l'array verrà reindicizzato secondo $indexKey.

commas (?string $lastGlue=null)

Unisce gli elementi di un array con una virgola e uno spazio (', '). Una comoda scorciatoia per elencare elementi in forma leggibile.

{var $items = ['apples', 'oranges', 'bananas']}
{$items|commas}
{* stampa 'apples, oranges, bananas' *}

Potete anche indicare un separatore personalizzato per l'ultima coppia di elementi:

{$items|commas: ' and '}
{* stampa 'apples, oranges and bananas' *}

{=['PHP', 'JavaScript', 'Python']|commas: ', or '}
{* stampa 'PHP, JavaScript, or Python' *}

Vedi anche implode.

dataStream (?string $type=null)

Converte il contenuto nello schema data URI. Permette di incorporare le immagini in HTML o CSS senza dover collegare file esterni. Se $type è null, il tipo MIME viene rilevato automaticamente.

Supponiamo di avere un'immagine nella variabile $img = Image::fromFile('image.gif'), allora

<img src={$img|dataStream}>

Stampa, per esempio:

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

Richiede l'estensione PHP fileinfo.

date (string $format='j. n. Y')

Formatta una data e un'ora secondo la maschera usata dalla funzione PHP date. Il filtro accetta la data come timestamp UNIX, come stringa, come DateTimeInterface o come oggetto DateInterval.

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

Vedi anche localDate.

escapeUrl

Esegue l'escaping di una variabile per usarla come parametro in un URL.

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

Vedi anche query.

explode (string $separator='')

Divide una stringa in un array secondo un separatore. Alias di split.

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

Se il separatore è una stringa vuota (il valore predefinito), l'input verrà diviso nei singoli caratteri:

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

Potete usare anche l'alias split:

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

Vedi anche implode.

filter (callable $predicate): iterable

Filtra gli elementi di un array o di un iteratore, conservando solo quelli per cui il predicato restituisce true. Le chiavi vengono conservate.

{foreach ($people|filter: fn($person) => $person->age >= 18) as $adult}
	<p>{$adult->name}</p>
{/foreach}

first

Restituisce il primo elemento di un array o il primo carattere di una stringa:

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

Vedi anche last, random.

floor (int $precision=0)

Arrotonda un numero per difetto alla precisione indicata.

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

Vedi anche ceil, round.

firstLower

Converte la prima lettera in minuscolo. Richiede l'estensione PHP mbstring.

{='The Latte'|firstLower}  {* stampa 'the Latte' *}

Vedi anche capitalize, firstUpper, lower, upper.

firstUpper

Converte la prima lettera in maiuscolo. Richiede l'estensione PHP mbstring.

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

Vedi anche capitalize, firstLower, lower, upper.

group (string|int|\Closure $by): iterable

Il filtro raggruppa i dati secondo criteri diversi.

In questo esempio le righe della tabella sono raggruppate per la colonna categoryId. Il risultato è una struttura iterabile di gruppi, dove la chiave è il valore della colonna categoryId. Leggete la guida dettagliata.

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

Vedi anche batch, la funzione group e il tag iterateWhile.

implode (string $glue='')

Restituisce una stringa che è la concatenazione degli elementi della sequenza. Alias di join.

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

Potete usare anche l'alias join:

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

Vedi anche commas, explode.

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

Indenta il testo da sinistra di un dato numero di tabulazioni o di altri caratteri indicati nel secondo argomento. Le righe vuote non vengono indentate.

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

Stampa:

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

last

Restituisce l'ultimo elemento di un array o l'ultimo carattere di una stringa:

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

Vedi anche first, random.

length

Restituisce la lunghezza di una stringa o di un array.

• per le stringhe restituisce la lunghezza in caratteri UTF‑8
• per gli array restituisce il numero di elementi
• per gli oggetti che implementano l'interfaccia Countable usa il valore restituito dal metodo count()
• per gli oggetti che implementano l'interfaccia Traversable usa il valore restituito dalla funzione iterator_count()

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

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

Formatta la data e l'ora secondo il locale, garantendo una visualizzazione coerente e localizzata dei dati temporali nelle diverse lingue e regioni. Il filtro accetta la data come timestamp UNIX, come stringa o come oggetto DateTimeInterface.

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

Se usate il filtro senza parametri, stamperà la data al livello long, vedi sotto.

a) Uso di format

Il parametro format descrive quali componenti temporali vanno mostrati. Usa codici a lettere, dove il numero di ripetizioni influisce sull'ampiezza del risultato:

L'ordine dei codici nel formato non ha importanza, perché l'ordine dei componenti sarà mostrato secondo le convenzioni del locale. Il formato è quindi indipendente dal locale. Per esempio il formato yyyyMMMMd nel locale en_US stampa April 15, 2024, mentre nel locale cs_CZ stampa 15. dubna 2024:

b) Uso degli stili predefiniti

I parametri date e time determinano quanto dettagliatamente vanno mostrate la data e l'ora. Potete scegliere tra più livelli: full, long, medium, short. Potete scegliere di mostrare solo la data, solo l'ora oppure entrambe:

Per la data potete usare anche il prefisso relative- (per esempio relative-short), che per le date vicine al presente mostra ieri, oggi o domani; altrimenti la mostra nel modo consueto.

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

Vedi anche date.

lower

Converte una stringa in minuscolo. Richiede l'estensione PHP mbstring.

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

Vedi anche capitalize, firstLower, firstUpper, upper.

map (callable $transformer): iterable

Trasforma ogni elemento di un array o di un iteratore con una callback e restituisce un nuovo iteratore. È la controparte del filtro filter. Le chiavi vengono conservate.

{=($users|map: fn($user) => $user->name)|implode: ', '}   {* John, Mary, Paul *}

Vedi anche filter.

nocheck

Impedisce la pulizia automatica degli URL. Latte controlla automaticamente che un URL usi uno schema sicuro (come http, https, ftp, mailto, tel, sms) o che sia un link relativo, e blocca quelli potenzialmente pericolosi.

Se il link usa uno schema diverso, per esempio javascript: o data:, e siete sicuri del suo contenuto, potete disattivare il controllo con |nocheck.

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

<a href={$link}>controllato</a>
<a href={$link|nocheck}>non controllato</a>

Stampa:

<a href="">controllato</a>
<a href="javascript:window.close()">non controllato</a>

Vedi anche checkUrl.

noescape

Disattiva l'escaping automatico.

{var $trustedHtmlString = '<b>hello</b>'}
Con escaping: {$trustedHtmlString}
Senza escaping: {$trustedHtmlString|noescape}

Stampa:

Con escaping: <b>hello</b>
Senza escaping: <b>hello</b>

L'uso improprio del filtro noescape può portare a una vulnerabilità XSS! Non usatelo mai se non siete assolutamente sicuri di quello che state facendo e del fatto che la stringa stampata provenga da una fonte attendibile.

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

Formatta un numero con il numero di cifre decimali indicato. Se il locale è impostato, vengono usati i corrispondenti separatori decimale e delle migliaia.

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

Il parametro format permette di definire l'aspetto dei numeri esattamente secondo le vostre esigenze. Richiede che il locale sia impostato. Il formato è composto da alcuni caratteri speciali, descritti per intero nella documentazione DecimalFormat:

• 0 cifra obbligatoria, mostrata sempre anche se è zero
• # cifra facoltativa, mostrata solo se il numero ha davvero una cifra in quella posizione
• @ cifra significativa, aiuta a mostrare il numero con un certo numero di cifre significative
• . indica dove va il separatore decimale (punto o virgola, a seconda del paese)
• , serve a separare i gruppi di cifre, il più delle volte le migliaia
• % moltiplica il numero per 100 e aggiunge il segno di percentuale

Vediamo alcuni esempi. Nel primo le due cifre decimali sono obbligatorie, nel secondo sono facoltative. Il terzo esempio mostra il riempimento con zeri a sinistra e a destra, il quarto mostra solo le cifre esistenti:

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

Le cifre significative stabiliscono quante cifre, indipendentemente dalla virgola decimale, vanno mostrate, arrotondando se necessario:

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

Un modo semplice per mostrare un numero come percentuale. Il numero viene moltiplicato per 100 e viene aggiunto il segno %:

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

Possiamo definire un formato diverso per i numeri positivi e per quelli negativi, separati dal carattere ;. Così, per esempio, i numeri positivi possono essere mostrati con il segno +:

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

Ricordate che l'aspetto reale dei numeri può variare a seconda delle impostazioni del paese. Per esempio, in alcuni paesi come separatore decimale si usa la virgola invece del punto. Questo filtro ne tiene conto automaticamente, quindi non dovete preoccuparvene.

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

Riempie una stringa o un numero fino a una certa lunghezza con un'altra stringa, da sinistra.

{='hello'|padLeft: 10, '123'}  {* stampa '12312hello' *}
{=123|padLeft: 5, '0'}         {* stampa '00123' *}

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

Riempie una stringa o un numero fino a una certa lunghezza con un'altra stringa, da destra.

{='hello'|padRight: 10, '123'}  {* stampa 'hello12312' *}
{=123|padRight: 5, '0'}         {* stampa '12300' *}

query

Genera dinamicamente una query string in un URL:

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

Stampa:

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

Le chiavi con valore null vengono omesse.

Vedi anche escapeUrl.

random

Restituisce un elemento casuale di un array o un carattere casuale di una stringa:

{=[1, 2, 3, 4]|random}    {* stampa per esempio: 3 *}
{='abcd'|random}          {* stampa per esempio: 'b' *}

Vedi anche first, last.

repeat (int $count)

Ripete la stringa x volte.

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

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

Sostituisce tutte le occorrenze della stringa cercata con la stringa di sostituzione.

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

Si possono fare più sostituzioni in una volta sola:

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

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

Esegue una ricerca e sostituzione con un'espressione regolare.

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

reverse (bool $preserveKeys=false)

Inverte la stringa o l'array indicati.

{var $s = 'Nette'}
{$s|reverse}    {* stampa 'etteN' *}
{var $a = ['N', 'e', 't', 't', 'e']}
{$a|reverse}    {* restituisce ['e', 't', 't', 'e', 'N'] *}

round (int $precision=0)

Arrotonda un numero alla precisione indicata.

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

Vedi anche ceil, floor.

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

Estrae una porzione di un array, di una stringa o di un iteratore.

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

Il filtro si comporta come la funzione PHP array_slice per gli array o mb_substr per le stringhe. Per gli iteratori restituisce un generatore: gli elementi vengono consumati dalla fonte uno alla volta e la lettura si ferma appena raggiunto il limite. L'intero iteratore non viene mai caricato in memoria.

Se start non è negativo, la sequenza inizierà a quella distanza dall'inizio dell'array o della stringa. Se start è negativo, la sequenza inizierà a quella distanza dalla fine.

Se length è indicato ed è positivo, la sequenza avrà al massimo quel numero di elementi. Se l'input è più corto di length, saranno presenti solo gli elementi disponibili. Se length è indicato ed è negativo, la sequenza si fermerà a quel numero di elementi dalla fine dell'input. Se viene omesso, la sequenza conterrà tutto da start fino alla fine dell'input.

Per impostazione predefinita il filtro riordina e azzera le chiavi intere dell'array. Questo comportamento si può cambiare impostando preserveKeys a true. Le chiavi stringa vengono sempre conservate, indipendentemente da questo parametro.

Vedi anche limit.

limit (int $length)

Limita la lunghezza di un array, di una stringa o di un iteratore. Per gli array e gli iteratori le chiavi vengono conservate. Per le stringhe rispetta l'UTF-8.

{foreach ($items|limit: 5) as $item}
	...
{/foreach}

{$text|limit: 100}

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

Il filtro ordina gli elementi di un array o di un iteratore e ne conserva le chiavi associative. Quando è impostato un locale, l'ordinamento ne segue le regole, a meno che non sia indicata una funzione di confronto personalizzata.

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

Array ordinato in senso inverso:

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

Per l'ordinamento potete indicare una funzione di confronto personalizzata (l'esempio mostra come invertire l'ordinamento dal più grande al più piccolo):

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

Il filtro |sort permette anche di ordinare gli elementi per chiave:

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

Se avete bisogno di ordinare una tabella per una determinata colonna, potete usare il parametro by. Il valore 'name' nell'esempio indica che l'ordinamento avverrà per $item->name o $item['name'], a seconda che $item sia un array o un oggetto:

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

Potete anche definire una funzione di callback che determina il valore secondo cui ordinare:

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

Il parametro byKey si usa allo stesso modo.

spaceless

Rimuove dall'output gli spazi bianchi superflui. Potete usare anche l'alias deprecato strip, ma è preferibile spaceless.

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

Stampa:

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

stripHtml

Converte l'HTML in testo semplice. Rimuove cioè i tag HTML e converte le entità HTML in caratteri testuali.

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

Il testo semplice risultante può naturalmente contenere caratteri che rappresentano tag HTML, per esempio '<p>'|stripHtml viene convertito in <p>. Non stampate mai il testo risultante con |noescape, perché può portare a una vulnerabilità di sicurezza.

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

Estrae una parte di una stringa. Questo filtro è stato sostituito dal filtro slice.

{$string|substr: 1, 2}

toggle

Il filtro toggle controlla la presenza di un attributo in base a un valore booleano. Se il valore è vero, l'attributo è presente; se è falso, l'attributo viene omesso del tutto:

<div uk-grid={$isGrid|toggle}>
{* se $isGrid è vero: <div uk-grid> *}
{* se $isGrid è falso: <div> *}

Questo filtro è utile per gli attributi personalizzati o per gli attributi delle librerie JavaScript che richiedono un controllo di presenza/assenza simile a quello degli attributi booleani HTML.

Il filtro si può usare solo all'interno degli attributi HTML.

translate (…$args)

Traduce le espressioni in altre lingue. Perché il filtro sia disponibile, dovete configurare il traduttore. Potete usare anche i tag per la traduzione.

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

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

Rimuove gli spazi bianchi (o altri caratteri) dall'inizio e dalla fine di una stringa.

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

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

Accorcia una stringa alla lunghezza massima indicata, cercando di preservare le parole intere. Se la stringa viene accorciata, aggiunge alla fine i puntini di sospensione (modificabili con il secondo parametro).

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

upper

Converte una stringa in maiuscolo. Richiede l'estensione PHP mbstring.

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

Vedi anche capitalize, firstLower, firstUpper, lower.

webalize

Adatta una stringa UTF‑8 al formato usato negli URL.

Converte in ASCII. Converte gli spazi in trattini. Rimuove i caratteri che non sono alfanumerici, trattini bassi o trattini. Converte in minuscolo. Rimuove inoltre gli spazi bianchi iniziali e finali.

{var $s = 'Our 10th product'}
{$s|webalize}   {* stampa 'our-10th-product' *}

Richiede la libreria nette/utils.