Latte Etiketleri

Tüm Latte yerleşik etiketlerinin özeti ve açıklaması.

Baskı

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

Latte, herhangi bir ifadeyi çıktıya yazdırmak için {=...} etiketini kullanır. Eğer ifade bir değişken veya fonksiyon çağrısı ile başlıyorsa, eşittir işareti yazmaya gerek yoktur. Bu da pratikte neredeyse hiçbir zaman yazılmasına gerek olmadığı anlamına gelir:

Name: {$name} {$surname}<br>
Age: {date('Y') - $birth}<br>

PHP'den bildiğiniz her şeyi bir ifade olarak yazabilirsiniz. Sadece yeni bir dil öğrenmek zorunda değilsiniz. Örneğin:

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

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

Çıkıştan Kaçış

Bir şablon sisteminin en önemli görevi nedir? Güvenlik açıklarını önlemek. Ve çıktıya bir şey yazdırdığınızda Latte tam olarak bunu yapar. Her şeyi otomatik olarak kaçar:

<p>{='one < two'}</p>   {* prints: '<p>one &lt; two</p>' *}

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

Peki ya güvenilir bir kaynaktan HTML kodlu içerik yazdırıyorsanız? O zaman kaçış özelliğini kolayca kapatabilirsiniz:

{$trustedHtmlString|noescape}

noescape filtresinin yanlış kullanımı bir XSS güvenlik açığına yol açabilir! Ne yaptığınızdan ve yazdırdığınız dizenin güvenilir bir kaynaktan geldiğinden kesinlikle emin değilseniz asla kullanmayın.

JavaScript'te Yazdırma

Bağlama duyarlı kaçış sayesinde, JavaScript içindeki değişkenleri yazdırmak son derece kolaydır ve Latte bunları düzgün bir şekilde kaçacaktır.

Değişken bir dize olmak zorunda değildir, herhangi bir veri türü desteklenir ve daha sonra JSON olarak kodlanır:

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

Üretir:

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

Bu aynı zamanda değişkeni tırnak içine almayın nedenidir: Latte bunları dizelerin etrafına ekler. Ve bir dize değişkenini başka bir dizenin içine koymak istiyorsanız, bunları birleştirmeniz yeterlidir:

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

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

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

Filtreler

Yazdırılan ifade filtrelerle değiştirilebilir. Örneğin, bu örnek dizeyi büyük harfe dönüştürür ve en fazla 30 karakter olacak şekilde kısaltır:

{$string|upper|truncate:30}

Ayrıca, bir ifadenin bölümlerine aşağıdaki gibi filtreler uygulayabilirsiniz:

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

Koşullar

{if} {elseif} {else}

Koşullar PHP'deki benzerleriyle aynı şekilde davranır. PHP'den bildiğiniz ifadeleri kullanabilirsiniz, yeni bir dil öğrenmek zorunda değilsiniz.

{if $product->inStock > Stock::Minimum}
	In stock
{elseif $product->isOnWay()}
	On the way
{else}
	Not available
{/if}

Herhangi bir çift etiketi gibi, bir {if} ... {/ if} çifti de örneğin n:attribute şeklinde yazılabilir:

<p n:if="$count > 0">In stock {$count} items</p>

n:attributes öğesine tag- önekini ekleyebileceğinizi biliyor musunuz? Bu durumda koşul yalnızca HTML etiketlerini etkileyecek ve aralarındaki içerik her zaman yazdırılacaktır:

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

{* prints 'Hello' when $clickable is falsey *}
{* prints '<a href="...">Hello</a>' when $clickable is truthy *}

Güzel.

n:else

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

<strong n:if="$count > 0">In stock {$count} items</strong>

<em n:else>not available</em>

n:else özniteliği aşağıdakilerle birlikte de kullanılabilir n:ifset, n:foreach, n:try, n:ifcontentve n:ifchanged.

{/if $cond}

{if} koşulundaki ifadenin end etiketinde de belirtilebilmesi sizi şaşırtabilir. Bu, etiket açıldığında koşulun 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 listelemeye başlıyoruz ve ancak raporu tamamladıktan sonra veritabanında kayıt olmadığını fark ediyoruz. Bu yüzden {/if} son etiketine koşul koyarız ve eğer kayıt yoksa hiçbiri yazdırılmaz:

{if}
	<h1>Printing rows from the database</h1>

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

Kullanışlı, değil mi?

Ertelenmiş koşulda {else} adresini de kullanabilirsiniz, ancak {elseif} adresini kullanamazsınız.

{ifset} {elseifset}

Ayrıca bakınız {ifset block}

