Nette Documentation Preview

syntax
Tagi Latte
**********

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

.[table-latte-tags language-latte]
|## Spis treści
| `{$var}`, `{...}` lub `{=...}` | [drukuje wymazaną zmienną lub wyrażenie |#Printing]
| `{$var\|filter}` | [drukuje z użyciem filtrów |#Filters]
| `{l}` lub `{r}` | drukuje znak `{` nebo `}`

.[table-latte-tags language-latte]
|## Warunki
| `{if}`... `{elseif}`... `{else}`... `{/if}` | [warunek jeśli |#if-elseif-else]
| `{ifset}`... `{elseifset}`... `{/ifset}` | [ifset condition |#ifset-elseifset]
| `{ifchanged}`... `{/ifchanged}` | [test, czy nastąpiła zmiana |#ifchanged]
| `{switch}` `{case}` `{default}` `{/switch}` | [warunek przełączenia |#switch-case-default]
| `n:else` | [alternatywna zawartość dla warunków |#n:else]

.[table-latte-tags language-latte]
|## Cykle
| `{foreach}`... `{/foreach}` | [foreach |#foreach]
| `{for}`... `{/for}` | [dla |#for]
| `{while}`... `{/while}` | [while |#while]
| `{continueIf $cond}` | [kontynuuj z następną iteracją |#continueIf-skipIf-breakIf]
| `{skipIf $cond}` | [pomiń iterację |#continueIf-skipIf-breakIf]
| `{breakIf $cond}` | [break loop |#continueIf-skipIf-breakIf]
| `{exitIf $cond}` | [wcześniejsze rozwiązanie umowy|#exitIf]
| `{first}`... `{/first}` | [czy to pierwsze przejście? |#first-last-sep]
| `{last}`... `{/last}` | [czy to ostatnie przejście? |#first-last-sep]
| `{sep}`... `{/sep}` | [czy będzie kolejna przepustka? |#first-last-sep]
| `{iterateWhile}`... `{/iterateWhile}` | [structured foreach |#iterateWhile]
| `$iterator` | [specjalna zmienna wewnątrz foreach |#iterator]

.[table-latte-tags language-latte]
|## Wstawianie innych szablonów
| `{include 'file.latte'}` | [załaduj szablon z innego pliku |#include]
| `{sandbox 'file.latte'}` | [załaduj szablon w trybie piaskownicy |#sandbox]

.[table-latte-tags language-latte]
|## Bloki, układy, dziedziczenie szablonów
| `{block}` | [anonimowy blok |#block]
| `{block blockname}` | [definiuje blok |template-inheritance#Blocks]
| `{define blockname}` | [definiuje blok do późniejszego wykorzystania |template-inheritance#Definitions]
| `{include blockname}` | [render block |template-inheritance#Printing-Blocks]
| `{include blockname from 'file.latte'}` | [renderuj blok z pliku |template-inheritance#Printing-Blocks]
| `{import 'file.latte'}` | [pobierz bloki z szablonu |template-inheritance#Horizontal-Reuse]
| `{layout 'file.latte'}` / `{extends}` | [definiuje plik układu |template-inheritance#Layout Inheritance]
| `{embed}`... `{/embed}` | [ładuje szablon lub blok i pozwala na nadpisywanie bloków |template-inheritance#Unit-Inheritance]
| `{ifset blockname}`... `{/ifset}` | [czy blok istnieje |template-inheritance#Checking-Block-Existence]

.[table-latte-tags language-latte]
|## Obsługa wyjątków
| `{try}`... `{else}`... `{/try}` | [obsługa wyjątków |#try]
| `{rollback}` | [odrzucenie bloku prób |#rollback]

.[table-latte-tags language-latte]
|## Zmienne
| `{var $foo = value}` | [utwórz zmienną |#var-default]
| `{default $foo = value}` | [utwórz zmienną, jeśli nie istnieje |#var-default]
| `{parameters}` | [deklaruje zmienne, typy i wartości domyślne |#parameters]
| `{capture}`... `{/capture}` | [zapisuje blok w zmiennej |#capture]

.[table-latte-tags language-latte]
|## Rodzajów
| `{varType}` | [deklaruje typ zmiennej |type-system#varType]
| `{varPrint}` | [sugeruje typy zmiennych |type-system#varPrint]
| `{templateType}` | [deklaruje typy zmiennych według klas |type-system#templateType]
| `{templatePrint}` | [klasa projektowa ze zmiennymi typami |type-system#templatePrint]

.[table-latte-tags language-latte]
|Wykonywanie tłumaczeń
| `{_...}` | [drukuje tłumaczenie |#Translation]
| `{translate}`... `{/translate}` | [tłumaczy treść |#Translation]

.[table-latte-tags language-latte]
|## Inne
| `{contentType}` | [przełączyć ucieczkę i wysłać nagłówek HTTP |#contentType]
| `{debugbreak}` | [Umieść punkt przerwania w kodzie |#debugbreak]
| `{do}` | [Wykonuje kod, ale nic nie drukuje |#do]
| `{dump}` | [Zrzuca zmienne do Tracy Bar |#dump]
| `{php}` | [wykonuje dowolny kod PHP |#php]
| `{spaceless}`... `{/spaceless}` | [usuwa zbędne spacje |#spaceless]
| `{syntax}` | [zmienić składnię w czasie pracy |#Syntax]
| `{trace}` | [wyświetla ślad stosu |#trace]

.[table-latte-tags language-latte]
|## Pomocnicy kodera HTML
| `n:class` | [dynamiczne zapisywanie atrybutu klasy HTML |#n-class]
| `n:attr` | [dynamiczne zapisywanie dowolnych atrybutów HTML |#n-attr]
| `n:tag` | [dynamiczny zapis nazwy elementu HTML |#n-tag]
| `n:ifcontent` | [Pomiń pusty tag HTML |#n-ifcontent]

.[table-latte-tags language-latte]
|## Dostępne tylko w Nette Framework
| `n:href` | [link używany w elementach HTML |application:creating-links#In-the-Presenter-Template] <m id=410> `<a>`
|</m> `{link}` | [drukuje link |application:creating-links#In-the-Presenter-Template]
| `{plink}` | [drukuje link do prezentera |application:creating-links#In-the-Presenter-Template]
| `{control}` | [renderuje komponent |application:components#Rendering]
| `{snippet}`... `{/snippet}` | [snippet, który może być wysłany przez AJAX |application:ajax#snippets-in-latte]
| `{snippetArea}` | [clipping cover |application:ajax#snippet-areas]
| `{cache}`... `{/cache}` | [buforuje część szablonu |caching:#Caching-in-Latte]

.[table-latte-tags language-latte]
|## Dostępne tylko z Nette Forms
| `{form}`... `{/form}` | [renderuje znaczniki formularzy |forms:rendering#form]
| `{label}`... `{/label}` | [renderuje etykietę elementu formularza |forms:rendering#label-input]
| `{input}` | [renderuje element formularza |forms:rendering#label-input]
| `{inputError}` | [drukuje komunikat o błędzie elementu formularza |forms:rendering#inputError]
| `n:name` | [animuje element formularza |forms:rendering#n:name]
| `{formContainer}`... `{/formContainer}` | [renderowanie pojemnika na formularze |forms:rendering#special-cases]


Pisanie .[#toc-printing]
========================


`{$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ć:

```latte
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:


```latte
{='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 .[#toc-escaping-output]
-------------------------------------------

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:

```latte
<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ł |safety-first#Context-Aware-Escaping].

A co jeśli wyprowadzasz treść zakodowaną w HTML z zaufanego źródła? Wtedy ucieczka może być łatwo wyłączona:

```latte
{$trustedHtmlString|noescape}
```

.[warning]
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 .[#toc-printing-in-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:

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

Generuje:

```latte
<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:

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

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

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


Filtry .[#toc-filtry]
---------------------

Wymienione wyrażenie może być modyfikowane przez [filtr |syntax#Filters]. Na przykład przekonwertuj ciąg na duże litery i skróć go do maksymalnie 30 znaków:

```latte
{$string|upper|truncate:30}
```

W ten sposób można również stosować filtry do podczęści wyrażenia:

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


Warunki .[#toc-conditions]
==========================


`{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.

```latte
{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 |syntax#n-attributes], np:

```latte
<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:

```latte
<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` .{data-version:3.0.11}
-------------------------------

Jeśli warunek `{if} ... {/if}` zostanie zapisany w postaci [atrybutu n: |syntax#n:attributes], istnieje możliwość określenia alternatywnej gałęzi za pomocą `n:else`:

```latte
<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` |#ifset-elseifset], [`n:foreach` |#foreach], [`n:try` |#try], [`n:ifcontent` |#n:ifcontent]oraz [`n:ifchanged` |#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:

```latte
{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}`
-----------------------

.[note]
Zobacz także. [`{ifset block}` |template-inheritance#Checking-Block-Existence]

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 |syntax#n-attributes], więc weźmy to jako przykład:

```latte
<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:

```latte
{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 |syntax#n-attributes]:

```latte
{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.

```latte
{switch $transport}
	{case train}
		Vlakem
	{case plane}
		Letecky
	{default}
		Jinak
{/switch}
```

Klauzula `{case}` może zawierać wiele wartości oddzielonych przecinkami:

```latte
{switch $status}
{case $status::New}<b>nová položka</b>
{case $status::Sold, $status::Unknown}<i>není dostupná</i>
{/switch}
```


Cykle .[#toc-loops]
===================

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:

```latte
{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:: |syntax#n-attributes]

```latte
<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:

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

Wydrukuje więc coś w rodzaju:

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


`{else}` .{toc: foreach-else}
-----------------------------

Wewnątrz pętli `foreach` może zawrzeć klauzulę `{else}`, której zawartość zostanie wyświetlona, jeśli pętla jest pusta:

```latte
<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


```latte
{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 |syntax#n-attributes]:

```latte
{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:

```latte
{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 szczegółowe instrukcje |cookbook/grouping].

Może również elegancko zastąpić `{first}` i `{last}` w powyższym przykładzie:

```latte
{foreach $rows as $row}
	<table>

	{iterateWhile}
	<tr id="row-{$iterator->counter}">
		<td>{$row->name}</td>
		<td>{$row->email}</td>
	</tr>
	{/iterateWhile true}

	</table>
{/foreach}
```

Zobacz także filtry [wsadowe |filters#batch] i [grupowe |filters#group].


`{for}`
-------

Pętla jest napisana w taki sam sposób jak w PHP:

```latte
{for $i = 0; $i < 10; $i++}
	<span>Položka {$i}</span>
{/for}
```

Znacznik ten może być również użyty jako [n:attribut |syntax#n-attributes]:

```latte
<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:

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

Albo jako [n:atrybut |syntax#n-attributes]:

```latte
<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:

```latte
{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:

```latte
{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.

```latte
<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}` .{data-version:3.0.5}
--------------------------------

Kończy renderowanie szablonu lub bloku, gdy spełniony jest warunek (early exit).

```latte
{exitIf !$messages}

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


Wstawianie szablonu .[#toc-including-templates]
===============================================


`{include 'file.latte'}` .{toc: include}
----------------------------------------

.[note]
Zobacz także. [`{include block}` |template-inheritance#Printing-Blocks]

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
<?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:

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

Nazwa szablonu może być dowolnym wyrażeniem PHP:

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

Wstawioną treść można edytować za pomocą [filtrów |syntax#Filters]. Poniższy przykład usuwa cały HTML i dostosowuje wielkość liter:

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

Domyślnie [dziedziczenie szablonów |template inheritance] **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`:

```latte
{include 'template.latte' with blocks}
```

Związek między nazwą pliku określoną w znaczniku a plikiem na dysku jest sprawą programu [ładującego |extending-latte#Loaders].


`{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]):

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


`{block}`
=========

.[note]
Zobacz także. [`{block name}` |template-inheritance#Blocks]

Nienazwane bloki są używane jako sposób na zastosowanie [filtrów |syntax#Filters] do części szablonu. Na przykład filtr [paskowy |filters#strip] można zastosować w ten sposób, aby usunąć niepotrzebne spacje:

```latte
{block|strip}
<ul>
	<li>Hello World</li>
</ul>
{/block}
```


Zarządzanie wyjątkami .[#toc-exception-handling]
================================================


`{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:

```latte
{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:

```latte
{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 |syntax#n-attributes]:

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

Możliwe jest również zdefiniowanie niestandardowego [handler'a wyjątków |develop#Exception-Handler], 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:

```latte
{try}
<ul>
	{foreach $people as $person}
 		{skipIf $person->age < 18}
 		<li>{$person->name}</li>
	{else}
		{rollback}
	{/foreach}
</ul>
{/try}
```


Zmienne .[#toc-variables]
=========================


`{var}` `{default}`
-------------------

Utwórz nowe zmienne w szablonie z tagiem `{var}`:

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

{* Wielokrotne deklaracje *}
{var $name = 'John Smith', $age = 27}
```

Znacznik `{default}` działa podobnie, z wyjątkiem tego, że tworzy zmienne tylko wtedy, gdy nie istnieją. Jeśli zmienna już istnieje i zawiera `null`, nie zostanie nadpisana:

```latte
{default $lang = 'cs'}
```

Można również określić [typy zmiennych |type-system]. Na razie mają one charakter informacyjny i Latte ich nie sprawdza.

```latte
{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:

```latte
{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:

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

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

Znacznik może być również zapisany jako [n:attribute |syntax#n:attributes], jak każdy znacznik parami:

```latte
<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 |develop#disabling-auto-escaping-of-variable] podczas drukowania.


Inne .[#toc-others]
===================


`{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ą |safety-first#Context-Aware-Escaping] 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:

```latte
{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 |https://xdebug.org/]. Można dodać warunek określający, kiedy program powinien zostać zawieszony.

```latte
{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 |syntax#PHP Limitations in Latte].

```latte
{do $num++}
```


`{dump}`
--------

Wypisuje zmienną lub bieżący kontekst.

```latte
{dump $name} {* Zrzuca zmienną $name *}

{dump}       {* Zrzuca wszystkie aktualnie zdefiniowane zmienne *}
```

.[caution]
Wymaga biblioteki [Tracy |tracy:].


`{php}`
-------

Umożliwia wykonanie dowolnego kodu PHP. Tag musi być aktywowany przy użyciu rozszerzenia [RawPhpExtension |develop#RawPhpExtension].


`{spaceless}`
-------------

Usuwa niepotrzebne białe spacje z wyjścia. Działa podobnie jak filtr [bezprzestrzenny |filters#spaceless].

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

Generuje

```latte
<ul> <li>Hello</li> </ul>
```

Znacznik może być również zapisany jako [n:attribut |syntax#n-attributes].


`{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:

```latte
<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 |recipes#Latte-Inside-JavaScript-or-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 |tracy:], zobaczysz wyraźnie stos wywołań, w tym wszystkie przekazane argumenty.


Pomocnicy kodera HTML .[#toc-html-tag-helpers]
==============================================


n:klasa .[#toc-n-class]
-----------------------

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`:

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

I dalej, pierwszy element powinien mieć klasy `first` i `main`:

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

A wszystkie elementy powinny mieć klasę `list-item`:

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

Zadziwiająco proste, prawda?


n:attr .[#toc-n-attr]
---------------------

Atrybut `n:attr` może generować dowolne atrybuty HTML z taką samą elegancją jak [n:class |#n-class].

```latte
{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:

```latte
<input type="checkbox">

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

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


n:tag .[#toc-n-tag]
-------------------

Atrybut `n:tag` może dynamicznie zmieniać nazwę elementu HTML.

```latte
<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'`:

```latte
<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 .[#toc-n-ifcontent]
-------------------------------

Zapobiega wypisaniu pustego elementu HTML, tj. elementu zawierającego tylko spacje.

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

Drukuje w zależności od wartości zmiennej `$error`:

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

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


Tłumaczenia .[#toc-translation]
===============================

Aby tagi tłumaczące działały, należy [aktywować translator |develop#TranslatorExtension]. Możesz również użyć filtra do tłumaczenia [`translate` |filters#translate].


`{_...}`
--------

Tłumaczy wartości na inne języki.

```latte
<a href="basket">{_'Košík'}</a>
<span>{_$item}</span>
```

Inne parametry mogą być przekazane do tłumacza:

```latte
<a href="basket">{_'Košík', domain: order}</a>
```


`{translate}`
-------------

Tłumaczy części szablonu:

```latte
<h1>{translate}Objednávka{/translate}</h1>

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

Znacznik może być również zapisany jako [n:attribut |syntax#n-attributes], aby przetłumaczyć wnętrze elementu:

```latte
<h1 n:translate>Objednávka</h1>
```

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 szczegółowe instrukcje.

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}

Zobacz także filtry wsadowegrupowe.

{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 wyjątkiem tego, że tworzy zmienne tylko wtedy, gdy nie istnieją. Jeśli zmienna już istnieje i zawiera null, nie zostanie nadpisana:

{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>