Sözdizimi

Latte'nin sözdizimi, web tasarımcılarının pratik gereksinimlerinden doğdu. Aksi halde gerçek bir zorluk olan yapıları zarif biçimde yazabileceğiniz, kullanıcıya en dostça sözdizimini arıyorduk. Aynı zamanda tüm ifadeler tam olarak PHP'deki gibi yazılır, bu yüzden yeni bir dil öğrenmeniz gerekmez. Yalnızca bildiklerinizden yararlanırsınız.

Aşağıda birkaç temel öğeyi gösteren en yalın şablon var: etiketler, n:nitelikleri, yorumlar ve filtreler.

{* bu bir yorumdur *}
<ul n:if=$items>                  {* n:if bir n:niteliğidir *}
{foreach $items as $item}         {* foreach döngüsünü temsil eden etiket *}
	<li>{$item|capitalize}</li>   {* bir değişkeni filtreyle yazdıran etiket *}
{/foreach}                        {* döngünün sonu *}
</ul>

Bu önemli öğelere ve harika bir şablon oluşturmanıza nasıl yardım edebileceklerine daha yakından bakalım.

Etiketler

Bir şablon, şablon mantığını denetleyen (örneğin foreach döngüleri) ya da ifadeleri yazdıran etiketler içerir. İkisi için de tek bir sınırlayıcı { ... } kullanılır, bu yüzden diğer sistemlerin aksine hangi durumda hangi sınırlayıcıyı kullanacağınızı düşünmeniz gerekmez. { karakterinin hemen ardından boşluk, tırnak ya da başka bir { veya } geliyorsa, Latte onu bir etiketin başlangıcı saymaz; böylece şablonlarınızda JavaScript yapılarını, JSON'u veya CSS kurallarını sorunsuz kullanabilirsiniz.

Tüm etiketlere genel bakışa bakın. Ayrıca kendi özel etiketlerinizi oluşturabilirsiniz. { } sınırlayıcılarını değiştirebilir ya da tamamen kapatabilirsiniz ({syntax double}, {syntax off} veya n:syntax niteliğiyle); bkz. sözdizimini değiştirme.

Latte PHP'yi anlar

Etiketlerin içinde, bildiğiniz PHP ifadelerini kullanabilirsiniz:

• değişkenler
• dizeler (HEREDOC ve NOWDOC dahil), diziler, sayılar vb.
• operatörler
• fonksiyon ve metot çağrıları (sandbox ile kısıtlanabilir)
• match
• ok fonksiyonları
• first class callable sözdizimi
• çok satırlı yorumlar /* ... */
• vb…

Ayrıca Latte, PHP sözdizimini birkaç hoş uzantıyla zenginleştirir.

n:nitelikleri

Tek bir HTML elemanı üzerinde çalışan her çift etiket, örneğin {if} … {/if}, n:niteliği biçiminde yeniden yazılabilir. Örneğin giriş örneğindeki {foreach} şöyle de yazılabilirdi:

<ul n:if=$items>
	<li n:foreach="$items as $item">{$item|capitalize}</li>
</ul>

İşlevsellik o zaman, yerleştirildiği HTML elemanına uygulanır:

{var $items = ['I', '♥', 'Latte']}

<p n:foreach="$items as $item">{$item}</p>

şunu üretir:

<p>I</p>
<p>♥</p>
<p>Latte</p>

inner- ön ekini kullanarak davranışı, yalnızca elemanın iç bölümüne uygulanacak şekilde değiştirebiliriz:

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

Şunu üretir:

<div>
	<p>I</p>
	<hr>
	<p>♥</p>
	<hr>
	<p>Latte</p>
	<hr>
</div>

Ya da tag- ön ekini kullanarak işlevselliği yalnızca HTML etiketlerinin kendisine uygularız:

<p><a href={$url} n:tag-if="$url">Title</a></p>

Bu, $url değişkenine göre şunu üretir:

{* $url boşken *}
<p>Title</p>

{* $url 'https://nette.org' içerirken *}
<p><a href="https://nette.org">Title</a></p>

Ancak n:nitelikleri yalnızca çift etiketlerin kısayolu değildir, saf n:nitelikleri de vardır; örneğin kodlayıcının en iyi dostu n:class veya çok kullanışlı n:href.

Tırnaklı sözdizimi <div n:if="$foo"> yanında, küme parantezli alternatif sözdizimini <div n:if={$foo}> de kullanabilirsiniz. Başlıca avantajı, {...} içinde hem tek hem çift tırnağı serbestçe kullanabilmenizdir:

<div n:if={str_contains($val, "foo")}> ... </div>

Akıllı HTML nitelikleri

Latte, standart HTML nitelikleriyle çalışmayı inanılmaz kolaylaştırır. checked gibi boole niteliklerini sizin için halleder, null içeren nitelikleri kaldırır ve class ile style değerlerini dizilerle oluşturmanıza olanak tanır. data- nitelikleri için veriyi JSON'a bile otomatik serileştirir.

{* null niteliği kaldırır *}
<div title={$title}>

{* boole, boole niteliklerinin varlığını denetler *}
<input type="checkbox" checked={$isChecked}>

{* class'ta diziler çalışır *}
<div class={['btn', 'btn-primary', active => $isActive]}>

{* data- niteliklerinde diziler JSON'a kodlanır *}
<div data-config={[theme: dark, version: 2]}>

Daha fazlasını ayrı bölümde okuyun: Akıllı HTML nitelikleri.

Filtreler

Standart filtrelere genel bakışa bakın.

Filtreler boru simgesinden sonra yazılır (önünde boşluğa izin verilir):

<h1>{$heading|upper}</h1>

Filtreler zincirlenebilir ve soldan sağa sırayla uygulanırlar:

<h1>{$heading|lower|capitalize}</h1>

Argümanlar filtre adının ardından iki nokta üst üsteyle gelir, sonrakiler virgülle ayrılır; parantezli çağrı da çalışır:

<h1>{$heading|truncate:20,''}</h1>
<h1>{$heading|truncate(20, '')}</h1>

Filtreler bir ifadeye de uygulanabilir:

{var $name = ($title|upper) . ($subtitle|lower)}

Bir bloğa:

<h1>{block |lower}{$heading}{/block}</h1>

Ya da doğrudan bir değere ({=expr} etiketiyle birlikte):

<h1>{='  Hello world  '|trim}</h1>

Değer null olabiliyorsa ve bu durumda filtrenin uygulanmasından kaçınmak istiyorsanız, nullsafe filtresini ?| kullanın:

<h1>{$heading?|upper}</h1>

Dinamik HTML etiketleri

Latte, etiket adlarında esnekliğe ihtiyaç duyduğunuzda yararlı olan dinamik HTML etiketlerini destekler:

<h{$level}>Heading</h{$level}>

Örneğin yukarıdaki kod, $level değişkeninin değerine göre <h1>Heading</h1> veya <h2>Heading</h2> üretebilir. Latte'deki dinamik HTML etiketleri her zaman çift olmalıdır. Alternatifleri n:tag'dir.

Latte güvenli bir şablon sistemi olduğundan, ortaya çıkan etiket adının geçerli olduğunu ve istenmeyen ya da kötücül değerler içermediğini denetler. Ayrıca kapanış etiketi adının her zaman açılış etiketi adıyla eşleştiğinden emin olur.

Yorumlar

Yorumlar şöyle yazılır ve çıktıya girmez:

{* bu Latte'de bir yorumdur *}

Etiketlerin içinde PHP yorumları çalışır:

{include 'file.info', /* value: 123 */}

Boşluk denetimi

Latte, boşlukları akıllıca halleder. Okunabilirlik için kodunuzu serbestçe girintileyebilirsiniz, çıktı temiz kalır. Bir denetim etiketi bir satırda tek başına bulunuyorsa, tüm satır (girinti ve satır sonu) çıktıdan kaldırılır (bu, {$var}, {=...} veya {_...} gibi çıktı yazdıran etiketler için geçerli değildir; onlar girintilerini ve sondaki satır sonlarını korur):

<ul>
	{foreach $items as $item}
	<li>{$item}</li>
	{/foreach}
</ul>

Şunu üretir:

<ul>
	<li>foo</li>
	<li>bar</li>
</ul>

Peki ya bir etiket satırda tek başına değil de başka içerikle birlikteyse? O zaman etiketten önceki boşluk etiketin içine aittir:

<div>
	{if $foo}hello{/if}
</div>

Girinti aslında {if}'in içindedir: $foo yanlışken hiçbir şey yazdırılmaz; ne girinti ne de boş satır. $foo doğruyken çıktı doğal olarak girintiyi de içerir. Siz yalnızca iyi yapılandırılmış şablonlar yazarsınız, çıktı her zaman temiz olur.

Daha da temiz bir çıktı için, {if} veya {foreach} gibi çift etiketlerin içindeki iç içelikten kaynaklanan girintiyi de kaldıran Dedent özelliğini etkinleştirebilirsiniz.

Sözdizimsel şeker

Tırnaksız dizeler

Basit dizelerde tırnaklar atlanabilir:

PHP'deki gibi: {var $arr = ['hello', 'btn--default', '€']}

kısaltılmış:   {var $arr = [hello, btn--default, €]}

Basit dizeler, yalnızca harflerden, rakamlardan, alt çizgilerden, kısa çizgilerden ve noktalardan oluşanlardır. Bir rakamla başlamamalı, kısa çizgiyle başlamamalı veya bitmemelidir. Yalnızca büyük harflerden ve alt çizgilerden oluşmamalıdır, çünkü o zaman sabit sayılırlar (örneğin PHP_VERSION). Ve şu anahtar sözcüklerle çakışmamalıdırlar: and, array, clone, default, false, in, instanceof, new, null, or, return, true, xor.

Sabitler

Genel sabitleri basit dizelerden ayırmak için genel isim alanı ayırıcısını kullanın:

{if \PROJECT_ID === 1} ... {/if}

Bu yazım PHP'nin kendisinde de tamamen geçerlidir; orada ters eğik çizgi, sabitin genel isim alanında olduğunu belirtir.

Kısa üçlü operatör

Üçlü operatörün üçüncü değeri boşsa atlanabilir:

PHP'deki gibi: {$stock ? 'In stock' : ''}

kısaltılmış:   {$stock ? 'In stock'}

Dizilerde modern anahtar yazımı

Dizi anahtarları, fonksiyon çağrılarındaki adlandırılmış parametrelere benzer biçimde yazılabilir:

PHP'deki gibi: {var $arr = ['one' => 'item 1', 'two' => 'item 2']}

modern:        {var $arr = [one: 'item 1', two: 'item 2']}

Filtreler

Filtreler herhangi bir ifadeye kullanılabilir; ifadenin tamamını parantez içine almanız yeterlidir:

{var $content = ($text|truncate: 30|upper)}

in operatörü

in operatörü, in_array() fonksiyonunun yerini alabilir. Karşılaştırma her zaman katıdır:

{* in_array($item, $items, true) gibi *}
{if $item in $items}
	...
{/if}

Tarihe açılan bir pencere

Latte, tarihi boyunca PHP'nin kendisinde birkaç yıl sonra ortaya çıkan çeşitli sözdizimsel şekerleri getirdi. Örneğin Latte'de dizileri array(1, 2, 3) yerine [1, 2, 3] diye yazmak ya da nullsafe operatörü $obj?->foo kullanmak, PHP'nin kendisinde mümkün olmadan çok önce yapılabiliyordu. Latte ayrıca, bugünkü PHP ...$arr operatörüne denk olan dizi açma operatörü (expand) $arr'ı getirdi.

Latte'deki PHP sınırlamaları

Latte'de yalnızca PHP ifadeleri yazılabilir. Yani noktalı virgülle biten deyimler kullanılamaz. Sınıf bildiremez ya da if, foreach, switch, return, try, throw ve benzerleri gibi denetim yapılarını kullanamazsınız; bunlar için Latte kendi etiketlerini sunar. Nitelikleri, ters tırnakları veya bazı sihirli sabitleri de kullanamazsınız. unset, echo, include, require, exit, eval de kullanılamaz, çünkü bunlar fonksiyon değil, özel PHP dil yapılarıdır ve dolayısıyla ifade değildirler. Yalnızca çok satırlı yorumlar /* ... */ desteklenir.

Ancak bu sınırlamalar, şablon yazarının sorumluluğunda {php ...} etiketinin içinde herhangi bir PHP kodunu kullanmanıza olanak tanıyan RawPhpExtension uzantısı etkinleştirilerek aşılabilir.