Latte Tags

Überblick und Beschreibung aller Tags (oder Makros), die Ihnen standardmäßig im Latte-Templating-System zur Verfügung stehen.

Ausgabe

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

In Latte wird das Tag {=...} verwendet, um einen beliebigen Ausdruck in die Ausgabe zu schreiben. Latte legt Wert auf Ihren Komfort, daher müssen Sie kein Gleichheitszeichen schreiben, wenn der Ausdruck mit einer Variablen oder einem Funktionsaufruf beginnt. Das bedeutet in der Praxis, dass Sie es fast nie schreiben müssen:

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

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

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

Bitte suchen Sie im vorherigen Beispiel keinen Sinn, aber wenn Sie einen finden, schreiben Sie uns :-)

Escaping der Ausgabe

Was ist die wichtigste Aufgabe eines Templating-Systems? Sicherheitslücken zu verhindern. Und genau das tut Latte immer, wenn Sie etwas ausgeben. Es maskiert es automatisch:

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

Um genau zu sein, verwendet Latte kontextsensitives Escaping, was eine so wichtige und einzigartige Sache ist, dass wir ihr ein separates Kapitel gewidmet haben.

Und was ist, wenn Sie HTML-kodierten Inhalt aus einer vertrauenswürdigen Quelle ausgeben? Dann können Sie das Escaping einfach deaktivieren:

{$trustedHtmlString|noescape}

Eine falsche Verwendung des noescape-Filters kann zu einer XSS-Schwachstelle führen! Verwenden Sie ihn niemals, wenn Sie sich nicht absolut sicher sind, was Sie tun und dass die ausgegebene Zeichenkette aus einer vertrauenswürdigen Quelle stammt.

Ausgabe in JavaScript

Dank des kontextsensitiven Escapings ist es wunderbar einfach, Variablen innerhalb von JavaScript auszugeben, und Latte kümmert sich um das korrekte Escaping.

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

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

Erzeugt:

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

Dies ist auch der Grund, warum um die Variable keine Anführungszeichen geschrieben werden: Latte fügt sie bei Zeichenketten selbst hinzu. Und wenn Sie eine Zeichenkettenvariable in eine andere Zeichenkette einfügen möchten, verbinden Sie sie einfach:

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

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

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

Filter

Der ausgegebene Ausdruck kann durch einen Filter modifiziert werden. So konvertieren wir beispielsweise eine Zeichenkette in Großbuchstaben und kürzen sie auf maximal 30 Zeichen:

{$string|upper|truncate:30}

Sie können Filter auch auf Teilausdrücke anwenden:

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

Bedingungen

{if} {elseif} {else}

Bedingungen verhalten sich genauso wie ihre Gegenstücke in PHP. Sie können darin dieselben Ausdrücke verwenden, die Sie aus PHP kennen, Sie müssen keine neue Sprache lernen.

{if $product->inStock > Stock::Minimum}
	Auf Lager
{elseif $product->isOnWay()}
	Unterwegs
{else}
	Nicht verfügbar
{/if}

Wie jedes gepaarte Tag kann auch das Paar {if} ... {/if} als n:Attribut geschrieben werden, zum Beispiel:

<p n:if="$count > 0">{$count} Stück auf Lager</p>

Wussten Sie, dass Sie n:Attributen das Präfix tag- hinzufügen können? Dann gilt die Bedingung nur für die Ausgabe der HTML-Tags, und der Inhalt dazwischen wird immer ausgegeben:

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

{* gibt 'Hallo' aus, wenn $clickable falsch ist *}
{* gibt '<a href="...">Hallo</a>' aus, wenn $clickable wahr ist *}

Genial.

n:else

Wenn Sie die Bedingung {if} ... {/if} als n:Attribut schreiben, haben Sie die Möglichkeit, einen alternativen Zweig mit n:else anzugeben:

<strong n:if="$count > 0">{$count} Stück auf Lager</strong>

<em n:else>nicht verfügbar</em>

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

{/if $cond}

Vielleicht überrascht es Sie, dass der Ausdruck in der Bedingung {if} auch im schließenden Tag angegeben werden kann. Dies ist nützlich in Situationen, in denen wir beim Öffnen der Bedingung ihren Wert noch nicht kennen. Nennen wir es eine aufgeschobene Entscheidung.

Zum Beispiel beginnen wir mit der Ausgabe einer Tabelle mit Datensätzen aus der Datenbank und stellen erst nach Abschluss der Ausgabe fest, dass keine Datensätze in der Datenbank vorhanden waren. Also fügen wir die Bedingung in das schließende Tag {/if} ein, und wenn keine Datensätze vorhanden sind, wird nichts davon ausgegeben:

{if}
	<h1>Auflistung der Zeilen aus der Datenbank</h1>

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

Praktisch, nicht wahr?

