Latte tagek

A Latte sablonrendszer összes tagjének áttekintése és leírása, amelyek alapértelmezés szerint rendelkezésre állnak.

Kiírás

{$var} {...} {=...}

A Latte-ban a {=...} taget használjuk bármilyen kifejezés kiírására a kimenetre. A Latte törődik a kényelmével, így ha a kifejezés változóval vagy függvényhívással kezdődik, nem szükséges az egyenlőségjelet írni. Ami a gyakorlatban azt jelenti, hogy szinte soha nem kell írni:

Név: {$name} {$surname}<br>
Kor: {date('Y') - $birth}<br>

Kifejezésként bármit leírhat, amit PHP-ból ismer. Egyszerűen nem kell új nyelvet tanulnia. Így például:

{='0' . ($num ?? $num * 3) . ', ' . PHP_VERSION}

Kérjük, ne keressen semmi értelmet az előző példában, de ha találna benne valamit, írjon nekünk :-)

Kimenet escapelése

Mi a sablonrendszer legfontosabb feladata? Megakadályozni a biztonsági réseket. És pontosan ezt teszi a Latte mindig, amikor valamit kiír. Automatikusan escapeli:

<p>{='egy < kettő'}</p>   {* kiírja: '<p>egy &lt; kettő</p>' *}

Hogy pontosak legyünk, a Latte kontextusérzékeny escapelést használ, ami olyan fontos és egyedi dolog, hogy külön fejezetet szenteltünk neki.

És mi van, ha megbízható forrásból származó HTML-kódolt tartalmat ír ki? Akkor könnyen kikapcsolható az escapelés:

{$trustedHtmlString|noescape}

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.

Kiírás JavaScriptben

A kontextusérzékeny escapelésnek köszönhetően csodálatosan egyszerű a változók kiírása JavaScripten belül, és a helyes escapelést a Latte elintézi.

A változó nemcsak string lehet, bármely adattípus támogatott, amely aztán JSON-ként kódolódik:

{var $foo = ['hello', true, 1]}
<script>
	alert({$foo});
</script>

Generálja:

<script>
	alert(["hello", true, 1]);
</script>

Ez az oka annak is, hogy a változó köré nem írnak idézőjeleket: a Latte a stringeknél automatikusan hozzáadja őket. És ha egy string változót egy másik stringbe szeretne beilleszteni, egyszerűen fűzze össze őket:

<script>
	alert('Hello ' + {$name} + '!');  // OK

	alert({="Hello $name!"});         // OK

	alert('Hello {$name} !');         // HIBA!
</script>

Szűrők

A kiírt kifejezést módosíthatja szűrővel. Így például egy stringet nagybetűssé alakíthatunk és maximum 30 karakterre rövidíthetünk:

{$string|upper|truncate:30}

A szűrőket a kifejezés részeire is alkalmazhatja így:

{$left . ($middle|upper) . $right}

Feltételek

{if} {elseif} {else}

A feltételek ugyanúgy viselkednek, mint PHP megfelelőik. Használhatja bennük ugyanazokat a kifejezéseket, amelyeket PHP-ból ismer, nem kell új nyelvet tanulnia.

{if $product->inStock > Stock::Minimum}
	Raktáron
{elseif $product->isOnWay()}
	Úton
{else}
	Nem elérhető
{/if}

Mint minden páros taget, úgy az {if} ... {/if} párt is lehet n:attributumként írni, például:

<p n:if="$count > 0">Raktáron {$count} darab</p>

Tudta, hogy az n:attribútumokhoz csatolhat tag- előtagot? Akkor a feltétel csak a HTML tagek kiírására vonatkozik, és a köztük lévő tartalom mindig kiíródik:

<a href="..." n:tag-if="$clickable">Hello</a>

{* kiírja 'Hello', ha $clickable hamis *}
{* kiírja '<a href="...">Hello</a>', ha $clickable igaz *}

Nagyszerű.

n:else

Ha az {if} ... {/if} feltételt n:attributumként írja, lehetősége van alternatív ágat is megadni az n:else segítségével:

<strong n:if="$count > 0">Raktáron {$count} darab</strong>

<em n:else>nem elérhető</em>

