Latte etiketleri

Latte şablon sisteminde varsayılan olarak bulunan tüm etiketlere genel bakış ve açıklamaları.

Yazdırma

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

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

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

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

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

Lütfen önceki örnekte bir anlam aramayın, ama bulursanız bize haber verin :-)

Çıktının kaçırılması

Bir şablon sisteminin en önemli görevi nedir? Güvenlik açıklarını önlemek. Latte de bir şey yazdırdığınızda tam olarak bunu yapar. Onu otomatik kaçırır:

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

Daha doğrusu Latte, o kadar önemli ve eşsiz bir özellik olan bağlama duyarlı kaçışı kullanır 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çışı 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 olmadıkça asla kullanmayın.

JavaScript'te yazdırma

Bağlama duyarlı kaçış sayesinde JavaScript'in içinde değişken yazdırmak harika biçimde kolaydır ve doğru kaçışı Latte üstlenir.

Değişkenin dize olması gerekmez; her veri tipi desteklenir ve sonra JSON olarak kodlanır:

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

Şunu üretir:

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

Bu ayrıca değişkenin çevresine tırnak yazmamanız gerektiğinin de nedenidir: Latte onları dizeler için otomatik ekler. Bir dize değişkenini başka bir dizeye eklemek isterseniz, onları birleştirmeniz yeterlidir:

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

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

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

Filtreler

Yazdırılan ifade filtrelerle değiştirilebilir. Örneğin şu, dizeyi büyük harfe çevirir ve en fazla 30 karaktere kısaltır:

{$string|upper|truncate:30}

Filtreleri bir ifadenin bölümlerine de şöyle uygulayabilirsiniz:

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

Koşullar

{if} {elseif} {else}

Koşullar, PHP'deki karşılıklarıyla aynı şekilde davranır. PHP'den bildiğiniz ifadelerin aynısını kullanabilirsiniz; yeni bir dil öğrenmeniz gerekmez.

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

Her çift etiket gibi, {if} ... {/if} çifti de bir n:nitelik kullanılarak yazılabilir, örneğin:

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

n:niteliklerine tag- ön ekini ekleyebileceğinizi biliyor muydunuz? O zaman koşul yalnızca HTML etiketlerinin yazdırılmasını etkiler, aralarındaki içerik ise her zaman yazdırılır:

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

{* $clickable yanlış değerliyken 'Hello' yazdırır *}
{* $clickable doğru değerliyken '<a href="...">Hello</a>' yazdırır *}

Harika.

n:else n:elseif

{if} ... {/if} koşulunu bir n:nitelik biçiminde yazarsanız, alternatif dalları n:else (3.0.12'den beri) ve n:elseif (3.1'den beri) ile belirtme olanağınız olur:

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

<em n:elseif="$count < 0">Invalid count</em>

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

n:else niteliği n:ifset, n:foreach, n:try, n:ifcontent ve n:ifchanged ile birlikte de kullanılabilir.

{/if $cond}

{if} koşulundaki ifadenin kapanış etiketinde de belirtilebilmesine şaşırabilirsiniz. Bu, koşulu açarken değerini henüz bilmediğimiz durumlarda yararlıdır. Buna ertelenmiş karar diyelim.

Örneğin veritabanındaki kayıtlarla bir tabloyu listelemeye başlarız ve ancak çıktıyı tamamladıktan sonra veritabanında hiç kayıt olmadığını fark ederiz. Bu yüzden koşulu kapanış etiketi {/if}'e koyarız; kayıt yoksa hiçbiri yazdırılmaz:

{if}
	<h1>List of rows from the database</h1>

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

Kullanışlı, değil mi?

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

{ifset} {elseifset}

Ayrıca bkz. {ifset block}

Bir değişkenin (veya birden fazla değişkenin) var olup olmadığını ve null olmayan bir değer taşıyıp taşımadığını belirlemek için {ifset $var} koşulunu kullanın. Aslında PHP'deki if (isset($var)) ile aynıdır. Her çift etiket gibi bir n:nitelik kullanılarak da yazılabilir, bir örnek gösterelim:

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

{ifchanged}

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

