Latte Etiketleri
Tüm Latte yerleşik etiketlerinin özeti ve açıklaması.
{$var}, {...} veya {=...} |
öncelenmiş bir değişken veya ifade yazdırır |
{$var|filter} |
filtrelerle yazdırır |
{l} veya {r} |
{ or } karakterini yazdırır |
{if}… {elseif}… {else}… {/if} |
eğer koşulu |
{ifset}… {elseifset}… {/ifset} |
koşul ifset |
{ifchanged}… {/ifchanged} |
bir değişiklik olup olmadığını test edin |
{switch} {case} {default} {/switch} |
koşul anahtarı |
n:else |
koşullar için alternatif içerik |
{foreach}… {/foreach} |
foreach |
{for}… {/for} |
için |
{while}… {/while} |
while |
{continueIf $cond} |
sonraki yinelemeye devam et |
{skipIf $cond} |
geçerli döngü yinelemesini atla |
{breakIf $cond} |
döngüyü kırar |
{exitIf $cond} |
erken çıkış |
{first}… {/first} |
bu ilk y ineleme mi? |
{last}… {/last} |
bu son yineleme mi? |
{sep}… {/sep} |
bir sonraki yineleme takip edecek mi? |
{iterateWhile}… {/iterateWhile} |
yapılandırılmış foreach |
$iterator |
foreach döngüsü içinde özel değişken |
{include 'file.latte'} |
başka bir dosyadan şablon içerir |
{sandbox 'file.latte'} |
sandbox modunda bir şablon içerir |
{block} |
anonim blok |
{block blockname} |
blok tanımı |
{define blockname} |
gelecekteki kullanım için blok tanımı |
{include blockname} |
blok yazdırır |
{include blockname from 'file.latte'} |
dosyadan bir blok yazdırır |
{import 'file.latte'} |
blokları başka bir şablondan yükler |
{layout 'file.latte'} / {extends} |
bir düzen dosyası belirtir |
{embed}… {/embed} |
şablonu veya bloğu yükler ve blokların üzerine yazmanıza izin verir |
{ifset blockname}… {/ifset} |
blok tanımlanmışsa koşul |
{try}… {else}… {/try} |
istisnaları yakalama |
{rollback} |
deneme bloğunu atar |
{var $foo = value} |
değişken oluşturma |
{default $foo = value} |
değişken bildirilmediğinde varsayılan değer |
{parameters} |
değişkenleri bildirir, varsayılan değerleri yazar |
{capture}… {/capture} |
bir bölümü bir değişkene kaydeder |
{varType} |
değişkenin türünü bildirir |
{varPrint} |
değişken türlerini önerir |
{templateType} |
sınıf kullanarak değişken türlerini bildirir |
{templatePrint} |
özellikli sınıf oluşturur |
{_string} |
çevrilmiş olarak yazdırır |
{translate}… {/translate} |
içeriği çevirir |
{contentType} |
kaçış modunu değiştirir ve HTTP başlığı gönderir |
{debugbreak} |
koda kesme noktası koyar |
{do} |
bir ifadeyi yazdırmadan değerlendirir |
{dump} |
değişkenleri Tracy Bar'a döker |
{php} |
herhangi bir PHP kodunu çalıştırır |
{spaceless}… {/spaceless} |
gereksiz boşlukları kaldırır |
{syntax} |
çalışma zamanında sözdizimini değiştirir |
{trace} |
yığın izini gösterir |
n:class |
akıllı sınıf niteliği |
n:attr |
akıllı HTML nitelikleri |
n:tag |
HTML öğesinin dinamik adı |
n:ifcontent |
Boş HTML etiketini atlayın |
n:href |
<a> HTML
öğelerindeki bağlantı |
{link} |
bir bağlantı yazdırır |
{plink} |
sunum yapan kişiye bir bağlantı yazdırır |
{control} |
bir bileşen yazdırır |
{snippet}… {/snippet} |
AJAX ile gönderilebilecek bir şablon parçacığı |
{snippetArea} |
snippets zarfı |
{cache}… {/cache} |
bir şablon bölümünü önbelleğe alır |
{form}… {/form} |
bir form öğesi yazdırır |
{label}… {/label} |
bir form giriş etiketi yazdırır |
{input} |
bir form giriş öğesi yazdırır |
{inputError} |
form giriş öğesi için hata mesajı yazdırır |
n:name |
bir HTML giriş öğesini etkinleştirir |
{formContainer}… {/formContainer} |
form kapsayıcısını oluşturma |
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 < 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}
Bir koşul sağlanana kadar iç içe bir döngüde yineleme yaparak foreach döngüsünde yineleme sırasında doğrusal verilerin gruplanmasını basitleştirir. Ayrıntılı 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}
Ayrıca bkz. toplu iş ve grup filtreleri.
{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.
Bir değişken zaten mevcutsa ve null içeriyorsa, üzerine yazılmaz:
{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)xmljavascriptcsscalendar(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>