Az n:else attribútumot párban is használhatja a n:ifset, n:foreach, n:try, n:ifcontent és n:ifchanged attribútumokkal.

{/if $cond}

Talán meglepő, hogy az {if} feltételben lévő kifejezést a záró tagben is meg lehet adni. Ez olyan helyzetekben hasznos, amikor a feltétel megnyitásakor még nem ismerjük az értékét. Nevezzük ezt elhalasztott döntésnek.

Például elkezdünk kiírni egy táblázatot adatbázis-rekordokkal, és csak a kiírás befejezése után vesszük észre, hogy az adatbázisban nem volt rekord. Így a feltételt a {/if} záró tagbe tesszük, és ha nincs rekord, semmi sem íródik ki:

{if}
	<h1>Adatbázis sorainak listája</h1>

	<table>
	{foreach $resultSet as $row}
		...
	{/foreach}
	</table>
{/if isset($row)}

Ügyes, igaz?

Az elhalasztott feltételben használható {else}, de {elseif} nem.

{ifset} {elseifset}

Lásd még {ifset block}

Az {ifset $var} feltétellel megállapíthatjuk, hogy egy változó (vagy több változó) létezik-e és nem null értékű-e. Valójában ugyanaz, mint az if (isset($var)) PHP-ban. Mint minden páros taget, ezt is lehet n:attributumként írni, mutassuk be példaként:

<meta name="robots" content={$robots} n:ifset="$robots">

{ifchanged}

Az {ifchanged} ellenőrzi, hogy a változó értéke megváltozott-e a ciklus (foreach, for vagy while) utolsó iterációja óta.

Ha a tagben egy vagy több változót adunk meg, ellenőrzi, hogy valamelyikük megváltozott-e, és ennek megfelelően írja ki a tartalmat. Például a következő példa a név első betűjét írja ki címként minden alkalommal, amikor a nevek kiírása során megváltozik:

{foreach ($names|sort) as $name}
	{ifchanged $name[0]} <h2>{$name[0]}</h2> {/ifchanged}

	<p>{$name}</p>
{/foreach}

Ha azonban nem adunk meg argumentumot, a megjelenített tartalmat hasonlítja össze az előző állapotával. Ez azt jelenti, hogy az előző példában nyugodtan elhagyhatjuk az argumentumot a tagben. És természetesen használhatunk n:attributumot is:

{foreach ($names|sort) as $name}
	<h2 n:ifchanged>{$name[0]}</h2>

	<p>{$name}</p>
{/foreach}

Az {ifchanged}-en belül {else} klauzulát is meg lehet adni.

{switch} {case} {default}

Összehasonlítja az értéket több lehetőséggel. Ez a PHP-ból ismert switch feltételes utasítás megfelelője. Azonban a Latte javítja:

• szigorú összehasonlítást (===) használ
• nincs szüksége break-re

Tehát pontosan megegyezik a PHP 8.0-val érkező match struktúrával.

{switch $transport}
	{case train}
		Vonattal
	{case plane}
		Repülővel
	{default}
		Másképp
{/switch}

A {case} klauzula több, vesszővel elválasztott értéket is tartalmazhat:

{switch $status}
{case $status::New}<b>új tétel</b>
{case $status::Sold, $status::Unknown}<i>nem elérhető</i>
{/switch}

Ciklusok

A Latte-ban megtalálja az összes ciklust, amelyet PHP-ból ismer: foreach, for és while.

{foreach}

A ciklust pontosan ugyanúgy írjuk, mint PHP-ban:

{foreach $langs as $code => $lang}
	<span>{$lang}</span>
{/foreach}

Ezenkívül van néhány ügyes trükkje, amelyekről most beszélünk.

A Latte például ellenőrzi, hogy a létrehozott változók véletlenül nem írják-e felül az azonos nevű globális változókat. Ez megmenti azokat a helyzeteket, amikor arra számít, hogy a $lang-ban az oldal aktuális nyelve van, és nem veszi észre, hogy a foreach $langs as $lang felülírta ezt a változót.

A foreach ciklust nagyon elegánsan és tömören is le lehet írni n:attributummal:

<ul>
	<li n:foreach="$items as $item">{$item->name}</li>
</ul>