Etikette bir veya daha fazla değişken verirsek, herhangi birinin değişip değişmediğini denetler ve içeriği buna göre yazdırır. Örneğin aşağıdaki örnek, adlar listelenirken her değiştiğinde adın 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ç argüman verilmezse, render edilen içeriğin kendisi önceki durumuyla karşılaştırılır. Yani önceki örnekte etiketteki argümanı güvenle atlayabiliriz. Ve elbette bir n:nitelik de kullanabiliriz:

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

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

{ifchanged} içinde bir {else} yan tümcesi de kullanılabilir.

{switch} {case} {default}

Bir değeri birden fazla seçenekle karşılaştırır. PHP'den bilinen switch deyimine benzer. Ancak Latte onu iyileştirir:

• katı karşılaştırma (===) kullanır
• break gerektirmez

Böylece PHP 8.0'da tanıtılan match yapısına çok yakındır.

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

{case} yan tümcesi 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üleri bulacaksınız: foreach, for ve while.

{foreach}

Döngüyü tam olarak PHP'deki gibi yazarsınız:

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

Ayrıca, şimdi ele alacağımız birkaç kullanışlı özelliği vardır.

Örneğin Latte, oluşturulan değişkenlerin aynı adlı genel değişkenleri yanlışlıkla ezmediğini denetler. Bu sizi, $lang'ın sayfanın geçerli dilini taşımasını beklerken foreach $langs as $lang'ın o değişkeni ezdiğini fark etmediğiniz durumlardan kurtarır.

foreach döngüsü bir n:nitelik kullanılarak çok zarif ve ekonomik biçimde de yazılabilir:

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

n:niteliklerine inner- ön ekini ekleyebileceğinizi biliyor muydunuz? O zaman döngüde yalnızca elemanın iç bölümü yinelenir:

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

Böylece şuna benzer bir şey yazdırır:

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

{else}

foreach döngüsünün içinde, döngü boşsa içeriği gösterilen bir {else} yan tümcesi belirtebilirsiniz:

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

$iterator

foreach döngüsünün içinde Latte, süren döngü hakkında yararlı bilgiler bulmamızı sağlayan $iterator değişkenini oluşturur:

• $iterator->first – bu ilk yineleme mi?
• $iterator->last – bu son yineleme mi?
• $iterator->counter – birden başlayan yineleme sayacı
• $iterator->counter0 – sıfırdan başlayan yineleme sayacı
• $iterator->odd – bu tek bir yineleme mi?
• $iterator->even – bu çift bir yineleme mi?
• $iterator->parent – geçerli yineleyiciyi çevreleyen yineleyici
• $iterator->nextValue – döngüdeki sonraki öğe
• $iterator->nextKey – döngüdeki 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, öğe sayısının önceden bilinmediği genel bir yineleyici üzerinde dönen döngülerde de çalışır.

{first} {last} {sep}

Bu etiketler {foreach} döngüsünün içinde kullanılabilir. {first}'in içeriği, ilk yinelemeyse render edilir. {last}'ın içeriği ise… tahmin edebilir misiniz? Evet, son yinelemeyse. Bunlar aslında {if $iterator->first} ve {if $iterator->last} için kısayollardır.

Etiketler n:nitelik olarak da zarif biçimde kullanılabilir:

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

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

	<hr n:last>
{/foreach}

{sep} etiketinin içeriği, yineleme son değilse render edilir; bu da onu listelenen öğeler arasındaki virgüller gibi ayırıcıları render etmek için uygun kılar:

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

Bu epey pratik, değil mi?

{iterateWhile}

Koşul sağlandığı sürece yinelemeyi iç içe bir döngüde yaparak, bir foreach döngüsünde doğrusal veriyi gruplamayı basitleştirir. Ayrıntılı yönergeleri okuyun.

Yukarıdaki örnekte {first} ve {last}'ın yerini de zarif biçimde alabilir:

