Latte Etiketleri

Size standart olarak sunulan Latte şablonlama sisteminin tüm etiketlerinin özeti ve açıklaması.

Yazdırma

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

Latte'de herhangi bir ifadeyi çıktıya yazdırmak için {=...} etiketi kullanılır. Latte rahatlığınızı önemser, bu nedenle ifade bir değişkenle veya fonksiyon çağrısıyla başlıyorsa, eşittir işareti yazmaya gerek yoktur. Bu da pratikte neredeyse hiç yazmaya gerek olmadığı anlamına gelir:

İsim: {$name} {$surname}<br>
Yaş: {date('Y') - $birth}<br>

İfade olarak PHP'den bildiğiniz her şeyi yazabilirsiniz. Yeni bir dil öğrenmenize gerek yok. Örneğin:

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

Lütfen önceki örnekte herhangi bir anlam aramayın, ancak bulursanız bize yazın :-)

Çıktı Kaçış İşlemi

Bir şablonlama sisteminin en önemli görevi nedir? Güvenlik açıklarını önlemek. Ve Latte tam olarak bunu bir şey yazdırdığınızda her zaman yapar. Otomatik olarak kaçış işlemine tabi tutar:

<p>{='one < two'}</p>   {* yazdırır: '<p>one &lt; two</p>' *}

Kesin olmak gerekirse, Latte bağlama duyarlı kaçış kullanır, bu o kadar önemli ve benzersiz bir şeydir ki, buna ayrı bölüm ayırdık.

Peki ya güvenilir bir kaynaktan HTML olarak kodlanmış içeriği yazdırıyorsanız? O zaman kaçış işlemini kolayca kapatabilirsiniz:

{$trustedHtmlString|noescape}

noescape filtresinin yanlış kullanımı XSS güvenlik açığına yol açabilir! Ne yaptığınızdan ve yazdırılan karakter dizisinin güvenilir bir kaynaktan geldiğinden tamamen emin değilseniz asla kullanmayın.

JavaScript'te Yazdırma

Bağlama duyarlı kaçış sayesinde, JavaScript içinde değişkenleri yazdırmak harika bir şekilde kolaydır ve doğru kaçış işlemini Latte halleder.

Değişken yalnızca bir karakter dizisi olmak zorunda değildir, desteklenen herhangi bir veri türü daha sonra JSON olarak kodlanır:

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

Oluşturur:

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

Bu aynı zamanda değişkenin etrafına tırnak işareti yazılmamasının nedenidir: Latte bunları karakter dizileri için kendisi ekler. Ve eğer bir karakter dizisi değişkenini başka bir karakter dizisine eklemek isterseniz, bunları basitçe birleştirin:

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

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

	alert('Merhaba {$name} !');         // HATA!
</script>

Filtreler

Yazdırılan ifade filtre ile değiştirilebilir. Örneğin, bir karakter dizisini büyük harfe dönüştürür ve maksimum 30 karaktere kısaltırız:

{$string|upper|truncate:30}

Filtreleri ifadenin kısmi bölümlerine de bu şekilde uygulayabilirsiniz:

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

Koşullar

{if} {elseif} {else}

Koşullar, PHP'deki karşılıklarıyla aynı şekilde davranır. İçlerinde PHP'den bildiğiniz aynı ifadeleri de kullanabilirsiniz, yeni bir dil öğrenmenize gerek yoktur.

{if $product->inStock > Stock::Minimum}
	Stokta
{elseif $product->isOnWay()}
	Yolda
{else}
	Mevcut değil
{/if}

Her çift etiket gibi, {if} ... {/if} çifti de n:niteliği biçiminde yazılabilir, örneğin:

<p n:if="$count > 0">Stokta {$count} adet</p>

n:niteliklere tag- önekini ekleyebileceğinizi biliyor muydunuz? O zaman koşul yalnızca HTML etiketlerinin yazdırılmasına uygulanır ve aralarındaki içerik her zaman yazdırılır:

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

{* $clickable yanlış olduğunda 'Merhaba' yazdırır *}
{* $clickable doğru olduğunda '<a href="...">Merhaba</a>' yazdırır *}

Harika.

n:else

Eğer {if} ... {/if} koşulunu n:niteliği biçiminde yazarsanız, n:else kullanarak alternatif bir dal belirtme seçeneğiniz de vardır:

<strong n:if="$count > 0">Stokta {$count} adet</strong>

<em n:else>mevcut değil</em>

n:else niteliği ayrıca n:ifset, n:foreach, n:try, n:ifcontent ve n:ifchanged ile çift olarak da kullanılabilir.

{/if $cond}

