Tagi Latte

Przegląd i opis wszystkich znaczników systemu templatek Latte, które są domyślnie dostępne dla użytkownika.

Spis treści
{$var}, {...} lub {=...} drukuje wymazaną zmienną lub wyrażenie
{$var|filter} drukuje z użyciem filtrów
{l} lub {r} drukuje znak { nebo }
Warunki
{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
Cykle
{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
Wstawianie innych szablonów
{include 'file.latte'} załaduj szablon z innego pliku
{sandbox 'file.latte'} załaduj szablon w trybie piaskownicy
Bloki, układy, dziedziczenie szablonów
{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
Obsługa wyjątków
{try}{else}{/try} obsługa wyjątków
{rollback} odrzucenie bloku prób
Zmienne
{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
Rodzajów
{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ść
Inne
{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
Pomocnicy kodera HTML
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
Dostępne tylko w Nette Framework
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
Dostępne tylko z Nette Forms
{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 &lt; 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)
  • xml
  • javascript
  • css
  • calendar (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>
wersja: 3.0