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.

Vypisování
{$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 }
Podmínky
{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
Cykly
{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
Vložení dalších šablon
{include 'file.latte'} načte šablonu z dalšího souboru
{sandbox 'file.latte'} načte šablonu v sandbox režimu
Bloky, layouty, dědičnost šablon
{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
Řízení výjimek
{try}{else}{/try} zachycení výjimek
{rollback} zahození bloku try
Proměnné
{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é
Typy
{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
Překlady
{_...} vypíše překlad
{translate}{/translate} přeloží obsah
Ostatní
{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
Pomocníci HTML kodéra
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
Dostupné pouze v Nette Frameworku
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
Dostupné pouze s Nette Forms
{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 &lt; 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)
  • xml
  • javascript
  • css
  • calendar (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>
verze: 3.0 2.x