In der aufgeschobenen Bedingung kann auch {else} verwendet werden, jedoch nicht {elseif}.

{ifset} {elseifset}

Siehe auch {ifset block}

Mit der Bedingung {ifset $var} prüfen wir, ob eine Variable (oder mehrere Variablen) existiert und einen nicht-null-Wert hat. Es ist eigentlich dasselbe wie if (isset($var)) in PHP. Wie jedes gepaarte Tag kann es auch als n:Attribut geschrieben werden, also zeigen wir es als Beispiel:

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

{ifchanged}

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

Wenn wir eine oder mehrere Variablen im Tag angeben, prüft es, ob sich eine von ihnen geändert hat, und gibt den Inhalt entsprechend aus. Zum Beispiel gibt das folgende Beispiel den ersten Buchstaben des Namens als Überschrift aus, wann immer er sich bei der Ausgabe von Namen ändert:

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

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

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

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

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

Innerhalb von {ifchanged} kann auch eine {else}-Klausel angegeben werden.

{switch} {case} {default}

Vergleicht einen Wert mit mehreren Optionen. Es ist analog zur bedingten Anweisung switch, die Sie aus PHP kennen. Latte verbessert sie jedoch:

• verwendet strikten Vergleich (===)
• benötigt kein break

Es ist also das genaue Äquivalent zur match-Struktur, die mit PHP 8.0 eingeführt wurde.

{switch $transport}
	{case train}
		Mit dem Zug
	{case plane}
		Mit dem Flugzeug
	{default}
		Anderweitig
{/switch}

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

{switch $status}
{case $status::New}<b>neuer Eintrag</b>
{case $status::Sold, $status::Unknown}<i>nicht verfügbar</i>
{/switch}

Schleifen

In Latte finden Sie alle Schleifen, die Sie aus PHP kennen: foreach, for und while.

{foreach}

Die Schleife wird genauso geschrieben wie in PHP:

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

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

Latte prüft beispielsweise, ob die erstellten Variablen versehentlich globale Variablen gleichen Namens überschreiben. Dies rettet Situationen, in denen Sie davon ausgehen, dass $lang die aktuelle Sprache der Seite ist, und nicht erkennen, dass foreach $langs as $lang diese Variable überschrieben hat.

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

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

Wussten Sie, dass Sie n:Attributen das Präfix inner- hinzufügen können? Dann wird nur der innere Teil des Elements in der Schleife wiederholt:

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

Es wird also etwa Folgendes ausgegeben:

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

{else}

Innerhalb der foreach-Schleife kann eine {else}-Klausel angegeben werden, deren Inhalt angezeigt wird, wenn die Schleife leer ist:

<ul>
	{foreach $people as $person}
		<li>{$person->name}</li>
	{else}
		<li><em>Leider befinden sich keine Benutzer in dieser Liste</em></li>
	{/foreach}
</ul>

$iterator

Innerhalb der foreach-Schleife erstellt Latte die Variable $iterator, mit der wir nützliche Informationen über die laufende Schleife abrufen können:

• $iterator->first – ist es der erste Durchlauf der Schleife?
• $iterator->last – ist es der letzte Durchlauf?
• $iterator->counter – der wievielte Durchlauf ist es, gezählt ab eins?
• $iterator->counter0 – der wievielte Durchlauf ist es, gezählt ab null?
• $iterator->odd – ist es ein ungerader Durchlauf?
• $iterator->even – ist es ein gerader Durchlauf?
• $iterator->parent – der Iterator, der den aktuellen umschließt
• $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}

Latte ist schlau und $iterator->last funktioniert nicht nur bei 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 {foreach}-Schleife verwendet werden. Der Inhalt von {first} wird gerendert, wenn es der erste Durchlauf ist. Der Inhalt von {last} wird gerendert… erraten Sie es? Ja, wenn es der letzte Durchlauf ist. Es handelt sich eigentlich um Abkürzungen für {if $iterator->first} und {if $iterator->last}.

Die Tags können auch elegant als n:Attribut verwendet werden:

{foreach $rows as $row}
	{first}<h1>Liste der Namen</h1>{/first}

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

	<hr n:last>
{/foreach}

Der Inhalt des Tags {sep} wird gerendert, wenn der Durchlauf nicht der letzte ist. Er eignet sich daher zum Rendern von Trennzeichen, z. B. Kommas zwischen den ausgegebenen Elementen:

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

Das ist ziemlich praktisch, nicht wahr?

{iterateWhile}

Vereinfacht die Gruppierung linearer Daten während der Iteration in einer foreach-Schleife, indem die Iteration in einer verschachtelten Schleife durchgeführt wird, solange die Bedingung erfüllt ist. Lesen Sie die detaillierte Anleitung.

Es kann auch elegant {first} und {last} im obigen Beispiel 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}

Siehe auch die Filter batch und group.

