Syntax
******

.[perex]
Syntax Latte wurde aus den praktischen Anforderungen von Webdesignern geboren. Wir waren auf der Suche nach einer möglichst benutzerfreundlichen Syntax, mit der man auf elegante Weise Konstrukte schreiben kann, die sonst eine echte Herausforderung sind.
Gleichzeitig sind alle Ausdrücke genau so geschrieben wie in PHP, so dass Sie keine neue Sprache lernen müssen. Sie machen einfach das Beste aus dem, was Sie bereits kennen.

Im Folgenden finden Sie eine minimale Vorlage, die einige grundlegende Elemente veranschaulicht: Tags, n:Attribute, Kommentare und Filter.

```latte
{* dies ist ein Kommentar *}
<ul n:if="$items">                {* n:if ist n:atribut *}
{foreach $items as $item}         {* Tag, der eine foreach-Schleife darstellt *}
	<li>{$item|capitalize}</li>   {* Tag, das eine Variable mit einem Filter ausgibt *}
{/foreach}                        {* Ende des Zyklus *}
</ul>
```

Werfen wir einen genaueren Blick auf diese wichtigen Elemente und wie sie Ihnen helfen können, eine unglaubliche Vorlage zu erstellen.


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

Eine Vorlage enthält Tags, die die Logik der Vorlage (z. B. *foreach*-Schleifen) oder die Ausgabeausdrücke steuern. Für beides wird ein einziges Begrenzungszeichen `{ ... }` verwendet, so dass Sie nicht wie bei anderen Systemen überlegen müssen, welches Begrenzungszeichen in welcher Situation zu verwenden ist.
Wenn auf das `{`-Zeichen ein Anführungszeichen oder ein Leerzeichen folgt, betrachtet Latte es nicht als Beginn eines Tags, so dass Sie ohne Probleme JavaScript-Konstrukte, JSON oder CSS-Regeln in Ihren Vorlagen verwenden können.

