Nette Documentation Preview

syntax 
Sintassi
********

.[perex]
Syntax Latte è nata dalle esigenze pratiche dei web designer. Eravamo alla ricerca della sintassi più facile da usare, con la quale è possibile scrivere in modo elegante costrutti che altrimenti sarebbero una vera sfida.
Allo stesso tempo, tutte le espressioni sono scritte esattamente come in PHP, quindi non è necessario imparare un nuovo linguaggio. È sufficiente sfruttare al meglio ciò che già si conosce.

Di seguito è riportato un modello minimale che illustra alcuni elementi di base: tag, n:attributi, commenti e filtri.

```latte
{* questo è un commento *}
<ul n:if="$items">                {* n:if è n:atribut *}
{foreach $items as $item}         {* tag che rappresenta il ciclo foreach *}
	<li>{$item|capitalize}</li>   {* tag che stampa una variabile con un filtro *}
{/foreach}                        {* fine del ciclo *}
</ul>
```

Diamo un'occhiata più da vicino a questi importanti elementi e a come possono aiutare a costruire un template incredibile.


Tag .[#toc-tags]
================

Un modello contiene tag che controllano la logica del modello (per esempio, i cicli *foreach*) o le espressioni di output. Per entrambi viene usato un unico delimitatore `{ ... }`, in modo da non dover pensare a quale delimitatore usare in quale situazione, come avviene con altri sistemi.
Se il carattere `{` è seguito da una virgoletta o da uno spazio, Latte non lo considera l'inizio di un tag, per cui si possono usare costrutti JavaScript, JSON o regole CSS nei template senza problemi.

Vedere la [panoramica di tutti i tag |tags]. Inoltre, è possibile creare [tag personalizzati |extending-latte#tags].


Latte capisce il PHP .[#toc-latte-understands-php]
==================================================

È possibile utilizzare espressioni PHP che si conoscono bene all'interno dei tag:

- variabili
- stringhe (compresi HEREDOC e NOWDOC), array, numeri, ecc.
- [operatori |https://www.php.net/manual/en/language.operators.php]
- chiamate a funzioni e metodi (che possono essere limitate dalla [sandbox |sandbox])
- [corrispondenza |https://www.php.net/manual/en/control-structures.match.php]
- [funzioni anonime |https://www.php.net/manual/en/functions.arrow.php]
- [callback |https://www.php.net/manual/en/functions.first_class_callable_syntax.php]
- commenti multilinea `/* ... */`
- ecc.

Inoltre, Latte aggiunge diverse [estensioni |#Syntactic Sugar] alla sintassi di PHP.


n:attributi .[#toc-n-attributes]
================================

Ogni tag di coppia, come `{if} … {/if}`, che opera su un singolo elemento HTML può essere scritto in notazione [n:attributi |#n:attribute]. Per esempio, `{foreach}` nell'esempio precedente potrebbe essere scritto anche in questo modo:

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

La funzionalità corrisponde quindi all'elemento HTML in cui è scritta:

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

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

Stampe:

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

Utilizzando il prefisso `inner-` possiamo alterare il comportamento in modo che la funzionalità si applichi solo al corpo dell'elemento:

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

Stampe:

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

Oppure utilizzando il prefisso `tag-` la funzionalità viene applicata solo ai tag HTML:

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

A seconda del valore della variabile `$url` verrà stampato:

```latte
// when $url is empty
<p>Title</p>

// when $url equals 'https://nette.org'
<p><a href="https://nette.org">Title</a></p>
```

Tuttavia, gli attributi n:non sono solo una scorciatoia per i tag di coppia, ma esistono anche alcuni attributi n:puri, come ad esempio il migliore amico del codificatore [n:class |tags#n:class].


Filtri .[#toc-filters]
======================

Vedere il riepilogo dei [filtri standard |filters].

Latte consente di chiamare i filtri utilizzando la notazione del segno di pipe (è consentito lo spazio precedente):

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

I filtri possono essere concatenati, in tal caso si applicano in ordine da sinistra a destra:

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

I parametri vengono inseriti dopo il nome del filtro, separati da due punti o da una virgola:

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

I filtri possono essere applicati alle espressioni:

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

Su blocco:

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

O direttamente sul valore (in combinazione con [`{=expr}` | https://latte.nette.org/it/tags#printing] ):
```latte
<h1>{='  Hello world  '|trim}<h1>
```


Tag HTML dinamici .[#toc-dynamic-html-tags]
===========================================

Latte supporta i tag HTML dinamici, utili quando si ha bisogno di flessibilità nei nomi dei tag:

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

Ad esempio, il codice qui sopra può generare `<h1>Heading</h1>` o `<h2>Heading</h2>` a seconda del valore della variabile `$level`. I tag HTML dinamici in Latte devono sempre essere accoppiati. L'alternativa è il [n:tag |tags#n:tag].

Poiché Latte è un sistema di template sicuro, controlla che il nome del tag risultante sia valido e non contenga valori indesiderati o dannosi. Inoltre, garantisce che il nome del tag finale sia sempre uguale a quello del tag di apertura.


Commenti .[#toc-comments]
=========================

I commenti sono scritti in questo modo e non vengono inseriti nell'output:

```latte
{Questo è un commento in Latte.}
```

I commenti PHP funzionano all'interno dei tag:

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


Zucchero sintattico .[#toc-syntactic-sugar]
===========================================


Stringhe senza virgolette .[#toc-strings-without-quotation-marks]
-----------------------------------------------------------------

Le virgolette possono essere omesse per le stringhe semplici:

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

abbreviated: {var $arr = [hello, btn--default, €]}
```

Le stringhe semplici sono quelle composte esclusivamente da lettere, cifre, trattini bassi, trattini e punti. Non devono iniziare con una cifra e non devono iniziare o terminare con un trattino.
Non deve essere composta solo da lettere maiuscole e trattini bassi, perché in tal caso viene considerata una costante (ad esempio `PHP_VERSION`).
E non deve collidere con le parole chiave `and`, `array`, `clone`, `default`, `false`, `in`, `instanceof`, `new`, `null`, `or`, `return`, `true`, `xor`.


Operatore ternario breve .[#toc-short-ternary-operator]
-------------------------------------------------------

Se il terzo valore dell'operatore ternario è vuoto, può essere omesso:

```latte
as in PHP:   {$stock ? 'In stock' : ''}

abbreviated: {$stock ? 'In stock'}
```


Notazione moderna della chiave nell'array .[#toc-modern-key-notation-in-the-array]
----------------------------------------------------------------------------------

Le chiavi dell'array possono essere scritte in modo simile ai parametri denominati quando si chiamano le funzioni:

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

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


Filtri .[#toc-filters]
----------------------

I filtri possono essere utilizzati per qualsiasi espressione, basta racchiudere il tutto tra parentesi:

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


Operatore `in` .[#toc-operator-in]
----------------------------------

L'operatore `in` può essere utilizzato per sostituire la funzione `in_array()`. Il confronto è sempre rigoroso:

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


Una finestra nella storia .[#toc-a-window-into-history]
-------------------------------------------------------

Nel corso della sua storia, Latte ha inventato una serie di caramelle sintattiche che sono apparse in PHP qualche anno dopo. Per esempio, in Latte era possibile scrivere gli array come `[1, 2, 3]` invece di `array(1, 2, 3)` o usare l'operatore nullsafe `$obj?->foo` molto prima che fosse possibile in PHP. Latte ha anche introdotto l'operatore di espansione degli array `(expand) $arr`, che è l'equivalente dell'odierno operatore `...$arr` di PHP.

L'operatore undefined-safe `??->`, che è simile all'operatore nullsafe `?->`, ma non solleva un errore se la variabile non esiste, è stato creato per ragioni storiche e oggi si consiglia di utilizzare l'operatore standard di PHP `?->`.


Limitazioni di PHP in Latte .[#toc-php-limitations-in-latte]
============================================================

In Latte si possono scrivere solo espressioni PHP. Cioè, non si possono usare affermazioni che terminano con un punto e virgola. Non si possono dichiarare classi o usare [strutture di controllo |https://www.php.net/manual/en/language.control-structures.php], come `if`, `foreach`, `switch`, `return`, `try`, `throw` e altre, al posto delle quali Latte offre i suoi [tag |tags].
Non è inoltre possibile utilizzare [attributi |https://www.php.net/manual/en/language.attributes.php], [backtick |https://www.php.net/manual/en/language.operators.execution.php] o altre [costanti magiche |https://www.php.net/manual/en/language.constants.magic.php].
Non si possono nemmeno usare `unset`, `echo`, `include`, `require`, `exit`, `eval`, perché non sono funzioni, ma costrutti speciali del linguaggio PHP e quindi non espressioni. Sono supportati solo i commenti a più righe `/* ... */`.

Tuttavia, è possibile aggirare queste limitazioni attivando l'estensione [RawPhpExtension |develop#RawPhpExtension], che consente di utilizzare qualsiasi codice PHP nel tag `{php ...}` sotto la responsabilità dell'autore del template.

Sintassi

Syntax Latte è nata dalle esigenze pratiche dei web designer. Eravamo alla ricerca della sintassi più facile da usare, con la quale è possibile scrivere in modo elegante costrutti che altrimenti sarebbero una vera sfida. Allo stesso tempo, tutte le espressioni sono scritte esattamente come in PHP, quindi non è necessario imparare un nuovo linguaggio. È sufficiente sfruttare al meglio ciò che già si conosce.

Di seguito è riportato un modello minimale che illustra alcuni elementi di base: tag, n:attributi, commenti e filtri.

{* questo è un commento *}
<ul n:if="$items">                {* n:if è n:atribut *}
{foreach $items as $item}         {* tag che rappresenta il ciclo foreach *}
	<li>{$item|capitalize}</li>   {* tag che stampa una variabile con un filtro *}
{/foreach}                        {* fine del ciclo *}
</ul>

Diamo un'occhiata più da vicino a questi importanti elementi e a come possono aiutare a costruire un template incredibile.

Tag

Un modello contiene tag che controllano la logica del modello (per esempio, i cicli foreach) o le espressioni di output. Per entrambi viene usato un unico delimitatore { ... }, in modo da non dover pensare a quale delimitatore usare in quale situazione, come avviene con altri sistemi. Se il carattere { è seguito da una virgoletta o da uno spazio, Latte non lo considera l'inizio di un tag, per cui si possono usare costrutti JavaScript, JSON o regole CSS nei template senza problemi.

Vedere la panoramica di tutti i tag. Inoltre, è possibile creare tag personalizzati.

Latte capisce il PHP

È possibile utilizzare espressioni PHP che si conoscono bene all'interno dei tag:

Inoltre, Latte aggiunge diverse estensioni alla sintassi di PHP.

n:attributi

Ogni tag di coppia, come {if} … {/if}, che opera su un singolo elemento HTML può essere scritto in notazione n:attributi. Per esempio, {foreach} nell'esempio precedente potrebbe essere scritto anche in questo modo:

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

La funzionalità corrisponde quindi all'elemento HTML in cui è scritta:

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

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

Stampe:

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

Utilizzando il prefisso inner- possiamo alterare il comportamento in modo che la funzionalità si applichi solo al corpo dell'elemento:

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

Stampe:

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

Oppure utilizzando il prefisso tag- la funzionalità viene applicata solo ai tag HTML:

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

A seconda del valore della variabile $url verrà stampato:

// when $url is empty
<p>Title</p>

// when $url equals 'https://nette.org'
<p><a href="https://nette.org">Title</a></p>

Tuttavia, gli attributi n:non sono solo una scorciatoia per i tag di coppia, ma esistono anche alcuni attributi n:puri, come ad esempio il migliore amico del codificatore n:class.

Filtri

Vedere il riepilogo dei filtri standard.

Latte consente di chiamare i filtri utilizzando la notazione del segno di pipe (è consentito lo spazio precedente):

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

I filtri possono essere concatenati, in tal caso si applicano in ordine da sinistra a destra:

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

I parametri vengono inseriti dopo il nome del filtro, separati da due punti o da una virgola:

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

I filtri possono essere applicati alle espressioni:

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

Su blocco:

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

O direttamente sul valore (in combinazione con {=expr} ):

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

Tag HTML dinamici

Latte supporta i tag HTML dinamici, utili quando si ha bisogno di flessibilità nei nomi dei tag:

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

Ad esempio, il codice qui sopra può generare <h1>Heading</h1> o <h2>Heading</h2> a seconda del valore della variabile $level. I tag HTML dinamici in Latte devono sempre essere accoppiati. L'alternativa è il n:tag.

Poiché Latte è un sistema di template sicuro, controlla che il nome del tag risultante sia valido e non contenga valori indesiderati o dannosi. Inoltre, garantisce che il nome del tag finale sia sempre uguale a quello del tag di apertura.

Commenti

I commenti sono scritti in questo modo e non vengono inseriti nell'output:

{Questo è un commento in Latte.}

I commenti PHP funzionano all'interno dei tag:

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

Zucchero sintattico

Stringhe senza virgolette

Le virgolette possono essere omesse per le stringhe semplici:

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

abbreviated: {var $arr = [hello, btn--default, €]}

Le stringhe semplici sono quelle composte esclusivamente da lettere, cifre, trattini bassi, trattini e punti. Non devono iniziare con una cifra e non devono iniziare o terminare con un trattino. Non deve essere composta solo da lettere maiuscole e trattini bassi, perché in tal caso viene considerata una costante (ad esempio PHP_VERSION). E non deve collidere con le parole chiave and, array, clone, default, false, in, instanceof, new, null, or, return, true, xor.

Operatore ternario breve

Se il terzo valore dell'operatore ternario è vuoto, può essere omesso:

as in PHP:   {$stock ? 'In stock' : ''}

abbreviated: {$stock ? 'In stock'}

Notazione moderna della chiave nell'array

Le chiavi dell'array possono essere scritte in modo simile ai parametri denominati quando si chiamano le funzioni:

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

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

Filtri

I filtri possono essere utilizzati per qualsiasi espressione, basta racchiudere il tutto tra parentesi:

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

Operatore in

L'operatore in può essere utilizzato per sostituire la funzione in_array(). Il confronto è sempre rigoroso:

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

Una finestra nella storia

Nel corso della sua storia, Latte ha inventato una serie di caramelle sintattiche che sono apparse in PHP qualche anno dopo. Per esempio, in Latte era possibile scrivere gli array come [1, 2, 3] invece di array(1, 2, 3) o usare l'operatore nullsafe $obj?->foo molto prima che fosse possibile in PHP. Latte ha anche introdotto l'operatore di espansione degli array (expand) $arr, che è l'equivalente dell'odierno operatore ...$arr di PHP.

L'operatore undefined-safe ??->, che è simile all'operatore nullsafe ?->, ma non solleva un errore se la variabile non esiste, è stato creato per ragioni storiche e oggi si consiglia di utilizzare l'operatore standard di PHP ?->.

Limitazioni di PHP in Latte

In Latte si possono scrivere solo espressioni PHP. Cioè, non si possono usare affermazioni che terminano con un punto e virgola. Non si possono dichiarare classi o usare strutture di controllo, come if, foreach, switch, return, try, throw e altre, al posto delle quali Latte offre i suoi tag. Non è inoltre possibile utilizzare attributi, backtick o altre costanti magiche. Non si possono nemmeno usare unset, echo, include, require, exit, eval, perché non sono funzioni, ma costrutti speciali del linguaggio PHP e quindi non espressioni. Sono supportati solo i commenti a più righe /* ... */.

Tuttavia, è possibile aggirare queste limitazioni attivando l'estensione RawPhpExtension, che consente di utilizzare qualsiasi codice PHP nel tag {php ...} sotto la responsabilità dell'autore del template.