Latte tagy (makra)
Přehled a popis všech tagů (neboli značek či maker) šablonovacího systému Latte, které jsou vám standardně k dispozici.
{$var}, {...} nebo {=...} |
vypíše escapovanou proměnnou nebo výraz |
{$var|filter} |
vypíše s použitím filtrů |
{l} nebo {r} |
vypíše znak { nebo } |
{if} … {elseif} … {else} … {/if} |
podmínka if |
{ifset} … {elseifset} … {/ifset} |
podmínka ifset |
{ifchanged} … {/ifchanged} |
test jestli došlo ke změně |
{switch} {case} {default} {/switch} |
podmínka switch |
n:else |
alternativní obsah pro podmínky |
{foreach} … {/foreach} |
foreach |
{for} … {/for} |
for |
{while} … {/while} |
while |
{continueIf $cond} |
pokračovat další iterací |
{skipIf $cond} |
přeskočit iteraci |
{breakIf $cond} |
přerušení cyklu |
{exitIf $cond} |
včasné ukončení |
{first} … {/first} |
jde o první průchod? |
{last} … {/last} |
jde o poslední průchod? |
{sep} … {/sep} |
bude ještě následovat průchod? |
{iterateWhile} … {/iterateWhile} |
strukturovaný foreach |
$iterator |
speciální proměnná uvnitř foreach |
{include 'file.latte'} |
načte šablonu z dalšího souboru |
{sandbox 'file.latte'} |
načte šablonu v sandbox režimu |
{block} |
anonymní blok |
{block blockname} |
definuje blok |
{define blockname} |
definuje blok pro pozdější použití |
{include blockname} |
vykreslení bloku |
{include blockname from 'file.latte'} |
vykreslí blok ze souboru |
{import 'file.latte'} |
načte bloky ze šablony |
{layout 'file.latte'} / {extends} |
určuje soubor s layoutem |
{embed} … {/embed} |
načte šablonu či blok a umožní přepsat bloky |
{ifset blockname} … {/ifset} |
podmínka, zda existuje blok |
{try} … {else} … {/try} |
zachycení výjimek |
{rollback} |
zahození bloku try |
{var $foo = value} |
vytvoří proměnnou |
{default $foo = value} |
vytvoří proměnnou, pokud neexistuje |
{parameters} |
deklaruje proměnné, typy a výchozí hodnoty |
{capture} … {/capture} |
zachytí blok do proměnné |
{varType} |
deklaruje typ proměnné |
{varPrint} |
navrhne typy proměnných |
{templateType} |
deklaruje typy proměnných podle třídy |
{templatePrint} |
navrhne třídu s typy proměnných |
{_...} |
vypíše překlad |
{translate} … {/translate} |
přeloží obsah |
{contentType} |
přepne escapování a pošle HTTP hlavičku |
{debugbreak} |
umístí do kódu breakpoint |
{do} |
vykoná kód, ale nic nevypíše |
{dump} |
dumpuje proměnné do Tracy Bar |
{php} |
vykoná jakýkoliv PHP kód |
{spaceless} … {/spaceless} |
odstraní nadbytečné mezery |
{syntax} |
změna syntaxe za běhu |
{trace} |
zobrazí stack trace |
n:class |
dynamický zápis HTML atributu class |
n:attr |
dynamický zápis jakýchkoliv HTML atributů |
n:tag |
dynamický zápis jména HTML elementu |
n:ifcontent |
vynechá prázdný HTML tag |
n:href |
odkaz používaný v HTML elementech
<a> |
{link} |
vypíše odkaz |
{plink} |
vypíše odkaz na presenter |
{control} |
vykreslí komponentu |
{snippet} … {/snippet} |
výstřižek, který lze odeslat AJAXem |
{snippetArea} |
obálka pro výstřižky |
{cache} … {/cache} |
cachuje část šablony |
{form} … {/form} |
vykreslí značky formuláře |
{label} … {/label} |
vykreslí popisku formulářového prvku |
{input} |
vykreslí formulářový prvek |
{inputError} |
vypíše chybovou hlášku formulářového prvku |
n:name |
oživí formulářový prvek |
{formContainer} … {/formContainer} |
kreslení formulářového kontejneru |
Vypisování
{$var} {...} {=...}
V Latte se používá značka {=...} pro výpis jakéhokoliv výrazu na výstup. Latte záleží na vašem
pohodlí, takže pokud výraz začíná proměnnou nebo voláním funkce, není potřeba rovnítko psát. Což v praxi znamená,
že ho není potřeba psát téměř nikdy:
Jméno: {$name} {$surname}<br>
Věk: {date('Y') - $birth}<br>
Jako výraz můžete zapsat cokoliv, co znáte z PHP. Nemusíte se zkrátka učit nový jazyk. Tak třeba:
{='0' . ($num ?? $num * 3) . ', ' . PHP_VERSION}
Prosím, nehledejte v předchozím příkladu žádný smysl, ale kdybyste tam nějaký našli, napište nám :-)
Escapování výstupu
Jaký je nejdůležitější úkol šablonovacího systému? Zamezit bezpečnostním dírám. A přesně tohle dělá Latte vždy, když něco vypisujete. Automaticky to escapuje:
<p>{='one < two'}</p> {* vypíše: '<p>one < two</p>' *}
Abychom byli přesní, Latte používá kontextově sensitivně escapování, což je tak důležitá a unikátní věc, že jsme tomu věnovali samostatnou kapitolu.
A co když vypisujte obsah kódovaný v HTML z důvěryhodného zdroje? Pak lze snadno escapování vypnout:
{$trustedHtmlString|noescape}
Špatné použití filtru noescape může vést ke vzniku zranitelnosti XSS! Nikdy jej
nepoužívejte, pokud si nejste zcela jisti co děláte, a že vypisovaný řetězec pochází z důvěryhodného
zdroje.
Vypsání v JavaScriptu
Díky kontextově sensitivnímu escapování je nádherně snadné vypisovat proměnné uvnitř JavaScriptu a správné escapování zařídí Latte.
Proměnná nemusí být jen řetězec, podporován je kterýkoliv datový typ, který se pak zakóduje jako JSON:
{var $foo = ['hello', true, 1]}
<script>
alert({$foo});
</script>
Vygeneruje:
<script>
alert(["hello", true, 1]);
</script>
To je také důvod, proč se kolem proměnné nepíší uvozovky: Latte je u řetězců doplní samo. A pokud byste chtěli řetězcovou proměnnou vložit do jiného řetězce, jednoduše je spojte:
<script>
alert('Hello ' + {$name} + '!'); // OK
alert({="Hello $name!"}); // OK
alert('Hello {$name} !'); // CHYBA!
</script>
Filtry
Vypsaný výraz může být upraven filtrem. Takto třeba řetězec převedeme na velká písmena a zkrátíme na maximálně 30 znaků:
{$string|upper|truncate:30}
Filtry můžete používat i na dílčí části výrazu tímto způsobem:
{$left . ($middle|upper) . $right}
Podmínky
{if} {elseif} {else}
Podmínky se chovají stejně, jako jejich protějšky v PHP. Můžete v nich používat i stejné výrazy, jaké znáte z PHP, nemusíte se učit nový jazyk.
{if $product->inStock > Stock::Minimum}
Skladem
{elseif $product->isOnWay()}
Na cestě
{else}
Není dostupné
{/if}
Jako každou párovou značku, tak i dvojici {if} ... {/if} lze zapisovat i v podobě n:attributu, například:
<p n:if="$count > 0">Skladem {$count} kusů</p>
Víte, že k n:atributům můžete připojit prefix tag-? Pak se bude podmínka vztahovat jen na vypsání HTML
značek a obsah mezi nimi se vypíše vždycky:
<a href="..." n:tag-if="$clickable">Hello</a>
{* vypíše 'Hello' když $clickable je nepravdivá *}
{* vypíše '<a href="...">Hello</a>' když $clickable je pravdivá *}
Boží.
n:else
Pokud podmínku {if} ... {/if} zapíšete v podobě n:attributu, máte
možnost uvést i alternativní větev pomocí n:else:
<strong n:if="$count > 0">Skladem {$count} kusů</strong>
<em n:else>není dostupné</em>
Atribut n:else použít také ve dvojici s n:ifset, n:foreach, n:try, n:ifcontent a n:ifchanged.
{/if $cond}
Možná vás překvapí, že výraz v podmínce {if} lze uvést také v ukončovací značce. To se hodí
v situacích, kdy při otevírání podmínky ještě jeho hodnotu neznáme. Říkejme tomu odložené rozhodnutí.
Například začneme vypisovat tabulku se záznamy z databáze a teprve po dokončení výpisu si uvědomíme, že
v databázi žádný záznam nebyl. Tak dáme na to podmínku do koncové značky {/if} a pokud žádný záznam
nebude, nic z toho se nevypíše:
{if}
<h1>Výpis řádků z databáze</h1>
<table>
{foreach $resultSet as $row}
...
{/foreach}
</table>
{/if isset($row)}
Šikovné, že?
V odložené podmínce lze použít i {else}, ale nikoliv {elseif}.
{ifset} {elseifset}
Viz také {ifset block}
Pomocí podmínky {ifset $var} zjistíme, zda proměnná (nebo více proměnných) existuje a má
nenullovou hodnotu. Vlastně jde o totéž, jako if (isset($var)) v PHP. Jako každou párovou značku ji
lze zapisovat i v podobě n:attributu, tak si to ukažme jako příklad:
<meta name="robots" content={$robots} n:ifset="$robots">
{ifchanged}
{ifchanged} zkontroluje, zda se hodnota proměnné změnila od poslední iterace ve smyčce (foreach, for nebo
while).
Pokud ve značce uvedeme jednu či více proměnných, bude kontrolovat, zda se nějaká z nich změnila, a podle toho vypíše obsah. Například následující příklad vypíše první písmenko jména jako nadpis pokaždé, když se při výpisu jmen změní:
{foreach ($names|sort) as $name}
{ifchanged $name[0]} <h2>{$name[0]}</h2> {/ifchanged}
<p>{$name}</p>
{/foreach}
Pokud však neuvedeme žádný argument, bude se kontrolovat vykreslený obsah oproti jeho předchozímu stavu. To znamená, že v předchozím příkladě můžeme klidně argument ve značce vynechat. A samozřejmě také můžeme použít n:attribut:
{foreach ($names|sort) as $name}
<h2 n:ifchanged>{$name[0]}</h2>
<p>{$name}</p>
{/foreach}
Uvnitř {ifchanged} lze také uvést klauzuli {else}.
{switch} {case} {default}
Porovnává hodnotu s více možnostmi. Jde o obdobu podmíněnému příklazu switch, který znáte z PHP.
Nicméně Latte jej vylepšuje:
- používá striktní porovnání (
===) - nepotřebuje
break
Je to tedy přesný ekvivalent struktury match se kterou přichází PHP 8.0.
{switch $transport}
{case train}
Vlakem
{case plane}
Letecky
{default}
Jinak
{/switch}
Klauzule {case} může obsahovat více hodnot oddělených čárkami:
{switch $status}
{case $status::New}<b>nová položka</b>
{case $status::Sold, $status::Unknown}<i>není dostupná</i>
{/switch}
Cykly
V Latte najdete všechny cykly, které znáte z PHP: foreach, for a while.
{foreach}
Cyklus zapíšeme úplně stejně jako v PHP:
{foreach $langs as $code => $lang}
<span>{$lang}</span>
{/foreach}
Navíc má několik šikovných vychytávek, o kterých si nyní povíme.
Latte třeba kontroluje, zda vytvořené proměnné omylem nepřepisují globální proměnné téhož jména. Zachrání to
situace, kdy počítáte s tím, že v $lang je aktuální jazyk stránky, a neuvědomíte si, že
foreach $langs as $lang vám tu proměnnou přepsalo.
Cyklus foreach lze také velmi elegantně a úsporně zapsat pomocí n:attributu:
<ul>
<li n:foreach="$items as $item">{$item->name}</li>
</ul>
Víte, že k n:atributům můžete připojit prefix inner-? Pak se bude ve smyčce opakovat pouze vnitřek
elementu:
<div n:inner-foreach="$items as $item">
<h4>{$item->title}</h4>
<p>{$item->description}</p>
</div>
Takže se vypíše něco jako:
<div>
<h4>Foo</h4>
<p>Lorem ipsum.</p>
<h4>Bar</h4>
<p>Sit dolor.</p>
</div>
{else}
Uvnitř cyklu foreach může uvést klauzuli {else}, jejíž obsah se zobrazí, pokud je cyklus
prázdný:
<ul>
{foreach $people as $person}
<li>{$person->name}</li>
{else}
<li><em>Litujeme, v tomto seznamu nejsou žádní uživatelé</em></li>
{/foreach}
</ul>
$iterator
Uvnitř cyklu foreach vytvoří Latte proměnnou $iterator, pomocí které můžeme zjišťovat
užitečné informace o probíhajícím cyklu:
$iterator->first– prochází se cyklem poprvé?$iterator->last– jde o poslední průchod?$iterator->counter– kolikátý je to průchod počítáno od jedné?$iterator->counter0– kolikátý je to průchod počítáno od nuly?$iterator->odd– jde o lichý průchod?$iterator->even– jde o sudý průchod?$iterator->parent– iterátor obklopující ten aktuální$iterator->nextValue– následující položka v cyklu$iterator->nextKey– klíč následující položky v cyklu
{foreach $rows as $row}
{if $iterator->first}<table>{/if}
<tr id="row-{$iterator->counter}">
<td>{$row->name}</td>
<td>{$row->email}</td>
</tr>
{if $iterator->last}</table>{/if}
{/foreach}
Latte je mazané a $iterator->last funguje nejen u polí, ale i když cyklus probíhá nad obecným
iterátorem, kde není dopředu znám počet položek.
{first} {last} {sep}
Tyto značky lze používat uvnitř cyklu {foreach}. Obsah {first} se vykreslí, pokud jde o první
průchod. Obsah {last} se vykreslí … jestlipak to uhádnete? Ano, pokud jde o poslední průchod. Jde vlastně
o zkratky pro {if $iterator->first} a {if $iterator->last}.
Značky lze také elegantně použít jako n:attribut:
{foreach $rows as $row}
{first}<h1>List of names</h1>{/first}
<p>{$row->name}</p>
<hr n:last>
{/foreach}
Obsah značky {sep} se vykreslí, pokud průchod není poslední, hodí se tedy pro vykreslování oddělovačů,
například čárek mezi vypisovanými položkami:
{foreach $items as $item} {$item} {sep}, {/sep} {/foreach}
To je docela praktické, že?
{iterateWhile}
Zjednodušuje seskupování lineárních dat během iterování v cyklu foreach tím, že iteraci provádí ve vnořené smyčce, dokud je splněná podmínka. Přečtěte si návod.
Může také elegantně nahradit {first} a {last} v příkladu výše:
{foreach $rows as $row}
<table>
{iterateWhile}
<tr id="row-{$iterator->counter}">
<td>{$row->name}</td>
<td>{$row->email}</td>
</tr>
{/iterateWhile true}
</table>
{/foreach}
{for}
Cyklus zapisujeme úplně stejně jako v PHP:
{for $i = 0; $i < 10; $i++}
<span>Položka {$i}</span>
{/for}
Značku lze také použít jako n:attribut:
<h1 n:for="$i = 0; $i < 10; $i++">{$i}</h1>
{while}
Cyklus opět zapisujeme úplně stejně jako v PHP:
{while $row = $result->fetch()}
<span>{$row->title}</span>
{/while}
Nebo jako n:attribut:
<span n:while="$row = $result->fetch()">
{$row->title}
</span>
Je možná i varianta s podmínkou v koncové značce, která odpovídá v PHP cyklu do-while:
{while}
<span>{$item->title}</span>
{/while $item = $item->getNext()}
{continueIf} {skipIf} {breakIf}
Pro řízení jakéhokoliv cyklu lze používat značky {continueIf ?} a {breakIf ?}, které přejdou
na další prvek resp. ukončí cyklus při splnění podmínky:
{foreach $rows as $row}
{continueIf $row->date < $now}
{breakIf $row->parent === null}
...
{/foreach}
Značka {skipIf} je velmi podobná jako {continueIf}, ale nezvyšuje počítadlo
$iterator->counter, takže pokud jej vypisujeme a zároveň přeskočíme některé položky, nebudou
v číslování díry. A také klauzule {else} se vykreslí, když přeskočíme všechny položky.
<ul>
{foreach $people as $person}
{skipIf $person->age < 18}
<li>{$iterator->counter}. {$person->name}</li>
{else}
<li><em>Litujeme, v tomto seznamu nejsou žádní dospělí</em></li>
{/foreach}
</ul>
{exitIf}
Ukončí vykreslování šablony nebo bloku při splnění podmínky (tzv. „early exit“).
{exitIf !$messages}
<h1>Messages</h1>
<div n:foreach="$messages as $message">
{$message}
</div>
Vložení šablony
{include 'file.latte'}
Viz také {include block}
Značka {include} načte a vykreslí uvedenou šablonu. Pokud bychom se bavili v řeči našeho oblíbeného
jazyka PHP, je to něco jako:
<?php include 'header.phtml'; ?>
Vložené šablony nemají přístup k proměnným aktivního kontextu, mají přístup jen ke globálním proměnným.
Proměnné do vložené šablony můžete předávat tímto způsobem:
{include 'template.latte', foo: 'bar', id: 123}
Název šablony může být jakákoliv výraz v PHP:
{include $someVar}
{include $ajax ? 'ajax.latte' : 'not-ajax.latte'}
Vložený obsah lze upravit pomocí filtrů. Následující příklad odebere všechno HTML a upraví velikost písmen:
<title>{include 'heading.latte' |stripHtml|capitalize}</title>
Defaultně dědičnost šablon v tomto případě nijak nefiguruje. I když
v inkludované šabloně můžeme používat bloky, nedojde k nahrazení odpovídajících bloků v šabloně, do které se
inkluduje. Přemýšlejte o inkludovaných šabloných jako samostatných odstíněných částech stránek nebo modulů. Toto
chování se dá změnit pomocí modifikátoru with blocks:
{include 'template.latte' with blocks}
Vztah mezi názvem souboru uvedeným ve značce a souborem na disku je věcí loaderu.
{sandbox}
Při vkládání šablony vytvořené koncovým uživatelem byste měli zvážit sandbox režim (více informací v dokumentaci sandboxu):
{sandbox 'untrusted.latte', level: 3, data: $menu}
{block}
Viz také {block name}
Bloky bez jména slouží jako způsob jak aplikovat filtry na část šablony. Například takto lze aplikovat filtr strip, který odstraní zbytečné mezery:
{block|strip}
<ul>
<li>Hello World</li>
</ul>
{/block}
Řízení výjimek
{try}
Díky této značce je extrémně snadné vytvářet robustní šablony.
Pokud při vykreslování bloku {try} dojde k výjimce, celý blok se zahodí a vykreslování bude pokračovat
až po něm:
{try}
<ul>
{foreach $twitter->loadTweets() as $tweet}
<li>{$tweet->text}</li>
{/foreach}
</ul>
{/try}
Obsah ve volitelné klauzuli {else} se vykreslí jen když nastane výjimka:
{try}
<ul>
{foreach $twitter->loadTweets() as $tweet}
<li>{$tweet->text}</li>
{/foreach}
</ul>
{else}
<p>Je nám líto, nepodařilo se načíst tweety.</p>
{/try}
Značku lze také použít jako n:attribut:
<ul n:try>
...
</ul>
Je také možné definovat vlastní obslužný handler pro výjimky, například kvůli logování.
{rollback}
Blok {try} lze zastavit a přeskočit také ručně pomocí {rollback}. Díky tomu nemusíte předem
kontrolovat všechna vstupní data a až během vykreslování se můžete rozhodnout, že objekt nechcete vůbec vykreslit:
{try}
<ul>
{foreach $people as $person}
{skipIf $person->age < 18}
<li>{$person->name}</li>
{else}
{rollback}
{/foreach}
</ul>
{/try}
Proměnné
{var} {default}
Nové proměnné vytvoříme v šabloně značkou {var}:
{var $name = 'John Smith'}
{var $age = 27}
{* Vícenásobná deklarace *}
{var $name = 'John Smith', $age = 27}
Značka {default} funguje podobně s tím rozdílem, že vytváří proměnné jen tehdy, pokud neexistují:
{default $lang = 'cs'}
Můžete uvádět i typy proměnných. Zatím jsou informativní a Latte je nekontroluje.
{var string $name = $article->getTitle()}
{default int $id = 0}
{parameters}
Tak jako funkce deklaruje své parametry, může i šablona na začátku deklarovat své proměnné:
{parameters
$a,
?int $b,
int|string $c = 10
}
Proměnné $a a $b bez uvedené výchozí hodnoty mají automaticky výchozí hodnotu
null. Deklarované typy jsou zatím informativní a Latte je nekontroluje.
Jiné proměnné než deklarované se do šablony nepřenášejí. Tím se liší od značky {default}.
{capture}
Zachytí výstup do proměnné:
{capture $var}
<ul>
<li>Hello World</li>
</ul>
{/capture}
<p>Captured: {$var}</p>
Značku lze, podobně jako každou párovou značku, zapsat také jako n:attribut:
<ul n:capture="$var">
<li>Hello World</li>
</ul>
HTML výstup se do proměnné $var uloží v podobě objektu Latte\Runtime\Html, aby nedošlo k nežádoucímu escapování při vypsání.
Ostatní
{contentType}
Značkou určíte, jaký typ obsahu šablona představuje. Možnosti jsou:
html(výchozí typ)xmljavascriptcsscalendar(iCal)text
Její použití je důležité, protože nastaví kontextově
sensitivní escapování a jen tak může escapovat správně. Například {contentType xml} přepne do režimu
XML, {contentType text} escapování zcela vypne.
Pokud je parametrem plnohodnotný MIME type, jako například application/xml, tak ještě navíc odešle HTTP
hlavičku Content-Type do prohlížeče:
{contentType application/xml}
<?xml version="1.0"?>
<rss version="2.0">
<channel>
<title>RSS feed</title>
<item>
...
</item>
</channel>
</rss>
{debugbreak}
Označuje místo, kde dojde k pozastavení běhu programu a spuštění debuggeru, aby mohl programátor provést inspekci běhového prostředí a zjistit, zda program funguje podle očekávání. Podporuje Xdebug. Lze doplnit podmínku, která určuje, kdy má být program pozastaven.
{debugbreak} {* pozastaví program *}
{debugbreak $counter == 1} {* pozastaví program při splnění podmínky *}
{do}
Vykoná PHP kód a nic nevypisuje. Stejně jako u všech dalších značek se PHP kódem rozumí jeden výraz, viz omezení PHP.
{do $num++}
{dump}
Vypíše proměnnou nebo aktuální kontext.
{dump $name} {* Vypíše proměnnou $name *}
{dump} {* Vypíše všechny aktuálně definované proměnné *}
Vyžaduje knihovnu Tracy.
{php}
Umožňuje vykonat jakýkoliv PHP kód. Značku je nutné aktivovat pomocí rozšíření RawPhpExtension.
{spaceless}
Odstraní zbytečné bílé místo z výstupu. Funguje podobně jako filtr spaceless.
{spaceless}
<ul>
<li>Hello</li>
</ul>
{/spaceless}
Vygeneruje
<ul> <li>Hello</li> </ul>
Značku lze také zapsat jako n:attribut.
{syntax}
Latte značky nemusejí být ohraničeny pouze do jednoduchých složených závorek. Můžeme si zvolit i jiný oddělovač a
to dokonce za běhu. Slouží k tomu {syntax …}, kde jako parametr lze uvést:
- double:
{{...}} - off: zcela vypne zpracování Latte značek
S využitím n:atributů lze vypnout Latte třeba jen jednomu bloku JavaScriptu:
<script n:syntax="off">
var obj = {var: 123}; // tohle už není tag
</script>
Latte lze velmi pohodlně používat i uvnitř JavaScriptu, jen se stačí vynout konstrukcím jako v tomto příkladě, kdy
následuje písmeno hned za {, viz Latte uvnitř
JavaScriptu nebo CSS.
Pokud Latte vypnete pomocí {syntax off} (tj. značkou, nikoliv n:atributem), bude důsledně ignorovat všechny
značky až do {/syntax}
{trace}
Vyhodí výjimku Latte\RuntimeException, jejíž stack trace se nese v duchu šablon. Tedy místo volání
funkcí a metod obsahuje volání bloků a vkládání šablon. Pokud používáte nástroj pro přehledné zobrazení vyhozených
výjimek, jako je například Tracy, přehledně se vám zobrazí call stack včetně
všech předávaných argumentů.
Pomocníci HTML kodéra
n:class
Díky n:class velice snadno vygenerujete HTML atribut class přesně podle představ.
Příklad: potřebuji, aby aktivní prvek měl třídu active:
{foreach $items as $item}
<a n:class="$item->isActive() ? active">...</a>
{/foreach}
A dále, aby první prvek měl třídy first a main:
{foreach $items as $item}
<a n:class="$item->isActive() ? active, $iterator->first ? 'first main'">...</a>
{/foreach}
A všechny prvky mají mít třídu list-item:
{foreach $items as $item}
<a n:class="$item->isActive() ? active, $iterator->first ? 'first main', list-item">...</a>
{/foreach}
Úžasně jednoduché, že?
n:attr
Atribut n:attr umí se stejnou elegancí jako má n:class generovat libovolné HTML
atributy.
{foreach $data as $item}
<input type="checkbox" n:attr="value: $item->getValue(), checked: $item->isActive()">
{/foreach}
V závislosti na vrácených hodnotách vypíše např.:
<input type="checkbox">
<input type="checkbox" value="Hello">
<input type="checkbox" value="Hello" checked>
n:tag
Atribut n:tag umí dynamicky měnit název HTML elementu.
<h1 n:tag="$heading" class="main">{$title}</h1>
Pokud je $heading === null, vypíše se beze změny tag <h1>. Jinak se změní název elementu
na hodnotu proměnné, takže pro $heading === 'h3' se vypíše:
<h3 class="main">...</h3>
Protože Latte je bezpečný šablonovací systém, kontroluje, zda je nový název značky platný a neobsahuje žádné nežádoucí nebo škodlivé hodnoty.
n:ifcontent
Předchází tomu, aby se vypsal prázdný HTML element, tj. element neobsahující nic než mezery.
<div>
<div class="error" n:ifcontent>{$error}</div>
</div>
Vypíše v závislosti na hodnotě proměnné $error:
{* $error = '' *}
<div>
</div>
{* $error = 'Required' *}
<div>
<div class="error">Required</div>
</div>
Překlady
Aby značky pro překlad fungovaly, je potřeba aktivovat překladač. Pro
překlad můžete také použít filtr translate.
{_...}
Překládá hodnoty do jiných jazyků.
<a href="basket">{_'Košík'}</a>
<span>{_$item}</span>
Překladači lze předávat i další parametry:
<a href="basket">{_'Košík', domain: order}</a>
{translate}
Překládá části šablony:
<h1>{translate}Objednávka{/translate}</h1>
{translate domain: order}Lorem ipsum ...{/translate}
Značku lze také zapsat jako n:attribut, pro překlad vnitřku elementu:
<h1 n:translate>Objednávka</h1>