Siehe [Übersicht über alle Tags |tags]. Darüber hinaus können Sie auch [benutzerdefinierte Tags |extending-latte#tags] erstellen.


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

Sie können PHP-Ausdrücke, die Sie gut kennen, innerhalb der Tags verwenden:

- Variablen
- Zeichenketten (einschließlich HEREDOC und NOWDOC), Arrays, Zahlen, usw.
- [Operatoren |https://www.php.net/manual/en/language.operators.php]
- Funktions- und Methodenaufrufe (die durch die [Sandbox |sandbox] eingeschränkt werden können)
- [Übereinstimmung |https://www.php.net/manual/en/control-structures.match.php]
- [anonyme Funktionen |https://www.php.net/manual/en/functions.arrow.php]
- [Rückrufe |https://www.php.net/manual/en/functions.first_class_callable_syntax.php]
- mehrzeilige Kommentare `/* ... */`
- etc...

Darüber hinaus fügt Latte einige [nette Erweiterungen |#Syntactic Sugar] der PHP-Syntax hinzu.


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

Jedes Tag-Paar, wie z. B. `{if} … {/if}`, das auf ein einzelnes HTML-Element wirkt, kann in [n:Attribut-Notation |#n:attribute] geschrieben werden. Zum Beispiel könnte `{foreach}` im obigen Beispiel auch so geschrieben werden:

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

Die Funktionalität entspricht dann dem HTML-Element, in das sie geschrieben ist:

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

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

Druckt:

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

Durch die Verwendung des Präfixes `inner-` können wir das Verhalten so ändern, dass die Funktionalität nur für den Körper des Elements gilt:

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

Druckt:

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

Oder durch die Verwendung des Präfixes `tag-` wird die Funktionalität nur auf die HTML-Tags angewendet:

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

Je nach dem Wert der Variable `$url` wird dies gedruckt:

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

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

Allerdings sind n:Attribute nicht nur eine Abkürzung für Paar-Tags, es gibt auch einige reine n:Attribute, zum Beispiel den besten Freund des Programmierers [n:class |tags#n:class].


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

Siehe die Zusammenfassung der [Standardfilter |filters].

Latte erlaubt den Aufruf von Filtern mit Hilfe der Pipe-Schreibweise (vorangestelltes Leerzeichen ist erlaubt):

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

Filter können verkettet werden, in diesem Fall gelten sie in der Reihenfolge von links nach rechts:

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

Die Parameter werden durch Doppelpunkt oder Komma getrennt hinter den Filternamen gesetzt:

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

Filter können auf Ausdrücke angewendet werden:

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

Auf Block:

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

Oder direkt beim Wert (in Kombination mit [`{=expr}` | https://latte.nette.org/de/tags#printing] Tag):
```latte
<h1>{='  Hello world  '|trim}<h1>
```


Dynamische HTML-Tags .[#toc-dynamic-html-tags]
==============================================

Latte unterstützt dynamische HTML-Tags, die nützlich sind, wenn Sie Flexibilität bei den Tag-Namen benötigen:

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

Der obige Code kann zum Beispiel Folgendes erzeugen `<h1>Heading</h1>` oder `<h2>Heading</h2>` erzeugen, je nach dem Wert der Variablen `$level`. Dynamische HTML-Tags in Latte müssen immer gepaart sein. Ihre Alternative ist der [n:tag |tags#n:tag].

Da Latte ein sicheres Schablonensystem ist, prüft es, ob der resultierende Tag-Name gültig ist und keine unerwünschten oder bösartigen Werte enthält. Es stellt auch sicher, dass der Name des End-Tags immer mit dem Namen des Anfangs-Tags übereinstimmt.


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

Kommentare werden auf diese Weise geschrieben und gelangen nicht in die Ausgabe:

```latte
{* dies ist ein Kommentar in Latte *}
```

PHP-Kommentare funktionieren innerhalb von Tags:

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


Syntaktischer Zucker .[#toc-syntactic-sugar]
============================================


Zeichenketten ohne Anführungszeichen .[#toc-strings-without-quotation-marks]
----------------------------------------------------------------------------

Bei einfachen Zeichenketten können die Anführungszeichen weggelassen werden:

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

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

Einfache Zeichenfolgen sind Zeichenfolgen, die nur aus Buchstaben, Ziffern, Unterstrichen, Bindestrichen und Punkten bestehen. Sie dürfen nicht mit einer Ziffer beginnen und dürfen nicht mit einem Bindestrich beginnen oder enden.
Sie darf nicht nur aus Großbuchstaben und Unterstrichen bestehen, denn dann gilt sie als Konstante (z. B. `PHP_VERSION`).
Und er darf nicht mit den Schlüsselwörtern `and`, `array`, `clone`, `default`, `false`, `in`, `instanceof`, `new`, `null`, `or`, `return`, `true`, `xor` kollidieren.


Kurzer ternärer Operator .[#toc-short-ternary-operator]
-------------------------------------------------------

Wenn der dritte Wert des ternären Operators leer ist, kann er weggelassen werden:

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

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


Moderne Schlüsselschreibweise im Array .[#toc-modern-key-notation-in-the-array]
-------------------------------------------------------------------------------

Array-Schlüssel können ähnlich wie benannte Parameter beim Aufruf von Funktionen geschrieben werden:

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

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


Filter .[#toc-filters]
----------------------

Filter können für jeden beliebigen Ausdruck verwendet werden, indem man das Ganze in Klammern setzt:

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


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

Der Operator `in` kann anstelle der Funktion `in_array()` verwendet werden. Der Vergleich ist immer streng:

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


Ein Fenster in die Geschichte .[#toc-a-window-into-history]
-----------------------------------------------------------

Latte hat im Laufe seiner Geschichte eine Reihe von syntaktischen Bonbons entwickelt, die ein paar Jahre später in PHP selbst auftauchten. Zum Beispiel war es in Latte möglich, Arrays als `[1, 2, 3]` anstelle von `array(1, 2, 3)` zu schreiben oder den Nullsafe-Operator `$obj?->foo` zu verwenden, lange bevor dies in PHP selbst möglich war. Latte führte auch den Arrayerweiterungsoperator `(expand) $arr` ein, der dem heutigen `...$arr` Operator von PHP entspricht.

Der undefiniert-sichere Operator `??->`, der dem nullsicheren Operator `?->` ähnelt, aber keinen Fehler auslöst, wenn die Variable nicht existiert, wurde aus historischen Gründen geschaffen und wir empfehlen heute die Verwendung des Standard-PHP-Operators `?->`.


PHP-Einschränkungen in Latte .[#toc-php-limitations-in-latte]
=============================================================

In Latte können nur PHP-Ausdrücke geschrieben werden. Das heißt, Anweisungen, die mit einem Semikolon enden, können nicht verwendet werden. Sie können keine Klassen deklarieren oder [Kontrollstrukturen |https://www.php.net/manual/en/language.control-structures.php] verwenden, wie `if`, `foreach`, `switch`, `return`, `try`, `throw` und andere, an deren Stelle Latte seine [Tags |tags] anbietet.
Sie können auch keine [Attribute |https://www.php.net/manual/en/language.attributes.php], [Backticks |https://www.php.net/manual/en/language.operators.execution.php] oder [magische Konstanten |https://www.php.net/manual/en/language.constants.magic.php] verwenden.
Sie können nicht einmal `unset`, `echo`, `include`, `require`, `exit`, `eval` verwenden, da sie keine Funktionen, sondern spezielle PHP-Sprachkonstrukte und somit keine Ausdrücke sind. Nur mehrzeilige Kommentare werden unterstützt `/* ... */`.

Sie können diese Einschränkungen jedoch umgehen, indem Sie die [RawPhpExtension-Erweiterung |develop#RawPhpExtension] aktivieren, die es Ihnen ermöglicht, beliebigen PHP-Code im `{php ...}` -Tag auf Verantwortung des Vorlagenautors zu verwenden.