Bir değişkenin (veya birden fazla değişkenin) var olup olmadığını ve boş olmayan bir değere sahip olup olmadığını belirlemek için {ifset $var} koşulunu kullanın. Aslında PHP'deki if (isset($var)) ile aynıdır. Herhangi bir çift etiketi gibi, bu da n:attribute şeklinde yazılabilir, bu yüzden örnek olarak gösterelim:

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

{ifchanged}

{ifchanged} Döngüdeki (foreach, for veya while) son yinelemeden bu yana bir değişkenin değerinin 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 içeriği buna göre yazdırır. Örneğin, aşağıdaki örnek isimleri listelerken her değiştiğinde bir 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, herhangi bir argüman verilmezse, işlenen içeriğin kendisi önceki durumuna göre kontrol edilecektir. Bu, önceki örnekte etiketteki argümanı güvenli bir şekilde atlayabileceğimiz anlamına gelir. Ve tabii ki n:attribute da kullanabiliriz:

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

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

Ayrıca {ifchanged} içine bir {else} cümlesi de ekleyebilirsiniz.

{switch} {case} {default}

Değeri birden fazla seçenekle karşılaştırır. Bu, PHP'den bildiğiniz switch yapısına benzer. Ancak Latte bunu geliştirir:

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

Yani PHP 8.0 ile birlikte gelen match yapısının tam karşılığıdır.

{switch $transport}
	{case train}
		By train
	{case plane}
		By plane
	{default}
		Differently
{/switch}

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

{switch $status}
{case $status::New}<b>new item</b>
{case $status::Sold, $status::Unknown}<i>not available</i>
{/switch}

Döngüler

Latte'de PHP'den bildiğiniz tüm döngüler mevcuttur: foreach, for ve while.

{foreach}

Döngüyü PHP'deki ile tamamen aynı şekilde yazarsınız:

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

Buna ek olarak, şimdi bahsedeceğimiz bazı kullanışlı ince ayarlar var.

Örneğin, Latte oluşturulan değişkenlerin yanlışlıkla aynı isimli global değişkenlerin üzerine yazılmadığını kontrol eder. Bu, $lang adresinin sayfanın geçerli dili olduğunu varsaydığınızda ve foreach $langs as $lang adresinin bu değişkenin üzerine yazıldığını fark etmediğinizde sizi kurtaracaktır.

foreach döngüsü de n:attribute ile çok zarif ve ekonomik bir şekilde yazılabilir:

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

inner- ön ekini n:attributes öğesinin önüne ekleyebileceğinizi biliyor muydunuz? Artık sadece elemanın iç kısmı döngüde tekrarlanacaktır:

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

Yani şöyle bir şey yazdırıyor:

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

{else}

foreach döngüsü, verilen dizi boşsa metni görüntülenen isteğe bağlı bir {else} cümlesi alabilir:

<ul>
	{foreach $people as $person}
		<li>{$person->name}</li>
	{else}
		<li><em>Sorry, no users in this list</em></li>
	{/foreach}
</ul>

$iterator

foreach döngüsü içinde $iterator değişkeni başlatılır. Mevcut döngü hakkında önemli bilgiler tutar.

• $iterator->first – bu ilk yineleme mi?
• $iterator->last – bu son yineleme mi?
• $iterator->counter – yineleme sayacı, 1'den başlar
• $iterator->counter0 – yineleme sayacı, 0'dan başlar
• $iterator->odd – bu yineleme tek mi?
• $iterator->even – bu yineleme çift mi?
• $iterator->parent – mevcut olanı çevreleyen yineleyici
• $iterator->nextValue – döngüdeki bir sonraki öğe
• $iterator->nextKey – döngüdeki bir 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 diziler için değil, aynı zamanda 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. İlk geçiş için {first} içeriği işlenir. {last} içeriği … tahmin edebilir misiniz? Evet, son geçiş için. Bunlar aslında {if $iterator->first} ve {if $iterator->last} için kısayollardır.

Etiketler n:attributes şeklinde de yazılabilir:

{foreach $rows as $row}
	{first}<h1>List of names</h1>{/first}

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

	<hr n:last>
{/foreach}

Yineleme son değilse {sep} içeriği işlenir, bu nedenle listelenen öğeler arasındaki virgüller gibi sınırlayıcıları yazdırmak için uygundur:

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

Bu oldukça pratik, değil mi?

{iterateWhile}

Koşul karşılandığı sürece yinelemeyi iç içe bir döngüde gerçekleştirerek foreach döngüsünde yineleme sırasında doğrusal verilerin gruplanmasını basitleştirir. Yemek kitabındaki talimatları okuyun.

Ayrıca yukarıdaki örnekte {first} ve {last} adreslerini 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}

{for}

Döngüyü PHP'deki ile tamamen aynı şekilde yazıyoruz:

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

Etiket n:attribute şeklinde de yazılabilir:

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