{for}

Die Schleife wird genauso geschrieben wie in PHP:

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

Das Tag kann auch als n:Attribut verwendet werden:

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

{while}

Die Schleife wird wiederum genauso geschrieben 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>

Es ist auch eine Variante mit einer Bedingung im schließenden Tag möglich, die der do-while-Schleife in PHP entspricht:

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

{continueIf} {skipIf} {breakIf}

Zur Steuerung jeder Schleife können die Tags {continueIf ?} und {breakIf ?} verwendet werden, die zum nächsten Element wechseln bzw. die Schleife beenden, wenn die Bedingung erfüllt ist:

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

Das Tag {skipIf} ist {continueIf} sehr ähnlich, erhöht jedoch nicht den Zähler $iterator->counter. Wenn wir ihn also ausgeben und gleichzeitig einige Elemente überspringen, entstehen keine Lücken in der Nummerierung. Auch die {else}-Klausel wird gerendert, wenn wir alle Elemente überspringen.

<ul>
	{foreach $people as $person}
		{skipIf $person->age < 18}
		<li>{$iterator->counter}. {$person->name}</li>
	{else}
		<li><em>Leider befinden sich keine Erwachsenen in dieser Liste</em></li>
	{/foreach}
</ul>

{exitIf}

Beendet das Rendern des Templates oder Blocks, wenn die Bedingung erfüllt ist (sog. “early exit”).

{exitIf !$messages}

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

Template einfügen

{include 'file.latte'}

Siehe auch {include block}

Das Tag {include} lädt und rendert das angegebene Template. Wenn wir in der Sprache unserer Lieblingssprache PHP sprechen würden, wäre das so etwas wie:

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

Eingefügte Templates haben keinen Zugriff auf die Variablen des aktiven Kontexts, sie haben nur Zugriff auf globale Variablen.

Sie können Variablen auf diese Weise an das eingefügte Template übergeben:

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

Der Template-Name kann ein beliebiger PHP-Ausdruck sein:

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

Der eingefügte Inhalt kann mithilfe von Filtern modifiziert werden. Das folgende Beispiel entfernt sämtliches HTML und passt die Groß-/Kleinschreibung an:

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

Standardmäßig spielt die Template-Vererbung in diesem Fall keine Rolle. Obwohl wir Blöcke im inkludierten Template verwenden können, werden die entsprechenden Blöcke im Template, in das inkludiert wird, nicht ersetzt. Stellen Sie sich inkludierte Templates als separate, abgeschirmte Teile von Seiten oder Modulen vor. 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 Sache des Loaders.

{sandbox}

