Nette Documentation Preview

syntax
Latte Tags
**********

.[perex]
Zusammenfassung und Beschreibung aller in Latte integrierten Tags.

.[table-latte-tags language-latte]
|## Drucken
| `{$var}`, `{...}` oder `{=...}` | [druckt eine Variable oder einen Ausdruck mit Escapezeichen |#printing]
| `{$var\|filter}` | [druckt mit Filtern |#filters]
| `{l}` oder `{r}` | druckt `{` or `}` Zeichen

.[table-latte-tags language-latte]
|## Bedingungen
| `{if}`... `{elseif}`... `{else}`... `{/if}` | [Bedingung if |#if-elseif-else]
| `{ifset}`... `{elseifset}`... `{/ifset}` | [Bedingung ifset |#ifset-elseifset]
| `{ifchanged}`... `{/ifchanged}` | [Test, ob eine Änderung stattgefunden hat |#ifchanged]
| `{switch}` `{case}` `{default}` `{/switch}` | [Bedingung switch |#switch-case-default]
| `n:else` | [alternative Inhalte für Bedingungen |#n:else]

.[table-latte-tags language-latte]
|## Schleifen
| `{foreach}`... `{/foreach}` | [foreach |#foreach]
| `{for}`... `{/for}` | [for |#for]
| `{while}`... `{/while}` | [while |#while]
| `{continueIf $cond}` | [weiter zur nächsten Iteration |#continueif-skipif-breakif]
| `{skipIf $cond}` | [überspringt die aktuelle Schleifeniteration |#continueif-skipif-breakif]
| `{breakIf $cond}` | [bricht Schleife ab |#continueif-skipif-breakif]
| `{exitIf $cond}` | [vorzeitiges Beenden |#exitif]
| `{first}`... `{/first}` | [ist dies die erste Iteration? |#first-last-sep]
| `{last}`... `{/last}` | [ist es die letzte Iteration? |#first-last-sep]
| `{sep}`... `{/sep}` | [wird die nächste Iteration folgen? |#first-last-sep]
| `{iterateWhile}`... `{/iterateWhile}` | [strukturiert foreach |#iterateWhile]
| `$iterator` | [Spezielle Variable innerhalb der foreach-Schleife |#$iterator]

.[table-latte-tags language-latte]
|## Einbindung anderer Vorlagen
| `{include 'file.latte'}` | [schließt eine Vorlage aus einer anderen Datei ein |#include]
| `{sandbox 'file.latte'}` | [Einfügen einer Vorlage im Sandbox-Modus |#sandbox]

.[table-latte-tags language-latte]
|## Blöcke, Layouts, Vererbung von Vorlagen
| `{block}` | [anonymer Block |#block]
| `{block blockname}` | [Blockdefinition |template-inheritance#blocks]
| `{define blockname}` | [Blockdefinition für zukünftige Verwendung |template-inheritance#definitions]
| `{include blockname}` | [druckt Block |template-inheritance#printing-blocks]
| `{include blockname from 'file.latte'}` | [druckt einen Block aus einer Datei |template-inheritance#printing-blocks]
| `{import 'file.latte'}` | [lädt Blöcke aus einer anderen Vorlage |template-inheritance#horizontal-reuse]
| `{layout 'file.latte'}` / `{extends}` | [gibt eine Layout-Datei an |template-inheritance#layout-inheritance]
| `{embed}`... `{/embed}` | [lädt die Vorlage oder den Block und ermöglicht das Überschreiben der Blöcke |template-inheritance#unit-inheritance]
| `{ifset blockname}`... `{/ifset}` | [Bedingung, wenn Block definiert ist |template-inheritance#checking-block-existence]

.[table-latte-tags language-latte]
|## Ausnahmebehandlung
| `{try}`... `{else}`... `{/try}` | [Abfangen von Ausnahmen |#try]
| `{rollback}` | [verwirft try-Block |#rollback]

.[table-latte-tags language-latte]
|## Variablen
| `{var $foo = value}` | [Erstellung von Variablen |#var-default]
| `{default $foo = value}` | [Standardwert, wenn Variable nicht deklariert ist |#var-default]
| `{parameters}` | [deklariert Variablen, gibt einen Standardwert ein |#parameters]
| `{capture}`... `{/capture}` | [erfasst einen Abschnitt in einer Variablen |#capture]

.[table-latte-tags language-latte]
|## Typen
| `{varType}` | [deklariert den Typ einer Variablen |type-system#varType]
| `{varPrint}` | [schlägt Variablentypen vor |type-system#varPrint]
| `{templateType}` | [deklariert Variablentypen mittels Klasse |type-system#templateType]
| `{templatePrint}` | [erzeugt Klasse mit Eigenschaften |type-system#templatePrint]

.[table-latte-tags language-latte]
|## Übersetzung
| `{_string}` | [druckt übersetzt |#Translation]
| `{translate}`... `{/translate}` | [übersetzt den Inhalt |#Translation]

.[table-latte-tags language-latte]
|## Andere
| `{contentType}` | [schaltet den Escaping-Modus um und sendet HTTP-Header |#contenttype]
| `{debugbreak}` | [setzt einen Haltepunkt im Code |#debugbreak]
| `{do}` | [wertet einen Ausdruck aus, ohne ihn zu drucken |#do]
| `{dump}` | [gibt Variablen in die Tracy Bar aus |#dump]
| `{php}` | [führt beliebigen PHP-Code aus |#php]
| `{spaceless}`... `{/spaceless}` | [entfernt unnötige Leerzeichen |#spaceless]
| `{syntax}` | [schaltet die Syntax während der Laufzeit um |#syntax]
| `{trace}` | [zeigt Stack-Trace |#trace]

.[table-latte-tags language-latte]
|## HTML-Tag-Helfer
| `n:class` | [intelligentes Klassenattribut |#n:class]
| `n:attr` | [intelligente HTML-Attribute |#n:attr]
| `n:tag` | [Dynamischer Name des HTML-Elements |#n:tag]
| `n:ifcontent` | [Leeren HTML-Tag auslassen |#n:ifcontent]

.[table-latte-tags language-latte]
|## Nur in Nette Framework verfügbar
| `n:href` | [Link in `<a>` HTML-Elementen |application:creating-links#In the Presenter Template]
| `{link}` | [gibt einen Link aus |application:creating-links#In the Presenter Template]
| `{plink}` | [druckt einen Link zu einem Presenter |application:creating-links#In the Presenter Template]
| `{control}` | [druckt eine Komponente |application:components#Rendering]
| `{snippet}`... `{/snippet}` | [ein Template-Snippet, das per AJAX gesendet werden kann |application:ajax#snippets-in-latte]
| `{snippetArea}` | [Schnipsel Umschlag |application:ajax#snippet-areas]
| `{cache}`... `{/cache}` | [zwischenspeichert einen Vorlagenabschnitt |caching:#caching-in-latte]

.[table-latte-tags language-latte]
|## Nur mit Nette Forms verfügbar
| `{form}`... `{/form}` | [druckt ein Formularelement |forms:rendering#form]
| `{label}`... `{/label}` | [druckt eine Formulareingabebezeichnung |forms:rendering#label-input]
| `{input}` | [druckt ein Formulareingabeelement |forms:rendering#label-input]
| `{inputError}` | [gibt eine Fehlermeldung für ein Formulareingabeelement aus |forms:rendering#inputError]
| `n:name` | [aktiviert ein HTML-Eingabeelement |forms:rendering#n:name]
| `{formContainer}`... `{/formContainer}` | [Darstellung des Formular-Containers |forms:rendering#special-cases]


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


`{$var}` `{...}` `{=...}`
-------------------------

Latte verwendet das Tag `{=...}`, um einen beliebigen Ausdruck in der Ausgabe auszugeben. Wenn der Ausdruck mit einer Variablen oder einem Funktionsaufruf beginnt, ist es nicht nötig, ein Gleichheitszeichen zu schreiben. Das bedeutet in der Praxis, dass es fast nie geschrieben werden muss:

```latte
Name: {$name} {$surname}<br>
Age: {date('Y') - $birth}<br>
```

Sie können alles, was Sie aus PHP kennen, als Ausdruck schreiben. Sie müssen nur keine neue Sprache lernen. Zum Beispiel:


```latte
{='0' . ($num ?? $num * 3) . ', ' . PHP_VERSION}
```

Bitte suchen Sie nicht nach einer Bedeutung in dem vorherigen Beispiel, aber wenn Sie eine finden, schreiben Sie uns :-)


Ausweichende Ausgabe .[#toc-escaping-output]
--------------------------------------------

Was ist die wichtigste Aufgabe eines Template-Systems? Sicherheitslücken zu vermeiden. Und genau das tut Latte, wenn Sie etwas in die Ausgabe drucken. Es entschlüsselt automatisch alles:

```latte
<p>{='one < two'}</p>   {* prints: '<p>one &lt; two</p>' *}
```

Um genau zu sein, verwendet Latte kontextabhängiges Escaping, eine so wichtige und einzigartige Funktion dass wir ihr [ein eigenes Kapitel |safety-first#context-aware-escaping] gewidmet haben.

Und wenn Sie HTML-codierte Inhalte aus einer vertrauenswürdigen Quelle drucken? Dann können Sie das Escaping einfach abschalten:

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

.[warning]
Der Missbrauch des `noescape`-Filters kann zu einer XSS-Schwachstelle führen! Verwenden Sie ihn nur, wenn Sie **absolut sicher** sind, was Sie tun und dass die Zeichenfolge, die Sie ausgeben, aus einer vertrauenswürdigen Quelle stammt.


Drucken in JavaScript .[#toc-printing-in-javascript]
----------------------------------------------------

Dank der kontextsensitiven Escape-Funktion ist es wunderbar einfach, Variablen innerhalb von JavaScript zu drucken, und Latte wird sie korrekt escapen.

Die Variable muss keine Zeichenkette sein, es wird jeder Datentyp unterstützt, der dann als JSON kodiert wird:

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

Erzeugt:

```latte
<script>
	alert(["hello", true, 1]);
</script>
```

Dies ist auch der Grund, warum **Variablen nicht in Anführungszeichen** gesetzt werden sollten: Latte fügt sie um Strings herum ein. Und wenn Sie eine String-Variable in einen anderen String einfügen wollen, verketten Sie sie einfach:

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

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

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


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

Der gedruckte Ausdruck kann [durch Filter |syntax#filters] verändert werden. In diesem Beispiel wird die Zeichenkette beispielsweise in Großbuchstaben umgewandelt und auf maximal 30 Zeichen gekürzt:

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

Sie können auch Filter auf Teile eines Ausdrucks anwenden, wie folgt:

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


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


`{if}` `{elseif}` `{else}`
--------------------------

Bedingungen verhalten sich genauso wie die entsprechenden PHP-Ausdrücke. Sie können die gleichen Ausdrücke verwenden, die Sie aus PHP kennen, Sie müssen keine neue Sprache lernen.

```latte
{if $product->inStock > Stock::Minimum}
	In stock
{elseif $product->isOnWay()}
	On the way
{else}
	Not available
{/if}
```

Wie jedes Paar-Tag kann ein Paar von `{if} ... {/ if}` zum Beispiel als [n:attribute |syntax#n:attributes] geschrieben werden:

```latte
<p n:if="$count > 0">In stock {$count} items</p>
```

Wussten Sie, dass Sie das Präfix `tag-` zu n:Attributen hinzufügen können? Dann wirkt sich die Bedingung nur auf die HTML-Tags aus und der Inhalt zwischen ihnen wird immer gedruckt:

```latte
<a href="..." n:tag-if="$clickable">Hello</a>

{* prints 'Hello' when $clickable is falsey *}
{* prints '<a href="...">Hello</a>' when $clickable is truthy *}
```

Schön.


`n:else` .{data-version:3.0.11}
-------------------------------

Wenn Sie die Bedingung `{if} ... {/if}` in Form eines [n:-Attributs |syntax#n:attributes] schreiben, haben Sie die Möglichkeit, mit `n:else` eine alternative Verzweigung anzugeben:

```latte
<strong n:if="$count > 0">In stock {$count} items</strong>

<em n:else>not available</em>
```

Das Attribut `n:else` kann auch in Verbindung mit [`n:ifset` |#ifset-elseifset], [`n:foreach` |#foreach], [`n:try` |#try], [`n:ifcontent` |#n:ifcontent], und [`n:ifchanged` |#ifchanged].


`{/if $cond}`
-------------

Sie werden vielleicht überrascht sein, dass der Ausdruck in der Bedingung `{if}` auch im End-Tag angegeben werden kann. Dies ist in Situationen nützlich, in denen wir den Wert der Bedingung noch nicht kennen, wenn das Tag geöffnet wird. Nennen wir es eine aufgeschobene Entscheidung.

Wir beginnen z. B. mit der Auflistung einer Tabelle mit Datensätzen aus der Datenbank und stellen erst nach Fertigstellung des Berichts fest, dass kein Datensatz in der Datenbank vorhanden war. Also setzen wir die Bedingung in das End-Tag `{/if}`, und wenn es keinen Datensatz gibt, wird nichts davon gedruckt:

```latte
{if}
	<h1>Printing rows from the database</h1>

	<table>
	{foreach $resultSet as $row}
		...
	{/foreach}
	</table>
{/if isset($row)}
```

Praktisch, nicht wahr?

Sie können auch `{else}` in der aufgeschobenen Bedingung verwenden, aber nicht `{elseif}`.


`{ifset}` `{elseifset}`
-----------------------

.[note]
Siehe auch [`{ifset block}` |template-inheritance#checking-block-existence]

Verwenden Sie die `{ifset $var}` Bedingung, um festzustellen, ob eine Variable (oder mehrere Variablen) existiert und einen Nicht-Null-Wert hat. Es ist eigentlich das Gleiche wie `if (isset($var))` in PHP. Wie jedes Paar-Tag kann es in der Form von [n:attribute |syntax#n:attributes] geschrieben werden, also zeigen wir es in einem Beispiel:

```latte
<meta name="robots" content="{$robots}" n:ifset="$robots">
```


`{ifchanged}`
-------------

`{ifchanged}` prüft, ob sich der Wert einer Variablen seit der letzten Iteration in der Schleife (foreach, for oder while) geändert hat.

Wenn wir eine oder mehrere Variablen im Tag angeben, wird geprüft, ob sich eine von ihnen geändert hat, und der Inhalt wird entsprechend ausgegeben. Im folgenden Beispiel wird beispielsweise bei der Auflistung von Namen jedes Mal der erste Buchstabe eines Namens als Überschrift ausgegeben, wenn er sich ändert:

```latte
{foreach ($names|sort) as $name}
	{ifchanged $name[0]} <h2>{$name[0]}</h2> {/ifchanged}

	<p>{$name}</p>
{/foreach}
```

Wenn jedoch kein Argument angegeben wird, wird der gerenderte Inhalt selbst mit seinem vorherigen Zustand verglichen. Das bedeutet, dass wir im vorherigen Beispiel das Argument im Tag getrost weglassen können. Und natürlich können wir auch [n:attribute |syntax#n:attributes] verwenden:

```latte
{foreach ($names|sort) as $name}
	<h2 n:ifchanged>{$name[0]}</h2>

	<p>{$name}</p>
{/foreach}
```

Sie können auch eine `{else}` Klausel innerhalb der `{ifchanged}` einfügen.


`{switch}` `{case}` `{default}`
-------------------------------
Vergleicht den Wert mit mehreren Optionen. Dies ist ähnlich wie die `switch` Struktur, die Sie aus PHP kennen. Latte verbessert sie jedoch:

- verwendet einen strengen Vergleich (`===`)
- braucht kein `break`

Es ist also das exakte Äquivalent der `match` Struktur, die PHP 8.0 mitbringt.

```latte
{switch $transport}
	{case train}
		By train
	{case plane}
		By plane
	{default}
		Differently
{/switch}
```

Die Klausel `{case}` kann mehrere durch Kommas getrennte Werte enthalten:

```latte
{switch $status}
{case $status::New}<b>new item</b>
{case $status::Sold, $status::Unknown}<i>not available</i>
{/switch}
```


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

In Latte stehen Ihnen alle Schleifen, die Sie aus PHP kennen, zur Verfügung: foreach, for und while.


`{foreach}`
-----------

Sie schreiben den Zyklus genau so wie in PHP:

```latte
{foreach $langs as $code => $lang}
	<span>{$lang}</span>
{/foreach}
```

Darüber hinaus hat er einige praktische Verbesserungen, über die wir jetzt sprechen werden.

So stellt Latte zum Beispiel sicher, dass erstellte Variablen nicht versehentlich gleichnamige globale Variablen überschreiben. Das hilft Ihnen, wenn Sie davon ausgehen, dass `$lang` die aktuelle Sprache der Seite ist, und Sie nicht merken, dass `foreach $langs as $lang` diese Variable überschrieben hat.

Die foreach-Schleife kann auch sehr elegant und sparsam mit [n:attribute |syntax#n:attributes] geschrieben werden:

```latte
<ul>
	<li n:foreach="$items as $item">{$item->name}</li>
</ul>
```

Wussten Sie, dass Sie n:attributes das Präfix `inner-` voranstellen können? Dann wird in der Schleife nur noch der innere Teil des Elements wiederholt:

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

Es wird also etwas gedruckt wie:

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


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

Die Schleife `foreach` kann eine optionale Klausel `{else}` enthalten, deren Text angezeigt wird, wenn das angegebene Feld leer ist:

```latte
<ul>
	{foreach $people as $person}
		<li>{$person->name}</li>
	{else}
		<li><em>Sorry, no users in this list</em></li>
	{/foreach}
</ul>
```


`$iterator`
-----------

Innerhalb der Schleife `foreach` wird die Variable `$iterator` initialisiert. Sie enthält wichtige Informationen über die aktuelle Schleife.

- `$iterator->first` - ist dies die erste Iteration?
- `$iterator->last` - ist dies die letzte Iteration?
- `$iterator->counter` - Iterationszähler, beginnt bei 1
- `$iterator->counter0` - Iterationszähler, beginnt bei 0
- `$iterator->odd` - Ist diese Iteration ungerade?
- `$iterator->even` - ist diese Iteration gerade?
- `$iterator->parent` - der Iterator, der den aktuellen Iterator umgibt
- `$iterator->nextValue` - das nächste Element in der Schleife
- `$iterator->nextKey` - der Schlüssel des nächsten Elements in der Schleife


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

Die Latte ist schlau und `$iterator->last` funktioniert nicht nur für Arrays, sondern auch, wenn die Schleife über einen allgemeinen Iterator läuft, bei dem die Anzahl der Elemente nicht im Voraus bekannt ist.


`{first}` `{last}` `{sep}`
--------------------------

Diese Tags können innerhalb der Schleife `{foreach}` verwendet werden. Der Inhalt von `{first}` wird beim ersten Durchlauf gerendert.
Der Inhalt von `{last}` wird gerendert ... können Sie es erraten? Ja, für den letzten Durchlauf. Dies sind eigentlich Abkürzungen für `{if $iterator->first}` und `{if $iterator->last}`.

Die Tags können auch als [n:attributes |syntax#n:attributes] geschrieben werden:

```latte
{foreach $rows as $row}
	{first}<h1>List of names</h1>{/first}

	<p>{$row->name}</p>

	<hr n:last>
{/foreach}
```

Der Inhalt von `{sep}` wird wiedergegeben, wenn es sich nicht um die letzte Iteration handelt, und eignet sich daher für die Ausgabe von Begrenzungszeichen, wie z. B. Kommas zwischen aufgelisteten Elementen:

```latte
{foreach $items as $item} {$item} {sep}, {/sep} {/foreach}
```

Das ist doch ziemlich praktisch, oder?


`{iterateWhile}`
----------------

Sie vereinfacht die Gruppierung von linearen Daten während der Iteration in einer foreach-Schleife, indem sie die Iteration in einer verschachtelten Schleife durchführt, solange die Bedingung erfüllt ist. [Lesen Sie die Anweisungen im Kochbuch |cookbook/iteratewhile].

Sie kann auch `{first}` und `{last}` im obigen Beispiel elegant ersetzen:

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


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

Wir schreiben den Zyklus genau so wie in PHP:

```latte
{for $i = 0; $i < 10; $i++}
	<span>Item #{$i}</span>
{/for}
```

Das Tag kann auch als [n:attribute |syntax#n:attributes] geschrieben werden:

```latte
<h1 n:for="$i = 0; $i < 10; $i++">{$i}</h1>
```


`{while}`
---------

Auch hier schreiben wir den Zyklus genau so, wie in PHP:

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

Oder als [n:Attribut |syntax#n:attributes]:

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

Eine Variante mit einer Bedingung im End-Tag entspricht der do-while-Schleife in PHP:

```latte
{while}
	<span>{$item->title}</span>
{/while $item = $item->getNext()}
```


`{continueIf}` `{skipIf}` `{breakIf}`
-------------------------------------

Es gibt spezielle Tags, die Sie zur Steuerung jeder Schleife verwenden können - `{continueIf ?}` und `{breakIf ?}`, die zur nächsten Iteration springen bzw. die Schleife beenden, wenn die Bedingungen erfüllt sind:

```latte
{foreach $rows as $row}
	{continueIf $row->date < $now}
	{breakIf $row->parent === null}
	...
{/foreach}
```


Das Tag `{skipIf}` ist dem Tag `{continueIf}` sehr ähnlich, erhöht aber den Zähler nicht. So gibt es keine Löcher in der Nummerierung, wenn Sie `$iterator->counter` ausdrucken und einige Elemente überspringen. Auch die {else}-Klausel wird wiedergegeben, wenn Sie alle Elemente überspringen.

```latte
<ul>
	{foreach $people as $person}
		{skipIf $person->age < 18}
		<li>{$iterator->counter}. {$person->name}</li>
	{else}
		<li><em>Sorry, no adult users in this list</em></li>
	{/foreach}
</ul>
```


`{exitIf}` .{data-version:3.0.5}
--------------------------------

Beendet das Rendering einer Vorlage oder eines Blocks, wenn eine Bedingung erfüllt ist (d. h. "early exit").

```latte
{exitIf !$messages}

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


Schablonen einbeziehen .[#toc-including-templates]
==================================================


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

.[note]
Siehe auch [`{include block}` |template-inheritance#printing-blocks]

Der `{include}` Tag lädt und rendert die angegebene Vorlage. In unserer Lieblingssprache PHP sieht das so aus:

```php
<?php include 'header.phtml'; ?>
```

Eingebundene Templates haben keinen Zugriff auf die Variablen des aktiven Kontexts, aber sie haben Zugriff auf die globalen Variablen.

Sie können der eingefügten Vorlage auf folgende Weise Variablen übergeben:

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

Der Name der Vorlage kann ein beliebiger PHP-Ausdruck sein:

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

Der eingefügte Inhalt kann durch [Filter |syntax#filters] verändert werden. Im folgenden Beispiel werden alle HTML-Elemente entfernt und die Groß- und Kleinschreibung angepasst:

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

Die [Vorlagenvererbung |template inheritance] ist standardmäßig **nicht** daran beteiligt. Sie können zwar Block-Tags zu eingebundenen Vorlagen hinzufügen, diese ersetzen jedoch nicht die passenden Blöcke in der Vorlage, in die sie eingebunden sind. Betrachten Sie Includes als unabhängige und abgeschirmte Teile von Seiten oder Modulen. Dieses Verhalten kann mit dem Modifikator `with blocks` geändert werden:

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

Die Beziehung zwischen dem im Tag angegebenen Dateinamen und der Datei auf der Festplatte ist eine Sache des [Loaders |extending-latte#Loaders].


`{sandbox}`
-----------

Wenn Sie eine von einem Endbenutzer erstellte Vorlage einbinden, sollten Sie eine Sandbox verwenden (weitere Informationen finden Sie in der [Sandbox-Dokumentation |sandbox]):

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


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

.[note]
Siehe auch [`{block name}` |template-inheritance#blocks]

Blöcke ohne Namen dienen dazu, [Filter |syntax#filters] auf einen Teil der Vorlage anzuwenden. Sie können zum Beispiel einen [Streifenfilter |filters#strip] anwenden, um überflüssige Leerzeichen zu entfernen:

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


Behandlung von Ausnahmen .[#toc-exception-handling]
===================================================


`{try}`
-------

Diese Tags machen es extrem einfach, robuste Vorlagen zu erstellen.

Wenn beim Rendern des `{try}` -Blocks eine Ausnahme auftritt, wird der gesamte Block verworfen und das Rendern danach fortgesetzt:

```latte
{try}
	<ul>
		{foreach $twitter->loadTweets() as $tweet}
  			<li>{$tweet->text}</li>
		{/foreach}
	</ul>
{/try}
```

Der Inhalt der optionalen Klausel `{else}` wird nur gerendert, wenn eine Ausnahme auftritt:

```latte
{try}
	<ul>
		{foreach $twitter->loadTweets() as $tweet}
  			<li>{$tweet->text}</li>
		{/foreach}
	</ul>
	{else}
	<p>Sorry, the tweets could not be loaded.</p>
{/try}
```

Der Tag kann auch als [n:attribute |syntax#n:attributes] geschrieben werden:

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

Es ist auch möglich, [einen eigenen Exception-Handler |develop#exception handler] für z.B. die Protokollierung zu definieren:


`{rollback}`
------------

Der Block `{try}` kann auch manuell mit `{rollback}` angehalten und übersprungen werden. So müssen Sie nicht alle Eingabedaten im Voraus prüfen und können erst während des Renderings entscheiden, ob es sinnvoll ist, das Objekt zu rendern.

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


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


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

Wir werden neue Variablen in der Vorlage mit dem Tag `{var}` erstellen:

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

{* Mehrfache Deklaration *}
{var $name = 'John Smith', $age = 27}
```

Das Tag `{default}` funktioniert ähnlich, mit dem Unterschied, dass es Variablen nur dann anlegt, wenn sie nicht existieren:

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

Sie können auch [Typen von Variablen |type-system] angeben. Im Moment sind sie informativ und Latte prüft sie nicht.

```latte
{var string $name = $article->getTitle()}
{default int $id = 0}
```


`{parameters}`
--------------

So wie eine Funktion ihre Parameter deklariert, kann eine Vorlage ihre Variablen am Anfang deklarieren:

```latte
{parameters
	$a,
	?int $b,
	int|string $c = 10
}
```

Die Variablen `$a` und `$b` ohne Standardwert haben automatisch den Standardwert `null`. Die deklarierten Typen sind immer noch informativ, und Latte überprüft sie nicht.

Andere als die deklarierten Variablen werden nicht an die Vorlage übergeben. Dies ist ein Unterschied zum Tag `{default}`.


`{capture}`
-----------

Mit dem Tag `{capture}` können Sie die Ausgabe in einer Variablen erfassen:

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

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

Der Tag kann auch als [n:attribute |syntax#n:attributes] geschrieben werden, wie jeder paarweise Tag:

```latte
<ul n:capture="$var">
	<li>Hello World</li>
</ul>
```

Die HTML-Ausgabe wird in der Variablen `$var` als `Latte\Runtime\Html` -Objekt gespeichert, um [unerwünschtes Escaping |develop#disabling-auto-escaping-of-variable] beim Drucken [zu vermeiden |develop#disabling-auto-escaping-of-variable].


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


`{contentType}`
---------------

Verwenden Sie das Tag, um anzugeben, welche Art von Inhalt die Vorlage darstellt. Die Optionen sind:

- `html` (Standardtyp)
- `xml`
- `javascript`
- `css`
- `calendar` (iCal)
- `text`

Die Verwendung dieses Befehls ist wichtig, weil er die [kontextabhängige Escape-Funktion |safety-first#context-aware-escaping] einstellt und nur dann kann Latte korrekt escapen. Zum Beispiel schaltet `{contentType xml}` in den XML-Modus, `{contentType text}` schaltet das Escapen komplett ab.

Handelt es sich bei dem Parameter um einen MIME-Typ mit vollem Funktionsumfang, wie z. B. `application/xml`, so wird auch ein HTTP-Header `Content-Type` an den Browser gesendet:

```latte
{contentType application/xml}
<?xml version="1.0"?>
<rss version="2.0">
	<channel>
		<title>RSS feed</title>
		<item>
			...
		</item>
	</channel>
</rss>
```


`{debugbreak}`
--------------

Gibt die Stelle an, an der die Codeausführung unterbrochen wird. Sie wird zu Debugging-Zwecken verwendet, damit der Programmierer die Laufzeitumgebung überprüfen und sicherstellen kann, dass der Code wie erwartet ausgeführt wird. Er unterstützt [Xdebug |https://xdebug.org]. Zusätzlich können Sie eine Bedingung angeben, unter der der Code unterbrochen werden soll.

```latte
{debugbreak}                {* bricht das Programm *}

{debugbreak $counter == 1}  {* bricht das Programm ab, wenn die Bedingung erfüllt ist *}
```


`{do}`
------

Führt den PHP-Code aus und gibt nichts aus. Wie bei allen anderen Tags ist der PHP-Code ein einzelner Ausdruck, siehe [PHP-Einschränkungen |syntax#PHP Limitations in Latte].

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


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

Gibt eine Variable oder den aktuellen Kontext aus.

```latte
{dump $name} {* gibt die Variable $name aus *}

{dump}       {* gibt alle definierten Variablen aus *}
```

.[caution]
Erfordert das Paket [Tracy |tracy:].


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

Ermöglicht die Ausführung von beliebigem PHP-Code. Das Tag muss mit der Erweiterung [RawPhpExtension |develop#RawPhpExtension] aktiviert werden.


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

Entfernt unnötige Leerzeichen. Ähnlich wie der [raumlose |filters#spaceless] Filter.

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

Ausgaben:

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

Der Tag kann auch als [n:attribute |syntax#n:attributes] geschrieben werden:


`{syntax}`
----------

Latten-Tags müssen nicht nur in geschweifte Klammern eingeschlossen werden. Sie können ein anderes Trennzeichen wählen, auch zur Laufzeit. Dies geschieht durch `{syntax…}`, wobei der Parameter sein kann:

- double: `{{...}}`
- off: deaktiviert die Latte-Tags vollständig

Mit der Notation n:attribute können wir Latte nur für einen JavaScript-Block deaktivieren:

```latte
<script n:syntax="off">
	var obj = {var: 123}; // this isn't a tag any more
</script>
```

Latte kann sehr bequem innerhalb von JavaScript verwendet werden, man sollte nur Konstrukte wie in diesem Beispiel vermeiden, bei denen der Buchstabe unmittelbar auf `{` folgt, siehe [Latte innerhalb von JavaScript oder CSS |recipes#Latte inside JavaScript or CSS].

Wenn Sie Latte mit dem `{syntax off}` (d.h. Tag, nicht das n:-Attribut) ausschalten, werden alle Tags bis zu `{/syntax}` strikt ignoriert.


{trace}
-------

Wirft eine `Latte\RuntimeException` Exception, deren Stack-Trace im Sinne der Templates ist. Anstatt Funktionen und Methoden aufzurufen, werden also Blöcke aufgerufen und Vorlagen eingefügt. Wenn Sie ein Tool zur übersichtlichen Darstellung von geworfenen Ausnahmen wie [Tracy |tracy:] verwenden, sehen Sie deutlich den Aufrufstapel, einschließlich aller übergebenen Argumente.


HTML-Tag-Hilfsmittel .[#toc-html-tag-helpers]
=============================================


n:class
-------

Dank `n:class` ist es sehr einfach, das HTML-Attribut `class` genau so zu generieren, wie Sie es brauchen.

Beispiel: Ich möchte, dass das aktive Element die Klasse `active` hat:

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

Außerdem muss das erste Element die Klassen `first` und `main` haben:

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

Und alle Elemente sollten die Klasse `list-item` haben:

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

Verblüffend einfach, nicht wahr?


n:attr
------

Das Attribut `n:attr` kann beliebige HTML-Attribute mit der gleichen Eleganz wie [n:class |#n:class] erzeugen.

```latte
{foreach $data as $item}
	<input type="checkbox" n:attr="value: $item->getValue(), checked: $item->isActive()">
{/foreach}
```

Abhängig von den zurückgegebenen Werten zeigt es z. B:

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

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

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


n:tag
-----

Das Attribut `n:tag` kann den Namen eines HTML-Elements dynamisch ändern.

```latte
<h1 n:tag="$heading" class="main">{$title}</h1>
```

Wenn `$heading === null`, wird das `<h1>` Tag ohne Änderung gedruckt. Andernfalls wird der Elementname in den Wert der Variablen geändert, so dass für `$heading === 'h3'` geschrieben wird:

```latte
<h3 class="main">...</h3>
```

Da es sich bei Latte um ein sicheres Templating-System handelt, wird überprüft, ob der neue Tag-Name gültig ist und keine unerwünschten oder bösartigen Werte enthält.


n:ifcontent
-----------

Verhindert, dass ein leeres HTML-Element gedruckt wird, d.h. ein Element, das nichts als Leerraum enthält.

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

Abhängig von den Werten der Variablen `$error` wird dies gedruckt:

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

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


Übersetzung .[#toc-translation]
===============================

Damit die Übersetzungs-Tags funktionieren, müssen Sie den [Übersetzer ein richten|develop#TranslatorExtension]. Sie können auch den [`translate` |filters#translate] Filter für die Übersetzung verwenden.


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

Übersetzt Werte in andere Sprachen.

```latte
<a href="basket">{_'Basket'}</a>
<span>{_$item}</span>
```

Es können auch andere Parameter an den Übersetzer übergeben werden:

```latte
<a href="basket">{_'Basket', domain: order}</a>
```


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

Překládá části šablony:

```latte
<h1>{translate}Order{/translate}</h1>

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

Der Tag kann auch als [n:attribute |syntax#n:attributes] geschrieben werden, um das Innere des Elements zu übersetzen:

```latte
<h1 n:translate>Order</h1>
```

Latte Tags

Zusammenfassung und Beschreibung aller in Latte integrierten Tags.

Drucken
{$var}, {...} oder {=...} druckt eine Variable oder einen Ausdruck mit Escapezeichen
{$var|filter} druckt mit Filtern
{l} oder {r} druckt { or } Zeichen
Bedingungen
{if}{elseif}{else}{/if} Bedingung if
{ifset}{elseifset}{/ifset} Bedingung ifset
{ifchanged}{/ifchanged} Test, ob eine Änderung stattgefunden hat
{switch} {case} {default} {/switch} Bedingung switch
n:else alternative Inhalte für Bedingungen
Schleifen
{foreach}{/foreach} foreach
{for}{/for} for
{while}{/while} while
{continueIf $cond} weiter zur nächsten Iteration
{skipIf $cond} überspringt die aktuelle Schleifeniteration
{breakIf $cond} bricht Schleife ab
{exitIf $cond} vorzeitiges Beenden
{first}{/first} ist dies die erste Iteration?
{last}{/last} ist es die letzte Iteration?
{sep}{/sep} wird die nächste Iteration folgen?
{iterateWhile}{/iterateWhile} strukturiert foreach
$iterator Spezielle Variable innerhalb der foreach-Schleife
Einbindung anderer Vorlagen
{include 'file.latte'} schließt eine Vorlage aus einer anderen Datei ein
{sandbox 'file.latte'} Einfügen einer Vorlage im Sandbox-Modus
Blöcke, Layouts, Vererbung von Vorlagen
{block} anonymer Block
{block blockname} Blockdefinition
{define blockname} Blockdefinition für zukünftige Verwendung
{include blockname} druckt Block
{include blockname from 'file.latte'} druckt einen Block aus einer Datei
{import 'file.latte'} lädt Blöcke aus einer anderen Vorlage
{layout 'file.latte'} / {extends} gibt eine Layout-Datei an
{embed}{/embed} lädt die Vorlage oder den Block und ermöglicht das Überschreiben der Blöcke
{ifset blockname}{/ifset} Bedingung, wenn Block definiert ist
Ausnahmebehandlung
{try}{else}{/try} Abfangen von Ausnahmen
{rollback} verwirft try-Block
Variablen
{var $foo = value} Erstellung von Variablen
{default $foo = value} Standardwert, wenn Variable nicht deklariert ist
{parameters} deklariert Variablen, gibt einen Standardwert ein
{capture}{/capture} erfasst einen Abschnitt in einer Variablen
Typen
{varType} deklariert den Typ einer Variablen
{varPrint} schlägt Variablentypen vor
{templateType} deklariert Variablentypen mittels Klasse
{templatePrint} erzeugt Klasse mit Eigenschaften
Übersetzung
{_string} druckt übersetzt
{translate}{/translate} übersetzt den Inhalt
Andere
{contentType} schaltet den Escaping-Modus um und sendet HTTP-Header
{debugbreak} setzt einen Haltepunkt im Code
{do} wertet einen Ausdruck aus, ohne ihn zu drucken
{dump} gibt Variablen in die Tracy Bar aus
{php} führt beliebigen PHP-Code aus
{spaceless}{/spaceless} entfernt unnötige Leerzeichen
{syntax} schaltet die Syntax während der Laufzeit um
{trace} zeigt Stack-Trace
HTML-Tag-Helfer
n:class intelligentes Klassenattribut
n:attr intelligente HTML-Attribute
n:tag Dynamischer Name des HTML-Elements
n:ifcontent Leeren HTML-Tag auslassen
Nur in Nette Framework verfügbar
n:href Link in <a> HTML-Elementen
{link} gibt einen Link aus
{plink} druckt einen Link zu einem Presenter
{control} druckt eine Komponente
{snippet}{/snippet} ein Template-Snippet, das per AJAX gesendet werden kann
{snippetArea} Schnipsel Umschlag
{cache}{/cache} zwischenspeichert einen Vorlagenabschnitt
Nur mit Nette Forms verfügbar
{form}{/form} druckt ein Formularelement
{label}{/label} druckt eine Formulareingabebezeichnung
{input} druckt ein Formulareingabeelement
{inputError} gibt eine Fehlermeldung für ein Formulareingabeelement aus
n:name aktiviert ein HTML-Eingabeelement
{formContainer}{/formContainer} Darstellung des Formular-Containers

Drucken

{$var} {...} {=...}

Latte verwendet das Tag {=...}, um einen beliebigen Ausdruck in der Ausgabe auszugeben. Wenn der Ausdruck mit einer Variablen oder einem Funktionsaufruf beginnt, ist es nicht nötig, ein Gleichheitszeichen zu schreiben. Das bedeutet in der Praxis, dass es fast nie geschrieben werden muss:

Name: {$name} {$surname}<br>
Age: {date('Y') - $birth}<br>

Sie können alles, was Sie aus PHP kennen, als Ausdruck schreiben. Sie müssen nur keine neue Sprache lernen. Zum Beispiel:

{='0' . ($num ?? $num * 3) . ', ' . PHP_VERSION}

Bitte suchen Sie nicht nach einer Bedeutung in dem vorherigen Beispiel, aber wenn Sie eine finden, schreiben Sie uns :-)

Ausweichende Ausgabe

Was ist die wichtigste Aufgabe eines Template-Systems? Sicherheitslücken zu vermeiden. Und genau das tut Latte, wenn Sie etwas in die Ausgabe drucken. Es entschlüsselt automatisch alles:

<p>{='one < two'}</p>   {* prints: '<p>one &lt; two</p>' *}

Um genau zu sein, verwendet Latte kontextabhängiges Escaping, eine so wichtige und einzigartige Funktion dass wir ihr ein eigenes Kapitel gewidmet haben.

Und wenn Sie HTML-codierte Inhalte aus einer vertrauenswürdigen Quelle drucken? Dann können Sie das Escaping einfach abschalten:

{$trustedHtmlString|noescape}

Der Missbrauch des noescape-Filters kann zu einer XSS-Schwachstelle führen! Verwenden Sie ihn nur, wenn Sie absolut sicher sind, was Sie tun und dass die Zeichenfolge, die Sie ausgeben, aus einer vertrauenswürdigen Quelle stammt.

Drucken in JavaScript

Dank der kontextsensitiven Escape-Funktion ist es wunderbar einfach, Variablen innerhalb von JavaScript zu drucken, und Latte wird sie korrekt escapen.

Die Variable muss keine Zeichenkette sein, es wird jeder Datentyp unterstützt, der dann als JSON kodiert wird:

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

Erzeugt:

<script>
	alert(["hello", true, 1]);
</script>

Dies ist auch der Grund, warum Variablen nicht in Anführungszeichen gesetzt werden sollten: Latte fügt sie um Strings herum ein. Und wenn Sie eine String-Variable in einen anderen String einfügen wollen, verketten Sie sie einfach:

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

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

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

Filter

Der gedruckte Ausdruck kann durch Filter verändert werden. In diesem Beispiel wird die Zeichenkette beispielsweise in Großbuchstaben umgewandelt und auf maximal 30 Zeichen gekürzt:

{$string|upper|truncate:30}

Sie können auch Filter auf Teile eines Ausdrucks anwenden, wie folgt:

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

Bedingungen

{if} {elseif} {else}

Bedingungen verhalten sich genauso wie die entsprechenden PHP-Ausdrücke. Sie können die gleichen Ausdrücke verwenden, die Sie aus PHP kennen, Sie müssen keine neue Sprache lernen.

{if $product->inStock > Stock::Minimum}
	In stock
{elseif $product->isOnWay()}
	On the way
{else}
	Not available
{/if}

Wie jedes Paar-Tag kann ein Paar von {if} ... {/ if} zum Beispiel als n:attribute geschrieben werden:

<p n:if="$count > 0">In stock {$count} items</p>

Wussten Sie, dass Sie das Präfix tag- zu n:Attributen hinzufügen können? Dann wirkt sich die Bedingung nur auf die HTML-Tags aus und der Inhalt zwischen ihnen wird immer gedruckt:

<a href="..." n:tag-if="$clickable">Hello</a>

{* prints 'Hello' when $clickable is falsey *}
{* prints '<a href="...">Hello</a>' when $clickable is truthy *}

Schön.

n:else

Wenn Sie die Bedingung {if} ... {/if} in Form eines n:-Attributs schreiben, haben Sie die Möglichkeit, mit n:else eine alternative Verzweigung anzugeben:

<strong n:if="$count > 0">In stock {$count} items</strong>

<em n:else>not available</em>

Das Attribut n:else kann auch in Verbindung mit n:ifset, n:foreach, n:try, n:ifcontent, und n:ifchanged.

{/if $cond}

Sie werden vielleicht überrascht sein, dass der Ausdruck in der Bedingung {if} auch im End-Tag angegeben werden kann. Dies ist in Situationen nützlich, in denen wir den Wert der Bedingung noch nicht kennen, wenn das Tag geöffnet wird. Nennen wir es eine aufgeschobene Entscheidung.

Wir beginnen z. B. mit der Auflistung einer Tabelle mit Datensätzen aus der Datenbank und stellen erst nach Fertigstellung des Berichts fest, dass kein Datensatz in der Datenbank vorhanden war. Also setzen wir die Bedingung in das End-Tag {/if}, und wenn es keinen Datensatz gibt, wird nichts davon gedruckt:

{if}
	<h1>Printing rows from the database</h1>

	<table>
	{foreach $resultSet as $row}
		...
	{/foreach}
	</table>
{/if isset($row)}

Praktisch, nicht wahr?

Sie können auch {else} in der aufgeschobenen Bedingung verwenden, aber nicht {elseif}.

{ifset} {elseifset}

Siehe auch {ifset block}

Verwenden Sie die {ifset $var} Bedingung, um festzustellen, ob eine Variable (oder mehrere Variablen) existiert und einen Nicht-Null-Wert hat. Es ist eigentlich das Gleiche wie if (isset($var)) in PHP. Wie jedes Paar-Tag kann es in der Form von n:attribute geschrieben werden, also zeigen wir es in einem Beispiel:

<meta name="robots" content="{$robots}" n:ifset="$robots">

{ifchanged}

{ifchanged} prüft, ob sich der Wert einer Variablen seit der letzten Iteration in der Schleife (foreach, for oder while) geändert hat.

Wenn wir eine oder mehrere Variablen im Tag angeben, wird geprüft, ob sich eine von ihnen geändert hat, und der Inhalt wird entsprechend ausgegeben. Im folgenden Beispiel wird beispielsweise bei der Auflistung von Namen jedes Mal der erste Buchstabe eines Namens als Überschrift ausgegeben, wenn er sich ändert:

{foreach ($names|sort) as $name}
	{ifchanged $name[0]} <h2>{$name[0]}</h2> {/ifchanged}

	<p>{$name}</p>
{/foreach}

Wenn jedoch kein Argument angegeben wird, wird der gerenderte Inhalt selbst mit seinem vorherigen Zustand verglichen. Das bedeutet, dass wir im vorherigen Beispiel das Argument im Tag getrost weglassen können. Und natürlich können wir auch n:attribute verwenden:

{foreach ($names|sort) as $name}
	<h2 n:ifchanged>{$name[0]}</h2>

	<p>{$name}</p>
{/foreach}

Sie können auch eine {else} Klausel innerhalb der {ifchanged} einfügen.

{switch} {case} {default}

Vergleicht den Wert mit mehreren Optionen. Dies ist ähnlich wie die switch Struktur, die Sie aus PHP kennen. Latte verbessert sie jedoch:

  • verwendet einen strengen Vergleich (===)
  • braucht kein break

Es ist also das exakte Äquivalent der match Struktur, die PHP 8.0 mitbringt.

{switch $transport}
	{case train}
		By train
	{case plane}
		By plane
	{default}
		Differently
{/switch}

Die Klausel {case} kann mehrere durch Kommas getrennte Werte enthalten:

{switch $status}
{case $status::New}<b>new item</b>
{case $status::Sold, $status::Unknown}<i>not available</i>
{/switch}

Schleifen

In Latte stehen Ihnen alle Schleifen, die Sie aus PHP kennen, zur Verfügung: foreach, for und while.

{foreach}

Sie schreiben den Zyklus genau so wie in PHP:

{foreach $langs as $code => $lang}
	<span>{$lang}</span>
{/foreach}

Darüber hinaus hat er einige praktische Verbesserungen, über die wir jetzt sprechen werden.

So stellt Latte zum Beispiel sicher, dass erstellte Variablen nicht versehentlich gleichnamige globale Variablen überschreiben. Das hilft Ihnen, wenn Sie davon ausgehen, dass $lang die aktuelle Sprache der Seite ist, und Sie nicht merken, dass foreach $langs as $lang diese Variable überschrieben hat.

Die foreach-Schleife kann auch sehr elegant und sparsam mit n:attribute geschrieben werden:

<ul>
	<li n:foreach="$items as $item">{$item->name}</li>
</ul>

Wussten Sie, dass Sie n:attributes das Präfix inner- voranstellen können? Dann wird in der Schleife nur noch der innere Teil des Elements wiederholt:

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

Es wird also etwas gedruckt wie:

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

{else}

Die Schleife foreach kann eine optionale Klausel {else} enthalten, deren Text angezeigt wird, wenn das angegebene Feld leer ist:

<ul>
	{foreach $people as $person}
		<li>{$person->name}</li>
	{else}
		<li><em>Sorry, no users in this list</em></li>
	{/foreach}
</ul>

$iterator

Innerhalb der Schleife foreach wird die Variable $iterator initialisiert. Sie enthält wichtige Informationen über die aktuelle Schleife.

  • $iterator->first – ist dies die erste Iteration?
  • $iterator->last – ist dies die letzte Iteration?
  • $iterator->counter – Iterationszähler, beginnt bei 1
  • $iterator->counter0 – Iterationszähler, beginnt bei 0
  • $iterator->odd – Ist diese Iteration ungerade?
  • $iterator->even – ist diese Iteration gerade?
  • $iterator->parent – der Iterator, der den aktuellen Iterator umgibt
  • $iterator->nextValue – das nächste Element in der Schleife
  • $iterator->nextKey – der Schlüssel des nächsten Elements in der Schleife
{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}

Die Latte ist schlau und $iterator->last funktioniert nicht nur für Arrays, sondern auch, wenn die Schleife über einen allgemeinen Iterator läuft, bei dem die Anzahl der Elemente nicht im Voraus bekannt ist.

{first} {last} {sep}

Diese Tags können innerhalb der Schleife {foreach} verwendet werden. Der Inhalt von {first} wird beim ersten Durchlauf gerendert. Der Inhalt von {last} wird gerendert … können Sie es erraten? Ja, für den letzten Durchlauf. Dies sind eigentlich Abkürzungen für {if $iterator->first} und {if $iterator->last}.

Die Tags können auch als n:attributes geschrieben werden:

{foreach $rows as $row}
	{first}<h1>List of names</h1>{/first}

	<p>{$row->name}</p>

	<hr n:last>
{/foreach}

Der Inhalt von {sep} wird wiedergegeben, wenn es sich nicht um die letzte Iteration handelt, und eignet sich daher für die Ausgabe von Begrenzungszeichen, wie z. B. Kommas zwischen aufgelisteten Elementen:

{foreach $items as $item} {$item} {sep}, {/sep} {/foreach}

Das ist doch ziemlich praktisch, oder?

{iterateWhile}

Sie vereinfacht die Gruppierung von linearen Daten während der Iteration in einer foreach-Schleife, indem sie die Iteration in einer verschachtelten Schleife durchführt, solange die Bedingung erfüllt ist. Lesen Sie die Anweisungen im Kochbuch.

Sie kann auch {first} und {last} im obigen Beispiel elegant ersetzen:

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

Wir schreiben den Zyklus genau so wie in PHP:

{for $i = 0; $i < 10; $i++}
	<span>Item #{$i}</span>
{/for}

Das Tag kann auch als n:attribute geschrieben werden:

<h1 n:for="$i = 0; $i < 10; $i++">{$i}</h1>

{while}

Auch hier schreiben wir den Zyklus genau so, wie in PHP:

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

Oder als n:Attribut:

<span n:while="$row = $result->fetch()">
	{$row->title}
</span>

Eine Variante mit einer Bedingung im End-Tag entspricht der do-while-Schleife in PHP:

{while}
	<span>{$item->title}</span>
{/while $item = $item->getNext()}

{continueIf} {skipIf} {breakIf}

Es gibt spezielle Tags, die Sie zur Steuerung jeder Schleife verwenden können – {continueIf ?} und {breakIf ?}, die zur nächsten Iteration springen bzw. die Schleife beenden, wenn die Bedingungen erfüllt sind:

{foreach $rows as $row}
	{continueIf $row->date < $now}
	{breakIf $row->parent === null}
	...
{/foreach}

Das Tag {skipIf} ist dem Tag {continueIf} sehr ähnlich, erhöht aber den Zähler nicht. So gibt es keine Löcher in der Nummerierung, wenn Sie $iterator->counter ausdrucken und einige Elemente überspringen. Auch die {else}-Klausel wird wiedergegeben, wenn Sie alle Elemente überspringen.

<ul>
	{foreach $people as $person}
		{skipIf $person->age < 18}
		<li>{$iterator->counter}. {$person->name}</li>
	{else}
		<li><em>Sorry, no adult users in this list</em></li>
	{/foreach}
</ul>

{exitIf}

Beendet das Rendering einer Vorlage oder eines Blocks, wenn eine Bedingung erfüllt ist (d. h. „early exit“).

{exitIf !$messages}

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

Schablonen einbeziehen

{include 'file.latte'}

Siehe auch {include block}

Der {include} Tag lädt und rendert die angegebene Vorlage. In unserer Lieblingssprache PHP sieht das so aus:

<?php include 'header.phtml'; ?>

Eingebundene Templates haben keinen Zugriff auf die Variablen des aktiven Kontexts, aber sie haben Zugriff auf die globalen Variablen.

Sie können der eingefügten Vorlage auf folgende Weise Variablen übergeben:

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

Der Name der Vorlage kann ein beliebiger PHP-Ausdruck sein:

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

Der eingefügte Inhalt kann durch Filter verändert werden. Im folgenden Beispiel werden alle HTML-Elemente entfernt und die Groß- und Kleinschreibung angepasst:

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

Die Vorlagenvererbung ist standardmäßig nicht daran beteiligt. Sie können zwar Block-Tags zu eingebundenen Vorlagen hinzufügen, diese ersetzen jedoch nicht die passenden Blöcke in der Vorlage, in die sie eingebunden sind. Betrachten Sie Includes als unabhängige und abgeschirmte Teile von Seiten oder Modulen. Dieses Verhalten kann mit dem Modifikator with blocks geändert werden:

{include 'template.latte' with blocks}

Die Beziehung zwischen dem im Tag angegebenen Dateinamen und der Datei auf der Festplatte ist eine Sache des Loaders.

{sandbox}

Wenn Sie eine von einem Endbenutzer erstellte Vorlage einbinden, sollten Sie eine Sandbox verwenden (weitere Informationen finden Sie in der Sandbox-Dokumentation):

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

{block}

Siehe auch {block name}

Blöcke ohne Namen dienen dazu, Filter auf einen Teil der Vorlage anzuwenden. Sie können zum Beispiel einen Streifenfilter anwenden, um überflüssige Leerzeichen zu entfernen:

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

Behandlung von Ausnahmen

{try}

Diese Tags machen es extrem einfach, robuste Vorlagen zu erstellen.

Wenn beim Rendern des {try} -Blocks eine Ausnahme auftritt, wird der gesamte Block verworfen und das Rendern danach fortgesetzt:

{try}
	<ul>
		{foreach $twitter->loadTweets() as $tweet}
  			<li>{$tweet->text}</li>
		{/foreach}
	</ul>
{/try}

Der Inhalt der optionalen Klausel {else} wird nur gerendert, wenn eine Ausnahme auftritt:

{try}
	<ul>
		{foreach $twitter->loadTweets() as $tweet}
  			<li>{$tweet->text}</li>
		{/foreach}
	</ul>
	{else}
	<p>Sorry, the tweets could not be loaded.</p>
{/try}

Der Tag kann auch als n:attribute geschrieben werden:

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

Es ist auch möglich, einen eigenen Exception-Handler für z.B. die Protokollierung zu definieren:

{rollback}

Der Block {try} kann auch manuell mit {rollback} angehalten und übersprungen werden. So müssen Sie nicht alle Eingabedaten im Voraus prüfen und können erst während des Renderings entscheiden, ob es sinnvoll ist, das Objekt zu rendern.

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

Variablen

{var} {default}

Wir werden neue Variablen in der Vorlage mit dem Tag {var} erstellen:

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

{* Mehrfache Deklaration *}
{var $name = 'John Smith', $age = 27}

Das Tag {default} funktioniert ähnlich, mit dem Unterschied, dass es Variablen nur dann anlegt, wenn sie nicht existieren:

{default $lang = 'cs'}

Sie können auch Typen von Variablen angeben. Im Moment sind sie informativ und Latte prüft sie nicht.

{var string $name = $article->getTitle()}
{default int $id = 0}

{parameters}

So wie eine Funktion ihre Parameter deklariert, kann eine Vorlage ihre Variablen am Anfang deklarieren:

{parameters
	$a,
	?int $b,
	int|string $c = 10
}

Die Variablen $a und $b ohne Standardwert haben automatisch den Standardwert null. Die deklarierten Typen sind immer noch informativ, und Latte überprüft sie nicht.

Andere als die deklarierten Variablen werden nicht an die Vorlage übergeben. Dies ist ein Unterschied zum Tag {default}.

{capture}

Mit dem Tag {capture} können Sie die Ausgabe in einer Variablen erfassen:

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

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

Der Tag kann auch als n:attribute geschrieben werden, wie jeder paarweise Tag:

<ul n:capture="$var">
	<li>Hello World</li>
</ul>

Die HTML-Ausgabe wird in der Variablen $var als Latte\Runtime\Html -Objekt gespeichert, um unerwünschtes Escaping beim Drucken zu vermeiden.

Andere

{contentType}

Verwenden Sie das Tag, um anzugeben, welche Art von Inhalt die Vorlage darstellt. Die Optionen sind:

  • html (Standardtyp)
  • xml
  • javascript
  • css
  • calendar (iCal)
  • text

Die Verwendung dieses Befehls ist wichtig, weil er die kontextabhängige Escape-Funktion einstellt und nur dann kann Latte korrekt escapen. Zum Beispiel schaltet {contentType xml} in den XML-Modus, {contentType text} schaltet das Escapen komplett ab.

Handelt es sich bei dem Parameter um einen MIME-Typ mit vollem Funktionsumfang, wie z. B. application/xml, so wird auch ein HTTP-Header Content-Type an den Browser gesendet:

{contentType application/xml}
<?xml version="1.0"?>
<rss version="2.0">
	<channel>
		<title>RSS feed</title>
		<item>
			...
		</item>
	</channel>
</rss>

{debugbreak}

Gibt die Stelle an, an der die Codeausführung unterbrochen wird. Sie wird zu Debugging-Zwecken verwendet, damit der Programmierer die Laufzeitumgebung überprüfen und sicherstellen kann, dass der Code wie erwartet ausgeführt wird. Er unterstützt Xdebug. Zusätzlich können Sie eine Bedingung angeben, unter der der Code unterbrochen werden soll.

{debugbreak}                {* bricht das Programm *}

{debugbreak $counter == 1}  {* bricht das Programm ab, wenn die Bedingung erfüllt ist *}

{do}

Führt den PHP-Code aus und gibt nichts aus. Wie bei allen anderen Tags ist der PHP-Code ein einzelner Ausdruck, siehe PHP-Einschränkungen.

{do $num++}

{dump}

Gibt eine Variable oder den aktuellen Kontext aus.

{dump $name} {* gibt die Variable $name aus *}

{dump}       {* gibt alle definierten Variablen aus *}

Erfordert das Paket Tracy.

{php}

Ermöglicht die Ausführung von beliebigem PHP-Code. Das Tag muss mit der Erweiterung RawPhpExtension aktiviert werden.

{spaceless}

Entfernt unnötige Leerzeichen. Ähnlich wie der raumlose Filter.

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

Ausgaben:

<ul> <li>Hello</li> </ul>

Der Tag kann auch als n:attribute geschrieben werden:

{syntax}

Latten-Tags müssen nicht nur in geschweifte Klammern eingeschlossen werden. Sie können ein anderes Trennzeichen wählen, auch zur Laufzeit. Dies geschieht durch {syntax…}, wobei der Parameter sein kann:

  • double: {{...}}
  • off: deaktiviert die Latte-Tags vollständig

Mit der Notation n:attribute können wir Latte nur für einen JavaScript-Block deaktivieren:

<script n:syntax="off">
	var obj = {var: 123}; // this isn't a tag any more
</script>

Latte kann sehr bequem innerhalb von JavaScript verwendet werden, man sollte nur Konstrukte wie in diesem Beispiel vermeiden, bei denen der Buchstabe unmittelbar auf { folgt, siehe Latte innerhalb von JavaScript oder CSS.

Wenn Sie Latte mit dem {syntax off} (d.h. Tag, nicht das n:-Attribut) ausschalten, werden alle Tags bis zu {/syntax} strikt ignoriert.

{trace}

Wirft eine Latte\RuntimeException Exception, deren Stack-Trace im Sinne der Templates ist. Anstatt Funktionen und Methoden aufzurufen, werden also Blöcke aufgerufen und Vorlagen eingefügt. Wenn Sie ein Tool zur übersichtlichen Darstellung von geworfenen Ausnahmen wie Tracy verwenden, sehen Sie deutlich den Aufrufstapel, einschließlich aller übergebenen Argumente.

HTML-Tag-Hilfsmittel

n:class

Dank n:class ist es sehr einfach, das HTML-Attribut class genau so zu generieren, wie Sie es brauchen.

Beispiel: Ich möchte, dass das aktive Element die Klasse active hat:

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

Außerdem muss das erste Element die Klassen first und main haben:

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

Und alle Elemente sollten die Klasse list-item haben:

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

Verblüffend einfach, nicht wahr?

n:attr

Das Attribut n:attr kann beliebige HTML-Attribute mit der gleichen Eleganz wie n:class erzeugen.

{foreach $data as $item}
	<input type="checkbox" n:attr="value: $item->getValue(), checked: $item->isActive()">
{/foreach}

Abhängig von den zurückgegebenen Werten zeigt es z. B:

<input type="checkbox">

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

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

n:tag

Das Attribut n:tag kann den Namen eines HTML-Elements dynamisch ändern.

<h1 n:tag="$heading" class="main">{$title}</h1>

Wenn $heading === null, wird das <h1> Tag ohne Änderung gedruckt. Andernfalls wird der Elementname in den Wert der Variablen geändert, so dass für $heading === 'h3' geschrieben wird:

<h3 class="main">...</h3>

Da es sich bei Latte um ein sicheres Templating-System handelt, wird überprüft, ob der neue Tag-Name gültig ist und keine unerwünschten oder bösartigen Werte enthält.

n:ifcontent

Verhindert, dass ein leeres HTML-Element gedruckt wird, d.h. ein Element, das nichts als Leerraum enthält.

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

Abhängig von den Werten der Variablen $error wird dies gedruckt:

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

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

Übersetzung

Damit die Übersetzungs-Tags funktionieren, müssen Sie den Übersetzer ein richten. Sie können auch den translate Filter für die Übersetzung verwenden.

{_...}

Übersetzt Werte in andere Sprachen.

<a href="basket">{_'Basket'}</a>
<span>{_$item}</span>

Es können auch andere Parameter an den Übersetzer übergeben werden:

<a href="basket">{_'Basket', domain: order}</a>

{translate}

Překládá části šablony:

<h1>{translate}Order{/translate}</h1>

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

Der Tag kann auch als n:attribute geschrieben werden, um das Innere des Elements zu übersetzen:

<h1 n:translate>Order</h1>