{while}

Yine, döngüyü PHP'deki ile tamamen aynı şekilde yazıyoruz:

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

Ya da n:attribute olarak:

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

Son etiketinde bir koşul bulunan bir varyant PHP'deki do-while döngüsüne karşılık gelir:

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

{continueIf} {skipIf} {breakIf}

Herhangi bir döngüyü kontrol etmek için kullanabileceğiniz özel etiketler vardır – {continueIf ?} ve {breakIf ?}, koşullar karşılandığında sırasıyla bir sonraki yinelemeye atlar ve döngüyü sonlandırır:

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

{skipIf} etiketi {continueIf} etiketine çok benzer, ancak sayacı artırmaz. Böylece $iterator->counter adresini yazdırdığınızda ve bazı öğeleri atladığınızda numaralandırmada delikler oluşmaz. Ayrıca tüm öğeleri atladığınızda {else} cümlesi oluşturulacaktır.

<ul>
	{foreach $people as $person}
		{skipIf $person->age < 18}
		<li>{$iterator->counter}. {$person->name}</li>
	{else}
		<li><em>Sorry, no adult users in this list</em></li>
	{/foreach}
</ul>

{exitIf}

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

{exitIf !$messages}

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

Şablonlar Dahil

{include 'file.latte'}

Ayrıca bakınız {include block}

{include} etiketi belirtilen şablonu yükler ve işler. Favori PHP dilimizde bu şuna benzer:

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

Dahil edilen şablonların aktif bağlamın değişkenlerine erişimi yoktur, ancak global değişkenlere erişimi vardır.

Eklenen şablona değişkenleri aşağıdaki ş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 öğelerini kaldırır ve durumu ayarlar:

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

Şablon kalıtımı varsayılan olarak buna dahil değildir. Dahil edilen şablonlara blok etiketleri ekleyebilseniz de, bunlar dahil edildikleri şablondaki eşleşen blokların yerini almayacaktır. İçerikleri, sayfaların veya modüllerin bağımsız ve 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 bir yükleyici meselesidir.

{sandbox}

Bir son kullanıcı tarafından oluşturulan bir şablonu eklerken, bunu korumalı alana almayı düşünmelisiniz (daha fazla bilgi korumalı alan belgelerinde bulunmaktadır):

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

{block}

Ayrıca bakınız {block name}

Adı olmayan bloklar, şablonun bir bölümüne filtre uygulama olanağı sunar. Örneğin, gereksiz boşlukları kaldırmak için bir şerit filtresi uygulayabilirsiniz:

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

İstisna İşleme

{try}

Bu etiketler, sağlam şablonlar oluşturmayı son derece kolaylaştırır.

{try} bloğu işlenirken bir istisna oluşursa, tüm blok atılır ve işleme bundan sonra devam eder:

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

İsteğe bağlı {else} cümlesinin içeriği yalnızca bir istisna oluştuğunda işlenir:

{try}
	<ul>
		{foreach $twitter->loadTweets() as $tweet}
  			<li>{$tweet->text}</li>
		{/foreach}
	</ul>
	{else}
	<p>Sorry, the tweets could not be loaded.</p>
{/try}

Etiket n:attribute şeklinde de yazılabilir:

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

Günlük kaydı için kendi istisna işleyicisini tanımlamak da mümkündür:

{rollback}

{try} bloğu {rollback} kullanılarak manuel olarak da durdurulabilir ve atlanabilir. Böylece tüm girdi verilerini önceden kontrol etmeniz gerekmez ve yalnızca render sırasında nesneyi render etmenin mantıklı olup olmadığına 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} etiketi ile yeni değişkenler oluşturacağız:

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

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

{default} etiketi de benzer şekilde çalışır, ancak değişkenleri yalnızca mevcut değillerse oluşturur:

{default $lang = 'cs'}

Değişken türlerini de belirtebilirsiniz. Şimdilik bunlar bilgilendiricidir ve Latte bunları kontrol etmez.

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

{parameters}

Tıpkı bir fonksiyonun parametrelerini bildirmesi gibi, bir şablon da değişkenlerini başlangıçta bildirebilir:

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

Varsayılan değeri olmayan $a ve $b değişkenleri otomatik olarak null varsayılan değerine sahip olur. Bildirilen türler hala bilgilendiricidir ve Latte bunları kontrol etmez.

Bildirilen değişkenler dışında hiçbir değişken şablona aktarılmaz. Bu, {default} etiketinden bir farktır.

{capture}

{capture} etiketini kullanarak çıktıyı bir değişkene yakalayabilirsiniz:

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

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

Bu etiket, herhangi bir ikili etiket gibi n:attribute şeklinde de yazılabilir:

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