Tudta, hogy az n:attribútumokhoz csatolhat inner- előtagot? Akkor a ciklusban csak az elem belseje ismétlődik:

<div n:inner-foreach="$items as $item">
	<h4>{$item->title}</h4>
	<p>{$item->description}</p>
</div>

Tehát valami ilyesmi íródik ki:

<div>
	<h4>Foo</h4>
	<p>Lorem ipsum.</p>
	<h4>Bar</h4>
	<p>Sit dolor.</p>
</div>

{else}

A foreach cikluson belül megadhat egy {else} klauzulát, amelynek tartalma akkor jelenik meg, ha a ciklus üres:

<ul>
	{foreach $people as $person}
		<li>{$person->name}</li>
	{else}
		<li><em>Sajnáljuk, ebben a listában nincsenek felhasználók</em></li>
	{/foreach}
</ul>

$iterator

A foreach cikluson belül a Latte létrehozza a $iterator változót, amely segítségével hasznos információkat tudhatunk meg a folyamatban lévő ciklusról:

• $iterator->first – ez az első futás a cikluson?
• $iterator->last – ez az utolsó futás?
• $iterator->counter – hányadik futás ez egytől számolva?
• $iterator->counter0 – hányadik futás ez nullától számolva?
• $iterator->odd – ez páratlan futás?
• $iterator->even – ez páros futás?
• $iterator->parent – az aktuálisat körülvevő iterátor
• $iterator->nextValue – a következő elem a ciklusban
• $iterator->nextKey – a következő elem kulcsa a ciklusban

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

A Latte okos, és a $iterator->last nemcsak tömböknél működik, hanem akkor is, ha a ciklus egy általános iterátoron fut, ahol előre nem ismert az elemek száma.

{first} {last} {sep}

Ezeket a tageket a {foreach} cikluson belül lehet használni. A {first} tartalma akkor jelenik meg, ha ez az első futás. A {last} tartalma akkor jelenik meg… kitalálja? Igen, ha ez az utolsó futás. Valójában ezek a {if $iterator->first} és {if $iterator->last} rövidítései.

A tageket elegánsan lehet n:attributumként is használni:

{foreach $rows as $row}
	{first}<h1>Nevek listája</h1>{/first}

	<p>{$row->name}</p>

	<hr n:last>
{/foreach}

A {sep} tag tartalma akkor jelenik meg, ha a futás nem az utolsó, tehát hasznos elválasztók kiírására, például vesszők a kiírt elemek között:

{foreach $items as $item} {$item} {sep}, {/sep} {/foreach}

Ez elég praktikus, igaz?

{iterateWhile}

Leegyszerűsíti a lineáris adatok csoportosítását a foreach ciklusban történő iterálás során azáltal, hogy az iterációt egy beágyazott ciklusban végzi, amíg a feltétel teljesül. Olvassa el a részletes útmutatót.

Elegánsan helyettesítheti a {first} és {last} tageket is a fenti példában:

{foreach $rows as $row}
	<table>

	{iterateWhile}
	<tr id="row-{$iterator->counter}">
		<td>{$row->name}</td>
		<td>{$row->email}</td>
	</tr>
	{/iterateWhile true}

	</table>
{/foreach}

Lásd még a batch és group szűrőket.

{for}

A ciklust pontosan ugyanúgy írjuk, mint PHP-ban:

{for $i = 0; $i < 10; $i++}
	<span>Elem {$i}</span>
{/for}

A taget n:attributumként is lehet használni:

<h1 n:for="$i = 0; $i < 10; $i++">{$i}</h1>

{while}

A ciklust ismét pontosan ugyanúgy írjuk, mint PHP-ban:

{while $row = $result->fetch()}
	<span>{$row->title}</span>
{/while}

Vagy n:attributumként:

<span n:while="$row = $result->fetch()">
	{$row->title}
</span>

Lehetséges egy változat is a feltétellel a záró tagben, amely a PHP do-while ciklusának felel meg:

{while}
	<span>{$item->title}</span>
{/while $item = $item->getNext()}

{continueIf} {skipIf} {breakIf}

Bármely ciklus vezérlésére használhatók a {continueIf ?} és {breakIf ?} tagek, amelyek a következő elemre ugranak, ill. befejezik a ciklust a feltétel teljesülésekor:

{foreach $rows as $row}
	{continueIf $row->date < $now}
	{breakIf $row->parent === null}
	...
{/foreach}

A {skipIf} tag nagyon hasonló a {continueIf}-hez, de nem növeli a $iterator->counter számlálót, így ha kiírjuk és közben kihagyunk néhány elemet, nem lesznek lyukak a számozásban. És az {else} klauzula is megjelenik, ha minden elemet kihagyunk.

<ul>
	{foreach $people as $person}
		{skipIf $person->age < 18}
		<li>{$iterator->counter}. {$person->name}</li>
	{else}
		<li><em>Sajnáljuk, ebben a listában nincsenek felnőttek</em></li>
	{/foreach}
</ul>

{exitIf}

Befejezi a sablon vagy blokk megjelenítését a feltétel teljesülésekor (ún. “early exit”).

{exitIf !$messages}

<h1>Üzenetek</h1>
<div n:foreach="$messages as $message">
   {$message}
</div>

Sablon beillesztése

{include 'file.latte'}

Lásd még {include block}

Az {include} tag betölti és megjeleníti a megadott sablont. Ha kedvenc nyelvünk, a PHP nyelvén beszélnénk, ez valami ilyesmi:

<?php include 'header.phtml'; ?>

A beillesztett sablonok nem férnek hozzá az aktív kontextus változóihoz, csak a globális változókhoz férnek hozzá.

Változókat így adhat át a beillesztett sablonnak:

{include 'template.latte', foo: 'bar', id: 123}

A sablon neve bármilyen PHP kifejezés lehet:

{include $someVar}
{include $ajax ? 'ajax.latte' : 'not-ajax.latte'}

A beillesztett tartalmat módosíthatja szűrőkkel. A következő példa eltávolít minden HTML-t és módosítja a betűméretet:

<title>{include 'heading.latte' |stripHtml|capitalize}</title>

Alapértelmezés szerint a sablonöröklődés ebben az esetben semmilyen módon nem játszik szerepet. Bár a beillesztett sablonban használhatunk blokkokat, nem történik meg a megfelelő blokkok helyettesítése abban a sablonban, amelybe beillesztjük. Gondoljon a beillesztett sablonokra mint önálló, árnyékolt oldalrészekre vagy modulokra. Ez a viselkedés megváltoztatható a with blocks módosítóval:

{include 'template.latte' with blocks}

A tagben megadott fájlnév és a lemezen lévő fájl közötti kapcsolat a loader dolga.

{sandbox}

Végfelhasználó által létrehozott sablon beillesztésekor érdemes megfontolni a sandbox módot (további információk a sandbox dokumentációjában):

{sandbox 'untrusted.latte', level: 3, data: $menu}

{block}

Lásd még {block name}

A név nélküli blokkok arra szolgálnak, hogy szűrőket alkalmazzanak a sablon egy részére. Például így lehet alkalmazni a strip szűrőt, amely eltávolítja a felesleges szóközöket:

{block|strip}
<ul>
	<li>Hello World</li>
</ul>
{/block}

Kivételkezelés

{try}

Ennek a tagnek köszönhetően rendkívül egyszerű robusztus sablonokat létrehozni.

Ha a {try} blokk megjelenítése során kivétel történik, az egész blokk eldobódik, és a megjelenítés utána folytatódik:

{try}
	<ul>
		{foreach $twitter->loadTweets() as $tweet}
  			<li>{$tweet->text}</li>
		{/foreach}
	</ul>
{/try}

Az opcionális {else} klauzula tartalma csak akkor jelenik meg, ha kivétel történik:

{try}
	<ul>
		{foreach $twitter->loadTweets() as $tweet}
  			<li>{$tweet->text}</li>
		{/foreach}
	</ul>
	{else}
	<p>Sajnáljuk, nem sikerült betölteni a tweeteket.</p>
{/try}

A taget n:attributumként is lehet használni:

<ul n:try>
	...
</ul>

Lehetőség van saját kivételkezelő handler definiálására is, például naplózás céljából.

{rollback}