Beim Einfügen eines vom Endbenutzer erstellten Templates sollten Sie den Sandbox-Modus in Betracht ziehen (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 als Möglichkeit, Filter auf einen Teil des Templates anzuwenden. Zum Beispiel kann so der Filter strip angewendet werden, der überflüssige Leerzeichen entfernt:

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

Ausnahmebehandlung

{try}

Dank dieses Tags ist es extrem einfach, robuste Templates zu erstellen.

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

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

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

{try}
	<ul>
		{foreach $twitter->loadTweets() as $tweet}
  			<li>{$tweet->text}</li>
		{/foreach}
	</ul>
	{else}
	<p>Leider konnten die Tweets nicht geladen werden.</p>
{/try}

Das Tag kann auch als n:Attribut verwendet werden:

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

Es ist auch möglich, einen eigenen Ausnahme-Handler zu definieren, zum Beispiel für die Protokollierung.

{rollback}

Der {try}-Block kann auch manuell mit {rollback} gestoppt und übersprungen werden. Dadurch müssen Sie nicht alle Eingabedaten im Voraus überprüfen, sondern können erst während des Renderns entscheiden, dass Sie das Objekt überhaupt nicht rendern möchten:

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

Variablen

{var} {default}

Neue Variablen erstellen wir im Template mit dem Tag {var}:

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

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

Das Tag {default} funktioniert ähnlich, erstellt Variablen jedoch nur dann, wenn sie nicht existieren. Wenn die Variable bereits existiert und den Wert null enthält, wird sie nicht überschrieben:

{default $lang = 'de'}

Sie können auch Variablentypen angeben. Diese sind vorerst informativ und werden von Latte nicht überprüft.

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

{parameters}

So wie eine Funktion ihre Parameter deklariert, kann auch ein Template am Anfang seine Variablen deklarieren:

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

Die Variablen $a und $b ohne angegebenen Standardwert haben automatisch den Standardwert null. Die deklarierten Typen sind vorerst informativ und werden von Latte nicht überprüft.

Andere als die deklarierten Variablen werden nicht an das Template übergeben. Dies unterscheidet sich vom Tag {default}.

{capture}

Fängt die Ausgabe in einer Variablen ab:

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

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

Das Tag kann, wie jedes gepaarte Tag, auch als n:Attribut geschrieben werden:

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

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

Sonstiges

{contentType}

Mit diesem Tag geben Sie an, welchen Inhaltstyp das Template darstellt. Die Optionen sind:

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

Seine Verwendung ist wichtig, da es das kontextsensitive Escaping festlegt und nur so korrekt maskieren kann. Zum Beispiel schaltet {contentType xml} in den XML-Modus, {contentType text} deaktiviert das Escaping vollständig.

Wenn der Parameter ein vollwertiger MIME-Typ ist, wie z. B. application/xml, sendet er zusätzlich den HTTP-Header Content-Type an den Browser:

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

{debugbreak}

Markiert eine Stelle, an der die Programmausführung angehalten und der Debugger gestartet wird, damit der Programmierer die Laufzeitumgebung überprüfen und feststellen kann, ob das Programm wie erwartet funktioniert. Unterstützt Xdebug. Es kann eine Bedingung hinzugefügt werden, die bestimmt, wann das Programm angehalten werden soll.

{debugbreak}                {* hält das Programm an *}

{debugbreak $counter == 1}  {* hält das Programm an, wenn die Bedingung erfüllt ist *}

{do}

Führt PHP-Code aus und gibt nichts aus. Wie bei allen anderen Tags bedeutet PHP-Code ein einzelner Ausdruck, siehe PHP-Beschränkungen.

{do $num++}

{dump}

Gibt eine Variable oder den aktuellen Kontext aus.

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

{dump}       {* Gibt alle aktuell definierten Variablen aus *}

Erfordert die Bibliothek Tracy.

{php}

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

{spaceless}

Entfernt überflüssigen Leerraum aus der Ausgabe. Funktioniert ähnlich wie der Filter spaceless.

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

Erzeugt:

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

Das Tag kann auch als n:Attribut geschrieben werden.

{syntax}

Latte-Tags müssen nicht nur in einfache geschweifte Klammern eingeschlossen sein. Wir können auch einen anderen Trenner wählen, sogar zur Laufzeit. Dazu dient {syntax …}, wobei als Parameter angegeben werden kann:

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

Mit n:Attributen kann Latte beispielsweise nur für einen JavaScript-Block deaktiviert werden:

<script n:syntax="off">
	var obj = {var: 123}; // dies ist kein Tag mehr
</script>

Latte kann sehr bequem innerhalb von JavaScript verwendet werden, man muss nur Konstruktionen wie in diesem Beispiel vermeiden, bei denen ein Buchstabe direkt auf { folgt, siehe Latte innerhalb von JavaScript oder CSS.

Wenn Sie Latte mit {syntax off} (d. h. mit dem Tag, nicht mit dem n:Attribut) deaktivieren, werden alle Tags bis {/syntax} konsequent ignoriert.

{trace}

Wirft eine Latte\RuntimeException, deren Stack Trace im Sinne von Templates aufgebaut ist. Das heißt, anstelle von Funktions- und Methodenaufrufen enthält er Aufrufe von Blöcken und das Einfügen von Templates. Wenn Sie ein Werkzeug zur übersichtlichen Anzeige geworfener Ausnahmen verwenden, wie z. B. Tracy, wird Ihnen der Call Stack einschließlich aller übergebenen Argumente übersichtlich angezeigt.

HTML-Codierer-Helfer

n:class

Dank n:class ist es sehr einfach, das HTML-Attribut class genau nach Ihren Vorstellungen zu generieren.

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

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

Und außerdem soll 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 sollen die Klasse list-item haben:

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

Erstaunlich einfach, nicht wahr?

n:attr

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

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

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

<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 ist, wird das Tag <h1> unverändert ausgegeben. Andernfalls wird der Name des Elements in den Wert der Variablen geändert, sodass für $heading === 'h3' Folgendes ausgegeben wird:

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

Da Latte ein sicheres Templating-System ist, prüft es, ob der neue Tag-Name gültig ist und keine unerwünschten oder schädlichen Werte enthält.

n:ifcontent

Verhindert, dass ein leeres HTML-Element ausgegeben wird, d. h. ein Element, das nichts außer Leerzeichen enthält.

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

Gibt abhängig vom Wert der Variablen $error aus:

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

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

Übersetzungen

Damit die Übersetzungs-Tags funktionieren, muss der Übersetzer aktiviert werden. Für die Übersetzung können Sie auch den Filter translate verwenden.

{_...}

Übersetzt Werte in andere Sprachen.

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

Dem Übersetzer können auch weitere Parameter übergeben werden:

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

{translate}

Übersetzt Teile des Templates:

<h1>{translate}Bestellung{/translate}</h1>

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

Das Tag kann auch als n:Attribut geschrieben werden, um den Inhalt des Elements zu übersetzen:

<h1 n:translate>Bestellung</h1>

`latte