HTML çıktısı, yazdırma sırasında istenmeyen kaçışları önlemek için $var değişkeninde bir Latte\Runtime\Html nesnesi olarak saklanır.

Diğerleri

{contentType}

Şablonun ne tür bir içeriği temsil ettiğini belirtmek için etiketi kullanın. Seçenekler şunlardır:

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

Kullanımı önemlidir çünkü bağlama duyarlı kaçış ayarlar ve ancak o zaman Latte doğru şekilde kaçabilir. Örneğin, {contentType xml} XML moduna geçer, {contentType text} kaçışı tamamen kapatır.

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

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

{debugbreak}

Kod yürütmesinin kesileceği yeri belirtir. Programcının çalışma zamanı ortamını incelemesi ve kodun beklendiği gibi çalıştığından emin olması için hata ayıklama amacıyla kullanılır. Xdebug'ı destekler. Ek olarak, kodun ne zaman kırılması gerektiğini bir koşul olarak belirtebilirsiniz.

{debugbreak}                {* programı bozar *}

{debugbreak $counter == 1}  {* koşul yerine getirilirse programı keser *}

{do}

PHP kodunu çalıştırır ve hiçbir şey yazdırmaz. Diğer tüm etiketlerde olduğu gibi, PHP kodu tek bir ifadedir, PHP sınırlamalarına bakınız.

{do $num++}

{dump}

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

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

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

Tracy paketi gerektirir.

{php}

Herhangi bir PHP kodunu çalıştırmanıza izin verir. Etiket RawPhpExtension uzantısı kullanılarak etkinleştirilmelidir.

{spaceless}

Gereksiz boşlukları kaldırır. Boşluksuz filtreye benzer.

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

Çıkışlar:

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

Etiket n:attribute şeklinde de yazılabilir:

{syntax}

Latte etiketleri yalnızca tek küme parantezi içine alınmak zorunda değildir. Çalışma zamanında bile başka bir ayırıcı seçebilirsiniz. Bu, parametrenin olabileceği {syntax…} ile yapılır:

• Çifte: {{...}}
• off: Latte etiketlerini tamamen devre dışı bırakır

n:attribute notasyonunu kullanarak Latte'yi yalnızca bir JavaScript bloğu için devre dışı bırakabiliriz:

<script n:syntax="off">
	var obj = {var: 123}; // this isn't a tag any more
</script>

Latte JavaScript içinde çok rahat bir şekilde kullanılabilir, sadece bu örnekteki gibi harfin { harfinden hemen sonra geldiği yapılardan kaçının, JavaScript veya CSS içinde Lat te bölümüne bakın.

Latte'yi {syntax off} ile kapatırsanız (yani etiket, n:niteliği değil), {/syntax} adresine kadar olan tüm etiketleri kesinlikle yok sayacaktır.

{trace}

Yığın izi şablonların ruhuna uygun olan bir Latte\RuntimeException istisnası atar. Bu nedenle, işlevleri ve yöntemleri çağırmak yerine, blokları çağırmayı ve şablonları eklemeyi içerir. Tracy gibi atılan istisnaları açıkça görüntülemek için bir araç kullanırsanız, geçirilen tüm argümanlar da dahil olmak üzere çağrı yığınını açıkça görürsünüz.

HTML Etiket Yardımcıları

n:sınıf

n:class sayesinde, class HTML özniteliğini tam olarak ihtiyaç duyduğunuz şekilde oluşturmak çok kolaydır.

Örnek: Aktif öğ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ı gerekiyor:

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

Ve tüm öğeler list-item sınıfına sahip olmalıdır:

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

İnanılmaz derecede basit, değil mi?

n:attr

n:attr niteliği, n:class ile aynı zarafete sahip rastgele HTML nitelikleri oluşturabilir.

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

Dönen değerlere bağlı olarak, örn:

<input type="checkbox">

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

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

n:etiket

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ştirilmeden yazdırılır. Aksi takdirde, öğe adı değişkenin değeriyle değiştirilir, bu nedenle $heading === 'h3' için yazar:

<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 kötü amaçlı değerler içermediğini kontrol eder.

n:ifcontent

Boş bir HTML öğesinin, yani boşluktan 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ğerlerine bağlı olarak bu yazdırılacaktır:

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

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

Çeviri

Çeviri etiketlerinin çalışmasını sağlamak için çevirmen kurmanız gerekir. Ayrıca şunları da kullanabilirsiniz translate çeviri için filtre.

{_...}

Değerleri diğer dillere çevirir.

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

Çevirmene başka parametreler de aktarılabilir:

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

{translate}

Překládá části šablony:

<h1>{translate}Order{/translate}</h1>

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

Elemanın içini çevirmek için etiket n:attribute olarak da yazılabilir:

<h1 n:translate>Order</h1>