Belki şaşıracaksınız ama {if} koşulundaki ifade bitiş etiketinde de belirtilebilir. Bu, koşulu açarken değerini henüz bilmediğimiz durumlarda kullanışlıdır. Buna ertelenmiş karar diyelim.

Örneğin, veritabanından kayıtları içeren bir tabloyu yazdırmaya başlarız ve yalnızca yazdırmayı bitirdikten sonra veritabanında hiç kayıt olmadığını fark ederiz. O zaman {/if} bitiş etiketine bunun için bir koşul koyarız ve eğer hiç kayıt yoksa, bunların hiçbiri yazdırılmaz:

{if}
	<h1>Veritabanı satırlarının listesi</h1>

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

Kullanışlı, değil mi?

Ertelenmiş koşulda {else} de kullanılabilir, ancak {elseif} kullanılamaz.

{ifset} {elseifset}

Ayrıca bkz. {ifset block}

{ifset $var} koşuluyla, bir değişkenin (veya birden çok değişkenin) var olup olmadığını ve null olmayan bir değere sahip olup olmadığını kontrol ederiz. Aslında bu, PHP'deki if (isset($var)) ile aynıdır. Her çift etiket gibi, n:niteliği biçiminde de yazılabilir, o zaman bunu bir örnek olarak gösterelim:

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

{ifchanged}

{ifchanged}, bir değişkenin değerinin döngüdeki (foreach, for veya while) son iterasyondan bu yana değişip değişmediğini kontrol eder.

Etikette bir veya daha fazla değişken belirtirsek, bunlardan herhangi birinin değişip değişmediğini kontrol eder ve buna göre içeriği yazdırır. Örneğin, aşağıdaki örnek, isimleri yazdırırken her değiştiğinde ismin ilk harfini başlık olarak yazdırır:

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

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

Ancak, hiçbir argüman belirtmezsek, oluşturulan içerik önceki durumuyla karşılaştırılır. Bu, önceki örnekte etiketteki argümanı tamamen atlayabileceğimiz anlamına gelir. Ve tabii ki n:niteliğini de kullanabiliriz:

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

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

{ifchanged} içinde {else} ifadesi de belirtilebilir.

{switch} {case} {default}

Bir değeri birden çok seçenekle karşılaştırır. Bu, PHP'den bildiğiniz switch koşullu ifadesine benzer. Ancak Latte bunu geliştirir:

• katı karşılaştırma (===) kullanır
• break'e ihtiyaç duymaz

Yani bu, PHP 8.0 ile gelen match yapısının tam eşdeğeridir.

{switch $transport}
	{case train}
		Trenle
	{case plane}
		Uçakla
	{default}
		Diğer
{/switch}

{case} ifadesi virgülle ayrılmış birden çok değer içerebilir:

{switch $status}
{case $status::New}<b>yeni öğe</b>
{case $status::Sold, $status::Unknown}<i>mevcut değil</i>
{/switch}

Döngüler

Latte'de PHP'den bildiğiniz tüm döngüleri bulacaksınız: foreach, for ve while.

{foreach}

Döngüyü tıpkı PHP'deki gibi yazarız:

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

Ayrıca, şimdi bahsedeceğimiz birkaç kullanışlı özelliği vardır.

Örneğin Latte, oluşturulan değişkenlerin yanlışlıkla aynı addaki genel değişkenlerin üzerine yazıp yazmadığını kontrol eder. Bu, $lang'da sayfanın geçerli dilinin olduğunu varsaydığınız ve foreach $langs as $lang'ın bu değişkeni üzerine yazdığını fark etmediğiniz durumları kurtarır.

Foreach döngüsü ayrıca n:niteliği kullanılarak çok zarif ve özlü bir şekilde yazılabilir:

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

n:niteliklere inner- önekini ekleyebileceğinizi biliyor muydunuz? O zaman döngüde yalnızca öğenin içi tekrarlanır:

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

Yani şunun gibi bir şey yazdırılır:

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

{else}

foreach döngüsü içinde, döngü boşsa içeriği görüntülenecek olan {else} ifadesini belirtebilirsiniz:

<ul>
	{foreach $people as $person}
		<li>{$person->name}</li>
	{else}
		<li><em>Üzgünüz, bu listede hiç kullanıcı yok</em></li>
	{/foreach}
</ul>

$iterator

foreach döngüsü içinde Latte, devam eden döngü hakkında yararlı bilgiler öğrenmemizi sağlayan $iterator değişkenini oluşturur:

• $iterator->first – döngüden ilk kez mi geçiliyor?
• $iterator->last – bu son geçiş mi?
• $iterator->counter – birden başlayarak kaçıncı geçiş?
• $iterator->counter0 – sıfırdan başlayarak kaçıncı geçiş?
• $iterator->odd – bu tek sayılı bir geçiş mi?
• $iterator->even – bu çift sayılı bir geçiş mi?
• $iterator->parent – geçerli olanı çevreleyen yineleyici
• $iterator->nextValue – döngüdeki sonraki öğe
• $iterator->nextKey – sonraki öğenin anahtarı

{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 akıllıdır ve $iterator->last yalnızca dizilerde değil, döngü öğe sayısının önceden bilinmediği genel bir yineleyici üzerinde çalıştığında da çalışır.

{first} {last} {sep}

Bu etiketler {foreach} döngüsü içinde kullanılabilir. {first} içeriği ilk geçişse oluşturulur. {last} içeriği oluşturulur … tahmin edebilir misiniz? Evet, son geçişse. Bunlar aslında {if $iterator->first} ve {if $iterator->last} için kısayollardır.

Etiketler ayrıca zarif bir şekilde n:niteliği olarak da kullanılabilir:

{foreach $rows as $row}
	{first}<h1>İsim listesi</h1>{/first}

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

	<hr n:last>
{/foreach}

{sep} etiketinin içeriği, geçiş son değilse oluşturulur, bu nedenle yazdırılan öğeler arasına virgül gibi ayırıcılar oluşturmak için kullanışlıdır:

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

Bu oldukça pratik, değil mi?

{iterateWhile}

Koşul karşılandığı sürece iç içe bir döngüde yineleme yaparak foreach döngüsünde yinelenirken doğrusal verilerin gruplandırılmasını basitleştirir. Detaylı kılavuzu okuyun.

Ayrıca yukarıdaki örnekte {first} ve {last}'ı zarif bir şekilde değiştirebilir:

{foreach $rows as $row}
	<table>

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

	</table>
{/foreach}

Ayrıca bkz. batch ve group filtreleri.

{for}

Döngüyü tıpkı PHP'deki gibi yazarız:

{for $i = 0; $i < 10; $i++}
	<span>Öğe {$i}</span>
{/for}

Etiket ayrıca n:niteliği olarak da kullanılabilir:

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

{while}

Döngüyü yine tıpkı PHP'deki gibi yazarız:

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

Veya n:niteliği olarak:

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

PHP'deki do-while döngüsüne karşılık gelen bitiş etiketindeki koşulla bir varyant da mümkündür:

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

{continueIf} {skipIf} {breakIf}

Herhangi bir döngüyü kontrol etmek için, koşul karşılandığında sonraki öğeye geçen veya döngüyü sonlandıran {continueIf ?} ve {breakIf ?} etiketlerini kullanabilirsiniz:

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

{skipIf} etiketi {continueIf}'e çok benzer, ancak $iterator->counter sayacını artırmaz, bu nedenle onu yazdırırsak ve aynı zamanda bazı öğeleri atlarsak, numaralandırmada boşluklar olmaz. Ve ayrıca {else} ifadesi tüm öğeleri atlarsak oluşturulur.

<ul>
	{foreach $people as $person}
		{skipIf $person->age < 18}
		<li>{$iterator->counter}. {$person->name}</li>
	{else}
		<li><em>Üzgünüz, bu listede hiç yetişkin yok</em></li>
	{/foreach}
</ul>

{exitIf}

Koşul karşılandığında şablonun veya bloğun oluşturulmasını sonlandırır (“erken çıkış”).

{exitIf !$messages}

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

Şablon Ekleme

{include 'file.latte'}

Ayrıca bkz. {include block}

{include} etiketi belirtilen şablonu yükler ve oluşturur. Sevdiğimiz dilimiz PHP'nin dilinde konuşursak, bu şuna benzer:

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

Eklenen şablonlar etkin bağlamın değişkenlerine erişemez, yalnızca genel değişkenlere erişebilirler.

Değişkenleri eklenen şablona şu şekilde aktarabilirsiniz:

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

Şablon adı herhangi bir PHP ifadesi olabilir:

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

Eklenen içerik filtreler kullanılarak değiştirilebilir. Aşağıdaki örnek tüm HTML'i kaldırır ve harf boyutunu ayarlar:

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

Varsayılan olarak şablon kalıtımı bu durumda hiçbir rol oynamaz. Dahil edilen şablonda bloklar kullanabilsek de, dahil edildiği şablondaki karşılık gelen blokların yerini almaz. Dahil edilen şablonları sayfaların veya modüllerin ayrı, korumalı parçaları olarak düşünün. Bu davranış with blocks değiştiricisi kullanılarak değiştirilebilir:

{include 'template.latte' with blocks}

Etikette belirtilen dosya adı ile diskteki dosya arasındaki ilişki yükleyicinin işidir.

{sandbox}

Son kullanıcı tarafından oluşturulan bir şablonu eklerken, sandbox modunu düşünmelisiniz (daha fazla bilgi için sandbox dokümantasyonu):

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

{block}

Ayrıca bkz. {block name}

Adsız bloklar, filtreleri şablonun bir kısmına uygulamanın bir yolu olarak hizmet eder. Örneğin, bu şekilde gereksiz boşlukları kaldıran strip filtresini uygulayabilirsiniz:

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

İstisna Yönetimi

{try}

Bu etiket sayesinde sağlam şablonlar oluşturmak son derece kolaydır.

{try} bloğunu oluştururken bir istisna oluşursa, tüm blok atılır ve oluşturma ondan sonra devam eder:

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

İsteğe bağlı {else} ifadesindeki içerik yalnızca bir istisna oluştuğunda oluşturulur:

{try}
	<ul>
		{foreach $twitter->loadTweets() as $tweet}
  			<li>{$tweet->text}</li>
		{/foreach}
	</ul>
	{else}
	<p>Üzgünüz, tweet'ler yüklenemedi.</p>
{/try}

Etiket ayrıca n:niteliği olarak da kullanılabilir:

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

Ayrıca, örneğin günlükleme için özel bir istisna işleyici tanımlamak da mümkündür.

{rollback}

{try} bloğu ayrıca {rollback} kullanılarak manuel olarak durdurulabilir ve atlanabilir. Bu sayede tüm girdi verilerini önceden kontrol etmeniz gerekmez ve yalnızca oluşturma sırasında nesneyi hiç oluşturmak istemediğinize karar verebilirsiniz:

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

Değişkenler

{var} {default}

Şablonda {var} etiketiyle yeni değişkenler oluştururuz:

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

{* Çoklu bildirim *}
{var $name = 'John Smith', $age = 27}

{default} etiketi benzer şekilde çalışır, ancak değişkenleri yalnızca mevcut değillerse oluşturur. Değişken zaten mevcutsa ve null değerini içeriyorsa, üzerine yazılmaz:

{default $lang = 'tr'}

Ayrıca değişken tiplerini de belirtebilirsiniz. Şimdilik bunlar bilgilendiricidir ve Latte bunları kontrol etmez.

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

{parameters}

Fonksiyonların parametrelerini bildirdiği gibi, bir şablon da başlangıçta değişkenlerini bildirebilir:

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

Varsayılan değeri belirtilmeyen $a ve $b değişkenleri otomatik olarak null varsayılan değerine sahiptir. Bildirilen tipler şimdilik bilgilendiricidir ve Latte bunları kontrol etmez.

Bildirilenler dışındaki değişkenler şablona aktarılmaz. Bu, onu {default} etiketinden ayırır.

{capture}

Çıktıyı bir değişkene yakalar:

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

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

Etiket, her çift etiket gibi, n:niteliği olarak da yazılabilir:

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

HTML çıktısı $var değişkenine Latte\Runtime\Html nesnesi biçiminde kaydedilir, böylece yazdırırken istenmeyen kaçış işleminin gerçekleşmemesi sağlanır.

Diğer

{contentType}

Etiketle, şablonun hangi içerik türünü temsil ettiğini belirtirsiniz. Seçenekler şunlardır:

• html (varsayılan tip)
• xml
• javascript
• css
• calendar (iCal)
• text

Kullanımı önemlidir, çünkü bağlama duyarlı kaçış'ı ayarlar ve yalnızca bu şekilde doğru şekilde kaçış yapabilir. Örneğin, {contentType xml} XML moduna geçer, {contentType text} kaçış işlemini tamamen kapatır.

Parametre application/xml gibi tam bir MIME türü ise, ayrıca tarayıcıya Content-Type HTTP başlığını da gönderir:

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

{debugbreak}

Programcının çalışma zamanı ortamını inceleyebilmesi ve programın beklendiği gibi çalışıp çalışmadığını belirleyebilmesi için programın çalışmasının duraklatılacağı ve hata ayıklayıcının başlatılacağı yeri belirtir. Xdebug'ı destekler. Programın ne zaman duraklatılacağını belirleyen bir koşul eklenebilir.

{debugbreak}                {* programı duraklatır *}

{debugbreak $counter == 1}  {* koşul karşılandığında programı duraklatır *}

{do}

PHP kodunu yürütür ve hiçbir şey yazdırmaz. Diğer tüm etiketlerde olduğu gibi, PHP kodu tek bir ifade anlamına gelir, bkz. PHP kısıtlamaları.

{do $num++}

{dump}

Bir değişkeni veya geçerli bağlamı döker.

{dump $name} {* $name değişkenini döker *}

{dump}       {* Şu anda tanımlanmış tüm değişkenleri döker *}

Tracy kütüphanesini gerektirir.

{php}

Herhangi bir PHP kodunu yürütmeye izin verir. Etiketin RawPhpExtension uzantısı kullanılarak etkinleştirilmesi gerekir.

{spaceless}

Çıktıdan gereksiz boşlukları kaldırır. spaceless filtresine benzer şekilde çalışır.

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

Oluşturur

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

Etiket ayrıca n:niteliği olarak da yazılabilir.

{syntax}

Latte etiketlerinin yalnızca tek küme parantezleriyle sınırlanması gerekmez. Çalışma zamanında bile başka bir sınırlayıcı seçebiliriz. Bunun için {syntax …} kullanılır, burada parametre olarak şunlar belirtilebilir:

• double: {{...}}
• off: Latte etiketlerinin işlenmesini tamamen kapatır

n:nitelikleri kullanarak, Latte'yi örneğin yalnızca bir JavaScript bloğu için kapatabilirsiniz:

<script n:syntax="off">
	var obj = {var: 123}; // bu artık bir etiket değil
</script>

Latte, JavaScript içinde de çok rahat bir şekilde kullanılabilir, sadece bu örnekteki gibi { işaretinden hemen sonra bir harfin geldiği yapılardan kaçınmak yeterlidir, bkz. JavaScript veya CSS İçinde Latte.

Latte'yi {syntax off} kullanarak (yani etiketle, n:niteliğiyle değil) kapatırsanız, {/syntax}'a kadar tüm etiketleri kesinlikle yok sayacaktır.

{trace}

Yığın izi şablonlar ruhunda olan bir Latte\RuntimeException istisnası fırlatır. Yani fonksiyon ve metot çağrıları yerine blok çağrıları ve şablon eklemeleri içerir. Fırlatılan istisnaları net bir şekilde görüntülemek için Tracy gibi bir araç kullanıyorsanız, tüm aktarılan parametreler dahil olmak üzere çağrı yığını net bir şekilde görüntülenir.

HTML Kodlayıcı Yardımcıları

n:class

n:class sayesinde, HTML class niteliğini tam olarak istediğiniz gibi çok kolay bir şekilde oluşturabilirsiniz.

Örnek: etkin öğenin active sınıfına sahip olmasını istiyorum:

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

Ayrıca, ilk öğenin first ve main sınıflarına sahip olması gerekir:

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

Ve tüm öğelerin list-item sınıfına sahip olması gerekir:

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

Harika derecede basit, değil mi?

n:attr

n:attr niteliği, n:class'ın sahip olduğu aynı zarafetle herhangi bir HTML niteliğini oluşturabilir.

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

Döndürülen değerlere bağlı olarak, örneğin şunu yazdırır:

<input type="checkbox">

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

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

n:tag

n:tag niteliği, bir HTML öğesinin adını dinamik olarak değiştirebilir.

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

Eğer $heading === null ise, <h1> etiketi değişmeden yazdırılır. Aksi takdirde, öğenin adı değişkenin değerine değiştirilir, yani $heading === 'h3' için şu yazdırılır:

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

Latte güvenli bir şablonlama sistemi olduğundan, yeni etiket adının geçerli olup olmadığını ve istenmeyen veya zararlı değerler içermediğini kontrol eder.

n:ifcontent

Boş bir HTML öğesinin, yani boşluklardan başka bir şey içermeyen bir öğenin yazdırılmasını önler.

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

$error değişkeninin değerine bağlı olarak yazdırır:

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

{* $error = 'Required' *}
<div>
	<div class="error">Required</div>
</div>

Çeviriler

Çeviri etiketlerinin çalışması için çevirmenin etkinleştirilmesi gerekir. Çeviri için ayrıca translate filtresini de kullanabilirsiniz.

{_...}

Değerleri diğer dillere çevirir.

<a href="basket">{_'Sepet'}</a>
<span>{_$item}</span>

Çevirmene ek parametreler de aktarılabilir:

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

{translate}

Şablonun bölümlerini çevirir:

<h1>{translate}Sipariş{/translate}</h1>

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

Etiket ayrıca n:niteliği olarak da yazılabilir, öğenin içini çevirmek için:

<h1 n:translate>Sipariş</h1>