Latte tagek
A Latte sablonrendszer összes tagjének áttekintése és leírása, amelyek alapértelmezés szerint rendelkezésre állnak.
{$var}, {...} vagy {=...} |
kiírja az escapelt változót vagy kifejezést |
{$var|filter} |
szűrők használatával írja ki |
{l} vagy {r} |
kiírja a { vagy } karaktert |
{if} … {elseif} … {else} … {/if} |
if feltétel |
{ifset} … {elseifset} … {/ifset} |
ifset feltétel |
{ifchanged} … {/ifchanged} |
teszteli, hogy történt-e változás |
{switch} {case} {default} {/switch} |
switch feltétel |
n:else |
alternatív tartalom feltételekhez |
{foreach} … {/foreach} |
foreach |
{for} … {/for} |
for |
{while} … {/while} |
while |
{continueIf $cond} |
folytatás a következő iterációval |
{skipIf $cond} |
iteráció kihagyása |
{breakIf $cond} |
ciklus megszakítása |
{exitIf $cond} |
korai kilépés |
{first} … {/first} |
ez az első futás? |
{last} … {/last} |
ez az utolsó futás? |
{sep} … {/sep} |
lesz még következő futás? |
{iterateWhile} … {/iterateWhile} |
strukturált foreach |
$iterator |
speciális változó a foreach-en belül |
{include 'file.latte'} |
betölti a sablont egy másik fájlból |
{sandbox 'file.latte'} |
betölti a sablont sandbox módban |
{block} |
névtelen blokk |
{block blockname} |
definiál egy blokkot |
{define blockname} |
definiál egy blokkot későbbi használatra |
{include blockname} |
blokk megjelenítése |
{include blockname from 'file.latte'} |
megjeleníti a blokkot egy fájlból |
{import 'file.latte'} |
betölti a blokkokat egy sablonból |
{layout 'file.latte'} / {extends} |
meghatározza a layout fájlt |
{embed} … {/embed} |
betölt egy sablont vagy blokkot és lehetővé teszi a blokkok felülírását |
{ifset blockname} … {/ifset} |
feltétel, hogy létezik-e a blokk |
{try} … {else} … {/try} |
kivételek elkapása |
{rollback} |
a try blokk eldobása |
{var $foo = value} |
létrehoz egy változót |
{default $foo = value} |
létrehoz egy változót, ha nem létezik |
{parameters} |
deklarálja a változókat, típusokat és alapértelmezett értékeket |
{capture} … {/capture} |
elkapja a blokkot egy változóba |
{varType} |
deklarálja a változó típusát |
{varPrint} |
javaslatot tesz a változók típusaira |
{templateType} |
deklarálja a változók típusait egy osztály szerint |
{templatePrint} |
javaslatot tesz egy osztályra a változók típusaival |
{_...} |
kiírja a fordítást |
{translate} … {/translate} |
lefordítja a tartalmat |
{contentType} |
átkapcsolja az escapelést és HTTP fejlécet küld |
{debugbreak} |
breakpointet helyez el a kódban |
{do} |
végrehajtja a kódot, de semmit sem ír ki |
{dump} |
dumpolja a változókat a Tracy Bar-ba |
{php} |
végrehajt bármilyen PHP kódot |
{spaceless} … {/spaceless} |
eltávolítja a felesleges szóközöket |
{syntax} |
szintaxis váltás futás közben |
{trace} |
megjeleníti a stack trace-t |
n:class |
dinamikus HTML class attribútum írás |
n:attr |
dinamikus bármilyen HTML attribútum írás |
n:tag |
dinamikus HTML elem név írás |
n:ifcontent |
kihagyja az üres HTML taget |
n:href |
link, amelyet <a>
HTML elemekben használnak |
{link} |
kiír egy linket |
{plink} |
kiír egy linket egy presenterhez |
{control} |
megjelenít egy komponenst |
{snippet} … {/snippet} |
kivágat, amelyet AJAX-szal lehet küldeni |
{snippetArea} |
burkoló kivágatokhoz |
{cache} … {/cache} |
gyorsítótárazza a sablon egy részét |
{form} … {/form} |
megjeleníti az űrlap tageket |
{label} … {/label} |
megjeleníti az űrlap elem címkéjét |
{input} |
megjeleníti az űrlap elemet |
{inputError} |
kiírja az űrlap elem hibaüzenetét |
n:name |
életre kelti az űrlap elemet |
{formContainer} … {/formContainer} |
űrlap konténer rajzolása |
{asset} |
egy eszköz HTML elemként vagy URL-ként való megjelenítése |
{preload} |
előbetöltési tippeket generál a teljesítmény optimalizálásához. |
n:asset |
eszközattribútumokat ad a HTML-elemekhez. |
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 < 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)xmljavascriptcsscalendar(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 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>