A {try} blokkot manuálisan is le lehet állítani és átugrani a {rollback} segítségével. Ennek köszönhetően nem kell előre ellenőrizni az összes bemeneti adatot, és csak a megjelenítés során dönthet úgy, hogy az objektumot egyáltalán nem szeretné megjeleníteni:

{try}
<ul>
	{foreach $people as $person}
 		{skipIf $person->age < 18}
 		<li>{$person->name}</li>
	{else}
		{rollback}
	{/foreach}
</ul>
{/try}

Változók

{var} {default}

Új változókat a sablonban a {var} taggel hozunk létre:

{var $name = 'John Smith'}
{var $age = 27}

{* Többszörös deklaráció *}
{var $name = 'John Smith', $age = 27}

A {default} tag hasonlóan működik, de csak akkor hoz létre változókat, ha azok nem léteznek. Ha a változó már létezik és null értéket tartalmaz, nem íródik felül:

{default $lang = 'hu'}

Megadhat változótípusokat is. Ezek egyelőre informatívak, és a Latte nem ellenőrzi őket.

{var string $name = $article->getTitle()}
{default int $id = 0}

{parameters}

Ahogy a függvények deklarálják a paramétereiket, úgy a sablon is deklarálhatja a változóit az elején:

{parameters
	$a,
	?int $b,
	int|string $c = 10
}

Az $a és $b változók megadott alapértelmezett érték nélkül automatikusan null alapértelmezett értéket kapnak. A deklarált típusok egyelőre informatívak, és a Latte nem ellenőrzi őket.

A deklaráltakon kívül más változók nem kerülnek át a sablonba. Ebben különbözik a {default} tagtől.

{capture}

Elkapja a kimenetet egy változóba:

{capture $var}
<ul>
	<li>Hello World</li>
</ul>
{/capture}

<p>Elkapott: {$var}</p>

A taget, mint minden páros taget, n:attributumként is lehet írni:

<ul n:capture="$var">
	<li>Hello World</li>
</ul>

A HTML kimenet a $var változóba Latte\Runtime\Html objektumként kerül mentésre, hogy ne történjen nem kívánt escapelés a kiíráskor.

Egyéb

{contentType}

A taggel meghatározhatja, milyen típusú tartalmat képvisel a sablon. A lehetőségek:

• html (alapértelmezett típus)
• xml
• javascript
• css
• calendar (iCal)
• text

Használata fontos, mert beállítja a kontextusérzékeny escapelést, és csak így tud helyesen escapelni. Például a {contentType xml} átkapcsol XML módba, a {contentType text} teljesen kikapcsolja az escapelést.

Ha a paraméter egy teljes értékű MIME típus, mint például application/xml, akkor még a Content-Type HTTP fejlécet is elküldi a böngészőnek:

{contentType application/xml}
<?xml version="1.0"?>
<rss version="2.0">
	<channel>
		<title>RSS feed</title>
		<item>
			...
		</item>
	</channel>
</rss>

{debugbreak}

Jelzi azt a helyet, ahol a program futása leáll, és elindul a hibakereső, hogy a programozó megvizsgálhassa a futási környezetet, és megállapíthassa, hogy a program az elvárásoknak megfelelően működik-e. Támogatja az Xdebug-ot. Hozzáadható egy feltétel, amely meghatározza, mikor kell a programot leállítani.

{debugbreak}                {* leállítja a programot *}

{debugbreak $counter == 1}  {* leállítja a programot a feltétel teljesülésekor *}

{do}

Végrehajtja a PHP kódot, és semmit sem ír ki. Mint minden más tagnél, a PHP kód egyetlen kifejezést jelent, lásd PHP korlátozások.

{do $num++}

{dump}

Kiírja a változót vagy az aktuális kontextust.

{dump $name} {* Kiírja a $name változót *}

{dump}       {* Kiírja az összes aktuálisan definiált változót *}

Szükséges a Tracy könyvtár.

{php}

Lehetővé teszi bármilyen PHP kód végrehajtását. A taget aktiválni kell a RawPhpExtension bővítménnyel.

{spaceless}

Eltávolítja a felesleges fehér szóközt a kimenetből. Hasonlóan működik, mint a spaceless szűrő.

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

Generálja

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

A taget n:attributumként is lehet írni.

{syntax}