{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ü tam olarak PHP'deki gibi yazarız:

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

Etiket bir n:nitelik olarak da yazılabilir:

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

{while}

Döngüyü yine tam olarak PHP'deki gibi yazarız:

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

Ya da bir n:nitelik olarak:

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

PHP'deki do-while döngüsüne karşılık gelen, koşulu kapanış etiketinde olan bir varyant da mümkündür:

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

{continueIf} {skipIf} {breakIf}

Özel {continueIf ?} ve {breakIf ?} etiketleri herhangi bir döngüyü denetlemek için kullanılabilir. Koşul sağlanırsa sırasıyla sonraki yinelemeye atlarlar ya da döngüyü bitirirler:

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

{skipIf} etiketi {continueIf}'e çok benzer, ama $iterator->counter'ı artırmaz. Bu, sayacı yazdırırken ve bazı öğeleri atlarken numaralandırmada boşluk oluşmasını önler. Ayrıca tüm öğeler atlanırsa {else} yan tümcesi render edilir.

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

{exitIf}

Bir koşul sağlandığında bir şablonun veya bloğun render edilmesini bitirir (yani “erken çıkış”).

{exitIf !$messages}

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

Şablonları ekleme

{include 'file.latte'}

Ayrıca bkz. {include block} ve {embed}

{include} etiketi, belirtilen şablonu yükler ve render eder. Sevgili PHP dilimizde şuna benzer bir şeydir:

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

Eklenen şablonlar etkin bağlamın değişkenlerine erişemez, ama genel değişkenlere erişebilir.

Eklenen şablona değişkenleri şöyle aktarabilirsiniz:

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

Şablon adı herhangi bir PHP ifadesi olabilir:

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

Bir şablonun var olup olmadığı hasTemplate() fonksiyonuyla denetlenebilir.

Eklenen içerik filtrelerle değiştirilebilir. Şu örnek tüm HTML'i kaldırır ve harf durumunu ayarlar:

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

Varsayılan olarak şablon kalıtımı buna karışmaz. Eklenen şablonlarda blok kullanabilseniz de, bunlar eklendikleri şablondaki karşılık gelen blokların yerini almaz. Eklenen şablonları sayfaların veya modüllerin bağımsız, korumalı parçaları gibi düşünün. Bu davranış with blocks değiştiricisiyle değiştirilebilir:

{include 'template.latte' with blocks}

Etikette belirtilen dosya adı ile diskteki dosya arasındaki ilişki loader'a bağlıdır.

{sandbox}

Son kullanıcının oluşturduğu bir şablonu eklerken onu sandbox'lamayı düşünmelisiniz (daha fazla bilgi sandbox dokümantasyonunda):

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

{block}

Ayrıca bkz. {block name}

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

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

İstisna işleme

{try}

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

{try} bloğunun render edilmesi sırasında bir istisna oluşursa, tüm blok atılır ve render ondan sonra devam eder:

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

İsteğe bağlı {else} yan tümcesinin içeriği yalnızca bir istisna oluştuğunda render edilir:

{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 bir n:nitelik olarak da yazılabilir:

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

Örneğin günlükleme amacıyla kendi istisna işleyicinizi tanımlamak da mümkündür.

{rollback}

{try} bloğu {rollback} ile elle de durdurulup atlanabilir. Böylece tüm girdi verisini önceden denetlemeniz gerekmez ve ancak render sırasında nesnenin hiç render edilmemesi gerektiğine 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 yeni değişkenleri {var} etiketiyle oluştururuz:

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

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

{default} etiketi benzer çalışır, ama değişkenleri yalnızca yoksa oluşturur. Bir değişken zaten varsa ve null değeri taşıyorsa, üzerine yazılmaz:

{default $lang = 'en'}

Değişken tiplerini de belirtebilirsiniz. Şimdilik bilgilendiricidirler ve Latte onları denetlemez.

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

{parameters}

Bir fonksiyonun parametrelerini bildirmesi gibi, bir şablon da değişkenlerini başında bildirebilir:

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

Belirtilmiş varsayılan değeri olmayan $a ve $b değişkenlerinin varsayılan değeri otomatik olarak null olur. Bildirilen tipler şu anda bilgilendiricidir ve Latte onları denetlemez.

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

{capture}

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

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

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

Her çift etiket gibi, bu etiket de bir n:nitelik olarak yazılabilir:

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

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

Diğerleri

{contentType}

Şablonun temsil ettiği içerik tipini belirtmek için bu 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 kaçırabilir. Örneğin {contentType xml} XML moduna geçirir, {contentType text} kaçışı tamamen kapatır.

Parametre application/xml gibi tam bir MIME tipiyse, tarayıcıya Content-Type HTTP header'ı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}

Program çalışmasının duraklayacağı bir noktayı belirtir. Hata ayıklama amacıyla kullanılır ve programcının çalışma zamanı ortamını incelemesine ve kodun beklendiği gibi çalıştığından emin olmasına olanak tanır. Xdebug'u destekler. Programın ne zaman duraklayacağını belirleyen bir koşul da ekleyebilirsiniz.

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

{debugbreak $counter == 1}  {* koşul sağlanırsa programı duraklatır *}

{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 ifade demektir; bkz. PHP sınırlamaları.

{do $num++}

{dump}

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

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

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

Tracy kütüphanesini gerektirir.

{php}

Varsayılan olarak {php}, {do} için eskimiş bir takma ad gibi çalışır ve yalnızca tek bir ifadeyi değerlendirir. Herhangi bir PHP kodunu çalıştırmak için etiketin RawPhpExtension uzantısıyla etkinleştirilmesi gerekir.

{spaceless}

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

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

Şunu üretir:

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

Etiket bir n:nitelik olarak da yazılabilir.

{syntax}

Latte etiketlerinin yalnızca tek küme parantezi içine alınması gerekmez. Başka bir ayırıcı seçebilirsiniz, hatta çalışma zamanında. Bu, parametresi şunlar olabilen {syntax …} ile yapılır:

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

n:nitelikleri kullanarak Latte'yi örneğin yalnızca tek 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'in içinde çok rahat kullanılabilir; yalnızca bu örnekteki gibi {'nin hemen ardından bir harfin geldiği yapılardan kaçının, bkz. JavaScript veya CSS içinde Latte.

Latte'yi {syntax off} ile (yani n:nitelikle değil, etiketle) kapatırsanız, {/syntax}'a kadar tüm etiketleri kesinlikle yok sayar.

{trace}

Yığın izi şablonların ruhuna uyan bir Latte\RuntimeException istisnası fırlatır. Yani fonksiyon ve metot çağrıları yerine blok çağrılarını ve şablon eklemelerini içerir. Fırlatılan istisnaları anlaşılır biçimde gösteren Tracy gibi bir araç kullanıyorsanız, aktarılan tüm argümanlar dahil çağrı yığınını açıkça göreceksiniz.

HTML kodlayıcı yardımcıları

n:class

Latte 3.1'den beri standart HTML class niteliği aynı işlevselliği kazandı. Yani artık n:class kullanmanız gerekmez.

n:class sayesinde HTML class niteliğini tam olarak gerektiği gibi üretmek çok kolaydır.

Örnek: etkin elemanın active sınıfına sahip olmasını istiyorum:

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

Ve ayrıca ilk elemanın first ve main sınıflarına sahip olmasını istiyorum:

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

Ve tüm elemanların list-item sınıfına sahip olması gerekiyor:

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

İnanılmaz basit, değil mi?

n:attr

n:attr niteliği, class ile aynı zarafette herhangi bir HTML niteliğini üretebilir.

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

Döndürülen değerlere göre örneğin şunu yazdırır:

<input type="checkbox">

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

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

Latte 3.1'deki akıllı nitelik özellikleri, örneğin null değerleri düşürmek ya da class veya style'a dizi aktarmak, n:attr'nin içinde de çalışır:

<div n:attr="class: [a, b], title: $title"></div>

n:tag

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

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

$heading === null ise <h1> etiketi değişmeden yazdırılır. Aksi halde eleman adı değişkenin değerine göre değişir, yani $heading === 'h3' için şunu yazar:

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

Latte güvenli bir şablon sistemi olduğundan, yeni etiket adının geçerli olduğunu ve istenmeyen ya da kötücül değerler içermediğini denetler.

n:ifcontent

Boş bir HTML elemanının, yani boşluktan başka bir şey içermeyen bir elemanın yazdırılmasını engeller.

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

$error değişkeninin değerine göre şunu yazdırır:

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

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

Çeviri

Çeviri etiketlerinin çalışması için çevirmeni etkinleştirmeniz gerekir. Çeviri için translate filtresini de kullanabilirsiniz.

{_...}

Değerleri başka 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}

Şablonun bölümlerini çevirir:

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

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

Etiket, elemanın içini çevirmek için bir n:nitelik olarak da yazılabilir:

<h1 n:translate>Order</h1>