Tagi Latte
Przegląd i opis wszystkich znaczników systemu templatek Latte, które są domyślnie dostępne dla użytkownika.
{$var}, {...} lub {=...} |
drukuje wymazaną zmienną lub wyrażenie |
{$var|filter} |
drukuje z użyciem filtrów |
{l} lub {r} |
drukuje znak { nebo } |
{if}… {elseif}… {else}… {/if} |
warunek jeśli |
{ifset}… {elseifset}… {/ifset} |
ifset condition |
{ifchanged}… {/ifchanged} |
test, czy nastąpiła zmiana |
{switch} {case} {default} {/switch} |
warunek przełączenia |
n:else |
alternatywna zawartość dla warunków |
{foreach}… {/foreach} |
foreach |
{for}… {/for} |
dla |
{while}… {/while} |
while |
{continueIf $cond} |
kontynuuj z następną iteracją |
{skipIf $cond} |
pomiń iterację |
{breakIf $cond} |
break loop |
{exitIf $cond} |
wcześniejsze rozwiązanie umowy |
{first}… {/first} |
czy to pierwsze przejście? |
{last}… {/last} |
czy to ostatnie przejście? |
{sep}… {/sep} |
czy będzie kolejna przepustka? |
{iterateWhile}… {/iterateWhile} |
structured foreach |
$iterator |
specjalna zmienna wewnątrz foreach |
{include 'file.latte'} |
załaduj szablon z innego pliku |
{sandbox 'file.latte'} |
załaduj szablon w trybie piaskownicy |
{block} |
anonimowy blok |
{block blockname} |
definiuje blok |
{define blockname} |
definiuje blok do późniejszego wykorzystania |
{include blockname} |
render block |
{include blockname from 'file.latte'} |
renderuj blok z pliku |
{import 'file.latte'} |
pobierz bloki z szablonu |
{layout 'file.latte'} / {extends} |
definiuje plik układu |
{embed}… {/embed} |
ładuje szablon lub blok i pozwala na nadpisywanie bloków |
{ifset blockname}… {/ifset} |
czy blok istnieje |
{try}… {else}… {/try} |
obsługa wyjątków |
{rollback} |
odrzucenie bloku prób |
{var $foo = value} |
utwórz zmienną |
{default $foo = value} |
utwórz zmienną, jeśli nie istnieje |
{parameters} |
deklaruje zmienne, typy i wartości domyślne |
{capture}… {/capture} |
zapisuje blok w zmiennej |
{varType} |
deklaruje typ zmiennej |
{varPrint} |
sugeruje typy zmiennych |
{templateType} |
deklaruje typy zmiennych według klas |
{templatePrint} |
klasa projektowa ze zmiennymi typami |
| Wykonywanie tłumaczeń | |
{_...} |
drukuje tłumaczenie |
{translate}… {/translate} |
tłumaczy treść |
{contentType} |
przełączyć ucieczkę i wysłać nagłówek HTTP |
{debugbreak} |
Umieść punkt przerwania w kodzie |
{do} |
Wykonuje kod, ale nic nie drukuje |
{dump} |
Zrzuca zmienne do Tracy Bar |
{php} |
wykonuje dowolny kod PHP |
{spaceless}… {/spaceless} |
usuwa zbędne spacje |
{syntax} |
zmienić składnię w czasie pracy |
{trace} |
wyświetla ślad stosu |
n:class |
dynamiczne zapisywanie atrybutu klasy HTML |
n:attr |
dynamiczne zapisywanie dowolnych atrybutów HTML |
n:tag |
dynamiczny zapis nazwy elementu HTML |
n:ifcontent |
Pomiń pusty tag HTML |
n:href |
link używany w elementach HTML
<m id=410> <a> |
</m> {link} |
drukuje link |
{plink} |
drukuje link do prezentera |
{control} |
renderuje komponent |
{snippet}… {/snippet} |
snippet, który może być wysłany przez AJAX |
{snippetArea} |
clipping cover |
{cache}… {/cache} |
buforuje część szablonu |
{form}… {/form} |
renderuje znaczniki formularzy |
{label}… {/label} |
renderuje etykietę elementu formularza |
{input} |
renderuje element formularza |
{inputError} |
drukuje komunikat o błędzie elementu formularza |
n:name |
animuje element formularza |
{formContainer}… {/formContainer} |
renderowanie pojemnika na formularze |
Pisanie
{$var} {...} {=...}
W Latte znacznik {=...} służy do wyprowadzania na wyjście dowolnego wyrażenia. Latte zależy od wygody
użytkownika, więc jeśli wyrażenie zaczyna się od zmiennej lub wywołania funkcji, nie ma potrzeby pisania znaku równości.
Co w praktyce oznacza, że prawie nigdy nie musisz go pisać:
Jméno: {$name} {$surname}<br>
Věk: {date('Y') - $birth}<br>
Jako wyrażenie możesz napisać wszystko, co znasz z PHP. Po prostu nie musisz uczyć się nowego języka. Na przykład:
{='0' . ($num ?? $num * 3) . ', ' . PHP_VERSION}
Proszę nie szukać sensu w poprzednim przykładzie, ale jeśli jakiś znajdziecie, to napiszcie do nas :-)
Ucieczka od wyjścia
Jakie jest najważniejsze zadanie systemu templatkowania? Unikanie dziur w zabezpieczeniach. I właśnie to robi Latte za każdym razem, gdy coś wyprowadzasz. Automatycznie z niego ucieka:
<p>{='one < two'}</p> {* vypíše: '<p>one < two</p>' *}
Dokładnie mówiąc, Latte używa ucieczki kontekstowej, która jest tak ważną i unikalną rzeczą, że poświęciliśmy jej osobny rozdział.
A co jeśli wyprowadzasz treść zakodowaną w HTML z zaufanego źródła? Wtedy ucieczka może być łatwo wyłączona:
{$trustedHtmlString|noescape}
Niewłaściwe wykorzystanie filtra noescape może prowadzić do luki XSS! Nigdy nie używaj go,
jeśli nie jesteś całkowicie pewien co robisz i że łańcuch, który wyprowadzasz, pochodzi z zaufanego źródła.
Zrzutka w JavaScript
Ucieczka kontekstowa sprawia, że cudownie łatwo jest zrzucać zmienne wewnątrz JavaScript, a Latte zajmuje się odpowiednią ucieczką.
Zmienna nie musi być tylko ciągiem, obsługiwany jest dowolny typ danych, który następnie jest kodowany jako JSON:
{var $foo = ['hello', true, 1]}
<script>
alert({$foo});
</script>
Generuje:
<script>
alert(["hello", true, 1]);
</script>
Jest to również powód, dla którego cudzysłowy nie są napisane wokół zmiennej: Latte doda je dla ciągów. A jeśli chcesz umieścić zmienną łańcuchową w innym ciągu, po prostu konkatenuj je:
<script>
alert('Hello ' + {$name} + '!'); // OK
alert({="Hello $name!"}); // OK
alert('Hello {$name} !'); // CHYBA!
</script>
Filtry
Wymienione wyrażenie może być modyfikowane przez filtr. Na przykład przekonwertuj ciąg na duże litery i skróć go do maksymalnie 30 znaków:
{$string|upper|truncate:30}
W ten sposób można również stosować filtry do podczęści wyrażenia:
{$left . ($middle|upper) . $right}
Warunki
{if} {elseif} {else}
Warunki zachowują się tak samo jak ich odpowiedniki w PHP. Możesz też używać w nich tych samych wyrażeń, które znasz z PHP, nie musisz uczyć się nowego języka.
{if $product->inStock > Stock::Minimum}
Skladem
{elseif $product->isOnWay()}
Na cestě
{else}
Není dostupné
{/if}
Jak każda para znaczników, para {if} ... {/if} może być również zapisana w formie n:attribute, np:
<p n:if="$count > 0">Skladem {$count} kusů</p>
Czy wiesz, że możesz przedrostek tag- do n:atrybutów ? Wtedy warunek będzie dotyczył tylko wyjścia
znaczników HTML, a treść pomiędzy nimi będzie zawsze wyprowadzana:
<a href="..." n:tag-if="$clickable">Hello</a>
{* vypíše 'Hello' když $clickable je nepravdivá *}
{* vypíše '<a href="...">Hello</a>' když $clickable je pravdivá *}
Boże.
n:else
Jeśli warunek {if} ... {/if} zostanie zapisany w postaci atrybutu n:,
istnieje możliwość określenia alternatywnej gałęzi za pomocą n:else:
<strong n:if="$count > 0">In stock {$count} items</strong>
<em n:else>not available</em>
Atrybut n:else może być również użyty w połączeniu z n:ifset, n:foreach, n:try, n:ifcontentoraz n:ifchanged.
{/if $cond}
Możesz być zaskoczony, że wyrażenie w warunku {if} może być również zawarte w znaczniku kończącym. Jest
to przydatne w sytuacjach, gdy nie znamy wartości warunku w momencie jego otwarcia. Nazwijmy to decyzją odroczoną.
Na przykład zaczynamy zrzucać tabelę z rekordami z bazy danych i dopiero po zakończeniu zrzutu orientujemy się, że w
bazie nie było żadnego rekordu. Więc stawiamy na nim warunek w tagu końcowym {/if}, a jeśli nie ma rekordu, nic
nie jest wyrzucane:
{if}
<h1>Výpis řádků z databáze</h1>
<table>
{foreach $resultSet as $row}
...
{/foreach}
</table>
{/if isset($row)}
Poręczne, prawda?
Możesz również użyć {else}, ale nie {elseif}, w warunku odroczonym.
{ifset} {elseifset}
Zobacz także. {ifset block}
Użyj warunku {ifset $var}, aby określić, czy zmienna (lub wiele zmiennych) istnieje i ma wartość
non-null. Właściwie to jest to samo, co if (isset($var)) w PHP. Jak każdy znacznik par, może być
również napisany jako n:atrybut, więc weźmy to jako przykład:
<meta name="robots" content={$robots} n:ifset="$robots">
{ifchanged}
{ifchanged} sprawdza, czy wartość zmiennej zmieniła się od ostatniej iteracji w pętli (foreach, for lub
while).
Jeśli w znaczniku określisz jedną lub więcej zmiennych, sprawdzi on, czy któraś z nich uległa zmianie i odpowiednio wypisze jej zawartość. Na przykład, poniższy przykład wydrukuje pierwszą literę nazwy jako tytuł, gdy tylko zmieni się ona podczas wypisywania nazw:
{foreach ($names|sort) as $name}
{ifchanged $name[0]} <h2>{$name[0]}</h2> {/ifchanged}
<p>{$name}</p>
{/foreach}
Jednakże, jeśli nie podano żadnego argumentu, sprawdzi on wyrenderowaną zawartość względem jej poprzedniego stanu. Oznacza to, że w poprzednim przykładzie możemy bezpiecznie pominąć argument w znaczniku. Oczywiście możemy też użyć n:attribute:
{foreach ($names|sort) as $name}
<h2 n:ifchanged>{$name[0]}</h2>
<p>{$name}</p>
{/foreach}
Wewnątrz {ifchanged} możemy również umieścić klauzulę {else}.
{switch} {case} {default}
Porównuje wartość z wieloma opcjami. Jest to podobne do przykładu warunkowego switch, który znasz z PHP.
Latte jednak poprawia się w tym względzie:
- używa ścisłego porównania (
===) - nie musi
break
Jest to więc dokładny odpowiednik struktury match, z którą przychodzi PHP 8.0.
{switch $transport}
{case train}
Vlakem
{case plane}
Letecky
{default}
Jinak
{/switch}
Klauzula {case} może zawierać wiele wartości oddzielonych przecinkami:
{switch $status}
{case $status::New}<b>nová položka</b>
{case $status::Sold, $status::Unknown}<i>není dostupná</i>
{/switch}
Cykle
W Latte znajdziesz wszystkie cykle, które znasz z PHP: foreach, for i while.
{foreach}
Pętlę piszemy w taki sam sposób jak w PHP:
{foreach $langs as $code => $lang}
<span>{$lang}</span>
{/foreach}
Dodatkowo ma kilka fajnych funkcji, o których teraz porozmawiamy.
Na przykład Latte sprawdza, czy utworzone zmienne nie nadpisują przypadkiem zmiennych globalnych o tej samej nazwie. To
ratuje sytuacje, w których liczysz na to, że $lang zawiera aktualny język strony, a nie zdajesz sobie sprawy, że
foreach $langs as $lang nadpisał tę zmienną.
Pętla foreach może być również napisana bardzo elegancko i ekonomicznie przy użyciu atrybutu n::
<ul>
<li n:foreach="$items as $item">{$item->name}</li>
</ul>
Czy wiesz, że możesz przedrostek n:attributes z inner-? Wtedy w pętli będzie powtarzane tylko wnętrze
elementu:
<div n:inner-foreach="$items as $item">
<h4>{$item->title}</h4>
<p>{$item->description}</p>
</div>
Wydrukuje więc coś w rodzaju:
<div>
<h4>Foo</h4>
<p>Lorem ipsum.</p>
<h4>Bar</h4>
<p>Sit dolor.</p>
</div>
{else}
Wewnątrz pętli foreach może zawrzeć klauzulę {else}, której zawartość zostanie wyświetlona,
jeśli pętla jest pusta:
<ul>
{foreach $people as $person}
<li>{$person->name}</li>
{else}
<li><em>Litujeme, v tomto seznamu nejsou žádní uživatelé</em></li>
{/foreach}
</ul>
$iterator
Wewnątrz pętli foreach, Latte tworzy zmienną $iterator, którą możemy wykorzystać do uzyskania
przydatnych informacji o bieżącej pętli:
$iterator->first– czy przechodzi przez cykl po raz pierwszy?$iterator->last– czy to już ostatnie przejście?$iterator->counter– ile przejść liczy się od jednego?$iterator->counter0– ile przejść jest liczonych od zera?$iterator->odd– czy to przepustka z numerem nieparzystym?$iterator->even– czy jest to przepustka o numerach parzystych?$iterator->parent– iterator otaczający bieżący$iterator->nextValue– następny element w pętli$iterator->nextKey– klucz następnego elementu w pętli
{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 jest przebiegły i $iterator->last działa nie tylko dla tablic, ale także gdy pętla jest uruchamiana
nad generycznym iteratorem, w którym liczba elementów nie jest z góry znana.
{first} {last} {sep}
Znaczniki te mogą być użyte wewnątrz pętli {foreach}. renderowana jest zawartość strony
{first}, jeśli jest to pierwsze przejście. Zawartość strony {last} zostanie wyrenderowana … czy
można zgadnąć? Tak, jeśli to ostatnie przejście. Są to właściwie skróty dla {if $iterator->first} i
{if $iterator->last}.
Znaczniki mogą być również elegancko użyte jako n:attributes:
{foreach $rows as $row}
{first}<h1>List of names</h1>{/first}
<p>{$row->name}</p>
<hr n:last>
{/foreach}
Zawartość znacznika {sep} jest renderowana, jeśli przejście nie jest ostatnim, więc jest przydatna do
renderowania delimitatorów, takich jak linie pomiędzy wyszczególnianymi elementami:
{foreach $items as $item} {$item} {sep}, {/sep} {/foreach}
To całkiem poręczne, prawda?
{iterateWhile}
Upraszcza grupowanie danych liniowych podczas iteracji w pętli foreach poprzez iterację w pętli zagnieżdżonej do momentu spełnienia warunku. Przeczytaj instrukcję.
Może również elegancko zastąpić {first} i {last} w powyższym przykładzie:
{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}
Pętla jest napisana w taki sam sposób jak w PHP:
{for $i = 0; $i < 10; $i++}
<span>Položka {$i}</span>
{/for}
Znacznik ten może być również użyty jako n:attribut:
<h1 n:for="$i = 0; $i < 10; $i++">{$i}</h1>
{while}
Pętla znów jest napisana w taki sam sposób jak w PHP:
{while $row = $result->fetch()}
<span>{$row->title}</span>
{/while}
Albo jako n:atrybut:
<span n:while="$row = $result->fetch()">
{$row->title}
</span>
Możliwy jest również wariant z warunkiem w znaczniku końcowym, który odpowiada pętli do-while w PHP:
{while}
<span>{$item->title}</span>
{/while $item = $item->getNext()}
{continueIf} {skipIf} {breakIf}
Do sterowania dowolnym cyklem można użyć znaczników {continueIf ?} i {breakIf ?}, które
odpowiednio przejdą do następnego elementu i zakończą cykl po spełnieniu warunku:
{foreach $rows as $row}
{continueIf $row->date < $now}
{breakIf $row->parent === null}
...
{/foreach}
Znacznik {skipIf} jest bardzo podobny do {continueIf}, ale nie inkrementuje licznika
$iterator->counter, więc jeśli wymienimy go z pominięciem niektórych pozycji, nie będzie dziur w numeracji.
Również klauzula {else} jest renderowana, gdy pominiemy wszystkie wpisy.
<ul>
{foreach $people as $person}
{skipIf $person->age < 18}
<li>{$iterator->counter}. {$person->name}</li>
{else}
<li><em>Litujeme, v tomto seznamu nejsou žádní dospělí</em></li>
{/foreach}
</ul>
{exitIf}
Kończy renderowanie szablonu lub bloku, gdy spełniony jest warunek (early exit).
{exitIf !$messages}
<h1>Messages</h1>
<div n:foreach="$messages as $message">
{$message}
</div>
Wstawianie szablonu
{include 'file.latte'}
Zobacz także. {include block}
Znacznik {include} ładuje i renderuje podany szablon. Jeśli mówimy w języku naszego ulubionego języka PHP,
to jest to coś w stylu:
<?php include 'header.phtml'; ?>
Szablony zagnieżdżone nie mają dostępu do aktywnych zmiennych kontekstowych, mają tylko dostęp do zmiennych globalnych.
Do wstawionego szablonu można przekazać zmienne w następujący sposób:
{include 'template.latte', foo: 'bar', id: 123}
Nazwa szablonu może być dowolnym wyrażeniem PHP:
{include $someVar}
{include $ajax ? 'ajax.latte' : 'not-ajax.latte'}
Wstawioną treść można edytować za pomocą filtrów. Poniższy przykład usuwa cały HTML i dostosowuje wielkość liter:
<title>{include 'heading.latte' |stripHtml|capitalize}</title>
Domyślnie dziedziczenie szablonów nie jest w to zaangażowane. Chociaż można
dodawać znaczniki bloków do szablonów, które są dołączone, nie zastąpią one pasujących bloków w szablonie, do którego
są dołączone. Należy myśleć o załącznikach jako niezależnych i chronionych częściach stron lub modułów. To
zachowanie można zmienić za pomocą modyfikatora with blocks:
{include 'template.latte' with blocks}
Związek między nazwą pliku określoną w znaczniku a plikiem na dysku jest sprawą programu ładującego.
{sandbox}
W przypadku wstawiania szablonu utworzonego przez użytkownika końcowego należy rozważyć tryb piaskownicy (więcej informacji w dokumentacji pias kownicy):
{sandbox 'untrusted.latte', level: 3, data: $menu}
{block}
Zobacz także. {block name}
Nienazwane bloki są używane jako sposób na zastosowanie filtrów do części szablonu. Na przykład filtr paskowy można zastosować w ten sposób, aby usunąć niepotrzebne spacje:
{block|strip}
<ul>
<li>Hello World</li>
</ul>
{/block}
Zarządzanie wyjątkami
{try}
Marka ta niezwykle ułatwia tworzenie solidnych szablonów.
Jeśli podczas renderowania bloku {try} wystąpi wyjątek, cały blok zostanie wyrzucony, a renderowanie będzie
kontynuowane po nim:
{try}
<ul>
{foreach $twitter->loadTweets() as $tweet}
<li>{$tweet->text}</li>
{/foreach}
</ul>
{/try}
Zawartość w opcjonalnej klauzuli {else} będzie renderowana tylko w przypadku wystąpienia wyjątku:
{try}
<ul>
{foreach $twitter->loadTweets() as $tweet}
<li>{$tweet->text}</li>
{/foreach}
</ul>
{else}
<p>Je nám líto, nepodařilo se načíst tweety.</p>
{/try}
Znacznik ten może być również użyty jako n:attribute:
<ul n:try>
...
</ul>
Możliwe jest również zdefiniowanie niestandardowego handler'a wyjątków, na przykład dla logowania.
{rollback}
Blok {try} można również zatrzymać i pominąć ręcznie za pomocą {rollback}. W ten sposób nie
trzeba wcześniej sprawdzać wszystkich danych wejściowych i można w trakcie procesu renderowania zdecydować, że obiekt w
ogóle nie będzie renderowany:
{try}
<ul>
{foreach $people as $person}
{skipIf $person->age < 18}
<li>{$person->name}</li>
{else}
{rollback}
{/foreach}
</ul>
{/try}
Zmienne
{var} {default}
Utwórz nowe zmienne w szablonie z tagiem {var}:
{var $name = 'John Smith'}
{var $age = 27}
{* Wielokrotne deklaracje *}
{var $name = 'John Smith', $age = 27}
Znacznik {default} działa podobnie, z tym że tworzy zmienne tylko wtedy, gdy nie istnieją:
{default $lang = 'cs'}
Można również określić typy zmiennych. Na razie mają one charakter informacyjny i Latte ich nie sprawdza.
{var string $name = $article->getTitle()}
{default int $id = 0}
{parameters}
Podobnie jak funkcja deklaruje swoje parametry, szablon może zadeklarować swoje zmienne na początku:
{parameters
$a,
?int $b,
int|string $c = 10
}
Zmienne $a i $b bez zadeklarowanej wartości domyślnej automatycznie domyślnie przyjmują wartość
null. Zadeklarowane typy są nadal informacyjne i nie są sprawdzane przez Latte.
Zmienne inne niż zadeklarowane nie są przekazywane do szablonu. To jest coś innego niż tag {default}.
{capture}
Przechwytuje dane wyjściowe do zmiennej:
{capture $var}
<ul>
<li>Hello World</li>
</ul>
{/capture}
<p>Captured: {$var}</p>
Znacznik może być również zapisany jako n:attribute, jak każdy znacznik parami:
<ul n:capture="$var">
<li>Hello World</li>
</ul>
Dane wyjściowe HTML są przechowywane w zmiennej $var jako obiekt Latte\Runtime\Html, aby uniknąć niechcianych ucieczek podczas drukowania.
Inne
{contentType}
Użyj znacznika, aby określić, jaki typ treści reprezentuje szablon. Dostępne opcje to:
html(typ domyślny)xmljavascriptcsscalendar(iCal)text
Jego użycie jest ważne, ponieważ ustawia ucieczkę kontekstową
i tylko wtedy ucieczka może działać poprawnie. Na przykład {contentType xml} przełącza się na tryb XML,
{contentType text} całkowicie wyłącza escaping.
Jeśli parametr jest pełnym typem MIME, takim jak application/xml, wyśle również nagłówek HTTP
Content-Type do przeglądarki:
{contentType application/xml}
<?xml version="1.0"?>
<rss version="2.0">
<channel>
<title>RSS feed</title>
<item>
...
</item>
</channel>
</rss>
{debugbreak}
Wskazuje punkt, w którym program jest wstrzymywany i uruchamiany jest debugger, aby programista mógł zbadać środowisko uruchomieniowe i sprawdzić, czy program działa zgodnie z oczekiwaniami. Obsługuje Xdebug. Można dodać warunek określający, kiedy program powinien zostać zawieszony.
{debugbreak} {* zawieszenie programu *}
{debugbreak $counter == 1} {* zawieszenie programu po spełnieniu warunku *}
{do}
Wykonuje kod PHP i niczego nie drukuje. Podobnie jak w przypadku wszystkich innych znaczników, kod PHP jest pojedynczym wyrażeniem, patrz ograniczenia PHP.
{do $num++}
{dump}
Wypisuje zmienną lub bieżący kontekst.
{dump $name} {* Zrzuca zmienną $name *}
{dump} {* Zrzuca wszystkie aktualnie zdefiniowane zmienne *}
Wymaga biblioteki Tracy.
{php}
Umożliwia wykonanie dowolnego kodu PHP. Tag musi być aktywowany przy użyciu rozszerzenia RawPhpExtension.
{spaceless}
Usuwa niepotrzebne białe spacje z wyjścia. Działa podobnie jak filtr bezprzestrzenny.
{spaceless}
<ul>
<li>Hello</li>
</ul>
{/spaceless}
Generuje
<ul> <li>Hello</li> </ul>
Znacznik może być również zapisany jako n:attribut.
{syntax}
Znaki latte nie muszą ograniczać się do prostych nawiasów złożonych. Możemy też wybrać inny delimiter, nawet w locie.
Można to zrobić na stronie {syntax …}, gdzie jako parametr można podać:
- podwójne:
{{...}} - off: całkowicie wyłącza przetwarzanie znaczników Latte
Używając n:attributes, możesz wyłączyć Latte dla tylko jednego bloku JavaScript:
<script n:syntax="off">
var obj = {var: 123}; // tohle už není tag
</script>
Latte może być również używane bardzo wygodnie wewnątrz JavaScript, wystarczy unikać konstrukcji takich jak w tym
przykładzie, gdzie litera następuje po {, zobacz Latte
wewnątrz JavaScript lub CSS.
Jeśli wyłączysz Latte za pomocą {syntax off} (tj. za pomocą tagu, a nie atrybutu n:), będzie ona
konsekwentnie ignorować wszystkie tagi aż do {/syntax}
{trace}
Rzuca wyjątek Latte\RuntimeException, którego ślad stosu jest zgodny z linią szablonów. To znaczy, zamiast
wywoływania funkcji i metod, zawiera wywołania bloków i wstawianie szablonów. Jeśli używasz narzędzia do wyraźnego
wyświetlania rzuconych wyjątków, takich jak Tracy, zobaczysz wyraźnie stos
wywołań, w tym wszystkie przekazane argumenty.
Pomocnicy kodera HTML
n:klasa
Dzięki n:class możesz w łatwy sposób wygenerować atrybut HTML class dokładnie taki, jaki
chcesz.
Przykład: potrzebuję, aby aktywny element miał klasę active:
{foreach $items as $item}
<a n:class="$item->isActive() ? active">...</a>
{/foreach}
I dalej, pierwszy element powinien mieć klasy first i main:
{foreach $items as $item}
<a n:class="$item->isActive() ? active, $iterator->first ? 'first main'">...</a>
{/foreach}
A wszystkie elementy powinny mieć klasę list-item:
{foreach $items as $item}
<a n:class="$item->isActive() ? active, $iterator->first ? 'first main', list-item">...</a>
{/foreach}
Zadziwiająco proste, prawda?
n:attr
Atrybut n:attr może generować dowolne atrybuty HTML z taką samą elegancją jak n:class.
{foreach $data as $item}
<input type="checkbox" n:attr="value: $item->getValue(), checked: $item->isActive()">
{/foreach}
W zależności od zwróconych wartości wyprowadza np:
<input type="checkbox">
<input type="checkbox" value="Hello">
<input type="checkbox" value="Hello" checked>
n:tag
Atrybut n:tag może dynamicznie zmieniać nazwę elementu HTML.
<h1 n:tag="$heading" class="main">{$title}</h1>
Jeśli jest to $heading === null, tag jest drukowany bez zmian. <h1>. W przeciwnym razie nazwa
elementu jest zmieniana na wartość zmiennej, więc jest drukowana dla $heading === 'h3':
<h3 class="main">...</h3>
Ponieważ Latte jest bezpiecznym systemem szablonów, sprawdza, czy nowa nazwa tagu jest poprawna i nie zawiera żadnych niepożądanych lub złośliwych wartości.
n:ifcontent
Zapobiega wypisaniu pustego elementu HTML, tj. elementu zawierającego tylko spacje.
<div>
<div class="error" n:ifcontent>{$error}</div>
</div>
Drukuje w zależności od wartości zmiennej $error:
{* $error = '' *}
<div>
</div>
{* $error = 'Required' *}
<div>
<div class="error">Required</div>
</div>
Tłumaczenia
Aby tagi tłumaczące działały, należy aktywować translator. Możesz
również użyć filtra do tłumaczenia translate.
{_...}
Tłumaczy wartości na inne języki.
<a href="basket">{_'Košík'}</a>
<span>{_$item}</span>
Inne parametry mogą być przekazane do tłumacza:
<a href="basket">{_'Košík', domain: order}</a>
{translate}
Tłumaczy części szablonu:
<h1>{translate}Objednávka{/translate}</h1>
{translate domain: order}Lorem ipsum ...{/translate}
Znacznik może być również zapisany jako n:attribut, aby przetłumaczyć wnętrze elementu:
<h1 n:translate>Objednávka</h1>