A Latte tageknek nem kell csak egyszerű kapcsos zárójelekkel határolva lenniük. Választhatunk más elválasztót is, akár futás közben is. Erre szolgál a {syntax …}, ahol paraméterként megadható:

• double: {{...}}
• off: teljesen kikapcsolja a Latte tagek feldolgozását

Az n:attribútumok használatával kikapcsolhatja a Latte-t például csak egy JavaScript blokkra:

<script n:syntax="off">
	var obj = {var: 123}; // ez már nem tag
</script>

A Latte nagyon kényelmesen használható JavaScripten belül is, csak kerülni kell az olyan konstrukciókat, mint ebben a példában, amikor a { jelet közvetlenül betű követi, lásd Latte JavaScripten vagy CSS-en belül.

Ha a Latte-t a {syntax off} segítségével kapcsolja ki (azaz taggel, nem n:attribútummal), akkor következetesen figyelmen kívül hagyja az összes taget a {/syntax}-ig.

{trace}

Kivált egy Latte\RuntimeException kivételt, amelynek stack trace-je a sablonok szellemében van. Tehát a függvény- és metódushívások helyett blokkok hívását és sablonok beillesztését tartalmazza. Ha olyan eszközt használ a kiváltott kivételek áttekinthető megjelenítésére, mint például a Tracy, áttekinthetően megjelenik a hívási verem, beleértve az összes átadott argumentumot.

HTML kódoló segédeszközök

n:class

Az n:class segítségével nagyon egyszerűen generálhat HTML class attribútumot pontosan az elképzelések szerint.

Példa: szükségem van arra, hogy az aktív elemnek active osztálya legyen:

{foreach $items as $item}
	<a n:class="$item->isActive() ? active">...</a>
{/foreach}

Továbbá, hogy az első elemnek first és main osztálya legyen:

{foreach $items as $item}
	<a n:class="$item->isActive() ? active, $iterator->first ? 'first main'">...</a>
{/foreach}

És minden elemnek legyen list-item osztálya:

{foreach $items as $item}
	<a n:class="$item->isActive() ? active, $iterator->first ? 'first main', list-item">...</a>
{/foreach}

Csodálatosan egyszerű, igaz?

n:attr

Az n:attr attribútum ugyanolyan eleganciával tud generálni bármilyen HTML attribútumot, mint a n:class.

{foreach $data as $item}
	<input type="checkbox" n:attr="value: $item->getValue(), checked: $item->isActive()">
{/foreach}

A visszaadott értékektől függően kiírja pl.:

<input type="checkbox">

<input type="checkbox" value="Hello">

<input type="checkbox" value="Hello" checked>

n:tag

Az n:tag attribútum dinamikusan tudja megváltoztatni a HTML elem nevét.

<h1 n:tag="$heading" class="main">{$title}</h1>

Ha $heading === null, akkor változatlanul a <h1> tag íródik ki. Ellenkező esetben az elem neve a változó értékére változik, tehát $heading === 'h3' esetén kiíródik:

<h3 class="main">...</h3>

Mivel a Latte egy biztonságos sablonrendszer, ellenőrzi, hogy az új tagnév érvényes-e, és nem tartalmaz-e nem kívánt vagy káros értékeket.

n:ifcontent

Megakadályozza, hogy üres HTML elem íródjon ki, azaz olyan elem, amely semmit sem tartalmaz a szóközökön kívül.

<div>
	<div class="error" n:ifcontent>{$error}</div>
</div>

A $error változó értékétől függően írja ki:

{* $error = '' *}
<div>
</div>

{* $error = 'Kötelező' *}
<div>
	<div class="error">Kötelező</div>
</div>

Fordítások

Ahhoz, hogy a fordítási tagek működjenek, aktiválni kell a fordítót. A fordításhoz használhatja a translate szűrőt is.

{_...}

Értékeket fordít más nyelvekre.

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

A fordítónak további paramétereket is át lehet adni:

<a href="basket">{_'Kosár', domain: order}</a>

{translate}

Lefordítja a sablon részeit:

<h1>{translate}Rendelés{/translate}</h1>

{translate domain: order}Lorem ipsum ...{/translate}

A taget n:attributumként is lehet írni, az elem belsejének fordításához:

<h1 n:translate>Rendelés</h1>