syntax.texy

Syntaxe
*******

.[perex]
Syntax Latte vzešla z praktických požadavků webdesignerů. Hledali jsme tu nejpřívětivější syntax, se kterou elegantně zapíšete i konstrukce, které jinak představují skutečný oříšek.
Zároveň všechny výrazy se píší úplně stejně jako v PHP, takže se nemusíte učit nový jazyk. Prostě zúročíte co už dávno umíte.

Níže je uvedena minimální šablona, která ilustruje několik základních prvků: tagy, n:atributy, komentáře a filtry.

```latte
{* toto je komentář *}
<ul n:if="$items">                {* n:if je n:atribut *}
{foreach $items as $item}         {* tag představující cyklus foreach *}
	<li>{$item|capitalize}</li>   {* tag vypisující proměnnou s filtrem *}
{/foreach}                        {* konec cyklu *}
</ul>
```

Podívejme se blíže na tyto důležité prvky a na to, jak vám mohou pomoci vytvořit úžasnou šablonu.


Tagy
====

Šablona obsahuje tagy (neboli značky či makra), které řídí logiku šablony (například smyčky *foreach*) nebo vypisují výrazy. Pro obojí se používá jediný delimiter `{ ... }`, takže nemusíte přemýšlet, jaký delimiter v jaké situaci použít, jako je tomu u jiných systémů.
Pokud za znakem `{` následuje uvozovka nebo mezera, Latte jej nepovažuje za začátek značky, díky čemuž můžete v šablonách bez problémů používat i JavaScriptové konstrukce, JSON nebo pravidla v CSS.

Podívejte se na [přehled všech tagů|tags]. Krom toho si můžete vytvářet i [vlastní tagy|extending-latte#tagy].


Latte rozumí PHP
================

Uvnitř značek můžete používat PHP výrazy, které dobře znáte:

- proměnné
- řetězce (včetně HEREDOC a NOWDOC), pole, čísla, apod.
- [operátory |https://www.php.net/manual/en/language.operators.php]
- volání funkcí a metod
- [match |https://www.php.net/manual/en/control-structures.match.php]
- [anonymní funkce |https://www.php.net/manual/en/functions.arrow.php]
- [callbacky |https://www.php.net/manual/en/functions.first_class_callable_syntax.php]
- víceřádkové komentáře `/* ... */`
- atd…

Latte navíc syntaxi PHP doplňuje o několik [příjemných rozšíření |#Syntaktický cukr].


n:atributy
==========

Všechny párové značky, například `{if} … {/if}`, operující nad jedním HTML elementem, se dají přepsat do podoby n:atributů. Takto by bylo možné zapsat například i `{foreach}` v úvodní ukázce:

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

Funkcionalita se pak vztahuje na HTML element, do něhož je umístěný:

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

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

vypíše:

```latte
<p>I</p>
<p>♥</p>
<p>Latte</p>
```

Pomocí prefixu `inner-` můžeme chování poupravit tak, aby se vztahovalo jen na vnitřní část elementu:

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

Vypíše se:

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

Nebo pomocí prefixu `tag-` aplikujeme funkcionalitu jen na samotné HTML značky:

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

Což vypíše v závislosti na proměnné `$url`:

```latte
{* když je $url prázdné *}
<p>Title</p>

{* když $url obsahuje 'https://nette.org' *}
<p><a href="https://nette.org">Title</a></p>
```

Avšak n:atributy nejsou jen zkratkou pro párové značky. Existují i ryzí n:atributy, jako třeba [n:href |application:creating-links#V šabloně presenteru] nebo velešikovný pomocník kodéra [n:class |tags#n:class].


Filtry
======

Podívejte se na přehled [standardních filtrů |filters].

Filtry se zapisují za svislítko (může být před ním mezera):

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

Filtry lze zřetězit a poté se aplikují v pořadí od levého k pravému:

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

Parametry se zadávají za jménem filtru oddělené dvojtečkami nebo čárkami:

```latte
<h1>{$heading|truncate:20,''}</h1>
```

Filtry lze aplikovat i na výraz:

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

Na blok:

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

Nebo přímo na hodnotu (v kombinaci s tagem [`{=expr}`| https://latte.nette.org/cs/tags#Vypisování]):
```latte
<h1>{='  Hello world  '|trim}<h1>
```


Komentáře
=========

Komentáře se zapisují tímto způsobem a do výstupu se nedostanou:

```latte
{* tohle je komentář v Latte *}
```

Uvnitř značek fungují PHP komentáře:

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


Syntaktický cukr
================


Řetězce bez uvozovek
--------------------

U jednoduchých řetězců lze vynechat uvozovky:

```latte
jako v PHP:  {var $arr = ['hello', 'btn--default', '€']}

zkráceně:    {var $arr = [hello, btn--default, €]}
```

Jednoduché řetězce jsou ty, které jsou tvořeny čistě z písmen, číslic, podtržítek, pomlček a teček. Nesmí začínat číslicí a nesmí začínat nebo končit pomlčkou.
Nesmí být složený jen z velkých písmen a podtržítek, protože pak se považuje za konstantu (např. `PHP_VERSION`).
A nesmí kolidovat s klíčovými slovy: `and`, `array`, `clone`, `default`, `false`, `in`, `instanceof`, `new`, `null`, `or`, `return`, `true`, `xor`.


Zkrácený ternární operátor
--------------------------

Je-li třetí hodnota ternárního operátoru prázdná, lze ji vynechat:

```latte
jako v PHP:  {$stock ? 'Skladem' : ''}

zkráceně:    {$stock ? 'Skladem'}
```


Moderní zápis klíčů v poli
--------------------------

Klíče v poli lze zapisovat podobně jako pojmenované parametry při volání funkcí:

```latte
jako v PHP:  {var $arr = ['one' => 'item 1', 'two' => 'item 2']}

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


Filtry
------

Filtry lze použít pro jakékoliv výrazy, stačí celek uzavřít do závorek:

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


Operátor `in`
-------------

Operátorem `in` lze nahradit funkci `in_array()`. Porovnání je vždy striktní:

```latte
{* obdoba in_array($item, $items, true) *}
{if $item in $items}
	...
{/if}
```


Historické okénko
-----------------

Latte přišlo v průběhu své historie s celou řadou syntaktických cukříků, které se po pár letech objevily v samotném PHP. Například v Latte bylo možné psát pole jako `[1, 2, 3]` místo `array(1, 2, 3)` nebo používat nullsafe operátor `$obj?->foo` dávno předtím, než to bylo možné v samotném PHP. Latte také zavedlo operátor pro rozbalení pole `(expand) $arr`, který je ekvivalentem dnešního operátoru `...$arr` z PHP.

Undefined-safe operator `??->`, což je obdoba nullsafe operatoru `?->`, který ale nevyvolá chybu pokud proměnná neexistuje, vznikl z historických důvodů a dnes doporučujeme používat standardní PHP operátor `?->`.