Latte-Tags

Übersicht und Beschreibung aller Tags, die im Templating-System Latte standardmäßig zur Verfügung stehen.

Ausgabe

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

In Latte dient der Tag {=...} dazu, einen beliebigen Ausdruck auszugeben. Latte ist auf Ihren Komfort bedacht: Beginnt der Ausdruck mit einer Variablen oder einem Funktionsaufruf, brauchen Sie das Gleichheitszeichen nicht zu schreiben. In der Praxis heißt das, dass es fast nie nötig ist:

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

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

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

Bitte suchen Sie im vorigen Beispiel keinen Sinn, aber falls Sie einen finden, sagen Sie uns Bescheid :-)

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 escapt die Ausgabe automatisch:

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

Genauer gesagt verwendet Latte kontextsensitives Escaping, eine so wichtige und einzigartige Eigenschaft, dass wir ihr ein eigenes Kapitel gewidmet haben.

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

{$trustedHtmlString|noescape}

Ein falscher Einsatz des Filters noescape kann zu einer XSS-Sicherheitslücke führen! Verwenden Sie ihn niemals, wenn Sie sich nicht absolut sicher sind, was Sie tun und dass der ausgegebene String aus einer vertrauenswürdigen Quelle stammt.

Ausgabe in JavaScript

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

Die Variable muss kein String sein, unterstützt wird jeder Datentyp, der dann als JSON kodiert wird:

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

Erzeugt:

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

Genau deshalb dürfen Sie um die Variable keine Anführungszeichen schreiben: Bei Strings ergänzt Latte sie automatisch. Und wenn Sie eine String-Variable in einen anderen String einfügen möchten, verketten Sie beide einfach:

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

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

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

Filter

Der ausgegebene Ausdruck lässt sich mit Filtern verändern. So wandeln wir zum Beispiel einen String in Großbuchstaben um und kürzen ihn auf maximal 30 Zeichen:

{$string|upper|truncate:30}

Filter lassen sich auch auf Teile eines Ausdrucks anwenden:

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

Bedingungen

{if} {elseif} {else}

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

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

Wie jeder Paar-Tag lässt sich auch das Paar {if} ... {/if} als n:Attribut schreiben, zum Beispiel:

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

Wussten Sie, dass Sie n:Attributen das Präfix tag- voranstellen können? Dann betrifft die Bedingung nur die Ausgabe der HTML-Tags, der Inhalt dazwischen wird immer ausgegeben:

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

{* gibt 'Hello' aus, wenn $clickable falsy ist *}
{* gibt '<a href="...">Hello</a>' aus, wenn $clickable truthy ist *}

Großartig.

n:else n:elseif

Wenn Sie die Bedingung {if} ... {/if} als n:Attribut schreiben, können Sie mit n:else (seit 3.0.12) und n:elseif (seit 3.1) alternative Zweige angeben:

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

<em n:elseif="$count < 0">Ungültige Anzahl</em>

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

Das Attribut n:else lässt sich auch zusammen mit n:ifset, n:foreach, n:try, n:ifcontent und n:ifchanged verwenden.

{/if $cond}

Es mag Sie überraschen, dass sich der Ausdruck der Bedingung {if} auch im schließenden Tag angeben lässt. Das ist in Situationen nützlich, in denen wir seinen Wert beim Öffnen der Bedingung noch nicht kennen. Nennen wir es eine aufgeschobene Entscheidung.

Zum Beispiel beginnen wir, eine Tabelle mit Datensätzen aus der Datenbank auszugeben, und erst nach Abschluss der Ausgabe stellen wir fest, dass in der Datenbank gar keine Datensätze waren. Wir setzen die Bedingung also in den schließenden Tag {/if}, und wenn es keine Datensätze gibt, wird nichts davon ausgegeben:

{if}
	<h1>Liste der Datensätze aus der Datenbank</h1>

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

Praktisch, oder?

In der aufgeschobenen Bedingung lässt sich auch {else} verwenden, nicht aber {elseif}.

{ifset} {elseifset}

Siehe auch {ifset block}

Mit der Bedingung {ifset $var} stellen wir fest, ob eine Variable (oder mehrere Variablen) existiert und einen Wert ungleich null hat. Es ist eigentlich dasselbe wie if (isset($var)) in PHP. Wie jeder Paar-Tag lässt sie sich auch als n:Attribut schreiben, zeigen wir es also an einem Beispiel:

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

{ifchanged}

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

Wenn wir im Tag eine oder mehrere Variablen angeben, prüft er, ob sich eine davon geändert hat, und gibt den Inhalt entsprechend aus. Das folgende Beispiel gibt bei der Ausgabe von Namen jedes Mal, wenn sich der erste Buchstabe ändert, diesen als Überschrift aus:

{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 selbst mit seinem vorherigen Zustand verglichen. Das bedeutet, dass wir im vorigen Beispiel das Argument im Tag gefahrlos weglassen können. Und natürlich lässt sich auch ein n:Attribut verwenden:

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

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

Innerhalb von {ifchanged} lässt sich auch eine {else}-Klausel verwenden.

{switch} {case} {default}

Vergleicht einen Wert mit mehreren Möglichkeiten. Das ähnelt der aus PHP bekannten Konstruktion switch. Latte verbessert sie allerdings:

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

Es entspricht damit weitgehend der Struktur match, die PHP 8.0 eingeführt hat.

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

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

{switch $status}
{case $status::New}<b>neuer Artikel</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 schreiben Sie genauso wie in PHP:

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

Darüber hinaus hat sie einige praktische Fähigkeiten, über die wir jetzt sprechen.

Latte prüft zum Beispiel, ob die erzeugten Variablen nicht versehentlich gleichnamige globale Variablen überschreiben. Das bewahrt Sie vor Situationen, in denen Sie erwarten, dass $lang die aktuelle Sprache der Seite enthält, und dabei übersehen, dass foreach $langs as $lang diese Variable überschrieben hat.

Die foreach-Schleife lässt sich auch sehr elegant und sparsam als n:Attribut schreiben:

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

Wussten Sie, dass Sie n:Attributen das Präfix inner- voranstellen können? Dann wiederholt die Schleife nur den inneren Teil des Elements:

<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 lässt sich eine {else}-Klausel angeben, deren Inhalt angezeigt wird, wenn die Schleife leer ist:

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

$iterator

Innerhalb der foreach-Schleife erzeugt Latte die Variable $iterator, über die wir nützliche Informationen über die laufende Schleife erfahren:

• $iterator->first – ist es die erste Iteration?
• $iterator->last – ist es die letzte Iteration?
• $iterator->counter – Zähler der Iterationen, beginnt bei eins
• $iterator->counter0 – Zähler der Iterationen, beginnt bei null
• $iterator->odd – ist es eine ungerade Iteration?
• $iterator->even – ist es eine gerade Iteration?
• $iterator->parent – der Iterator, der den aktuellen umgibt
• $iterator->nextValue – das nächste Element der Schleife
• $iterator->nextKey – der Schlüssel des nächsten Elements 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 clever, und $iterator->last funktioniert nicht nur bei Arrays, sondern auch dann, wenn die Schleife über einen allgemeinen Iterator läuft, bei dem die Anzahl der Elemente vorab nicht bekannt ist.

{first} {last} {sep}

Diese Tags lassen sich innerhalb der Schleife {foreach} verwenden. Der Inhalt von {first} wird gerendert, wenn es die erste Iteration ist. Der Inhalt von {last} wird gerendert … erraten Sie es? Ja, wenn es die letzte Iteration ist. Es handelt sich eigentlich um Abkürzungen für {if $iterator->first} und {if $iterator->last}.

Die Tags lassen sich auch elegant als n:Attribute verwenden:

{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 die Iteration nicht die letzte ist. Er eignet sich daher für die Ausgabe von Trennzeichen, etwa Kommas zwischen den aufgezählten Elementen:

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

Ziemlich praktisch, oder?

{iterateWhile}

Vereinfacht das Gruppieren linearer Daten beim Iterieren in einer foreach-Schleife, indem die Iteration in einer verschachtelten Schleife läuft, solange die Bedingung erfüllt ist. Lesen Sie die ausführliche Anleitung.

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

Siehe auch die Filter batch und group.

{for}

Die Schleife schreiben wir genauso wie in PHP:

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

Der Tag lässt sich auch als n:Attribut schreiben:

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

{while}

Auch diese Schleife schreiben wir genauso 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>

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

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

{continueIf} {skipIf} {breakIf}

Mit den speziellen Tags {continueIf ?} und {breakIf ?} lässt sich jede Schleife steuern. Sie springen zur nächsten Iteration bzw. beenden die Schleife, wenn die Bedingung erfüllt ist:

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

Der Tag {skipIf} ist {continueIf} sehr ähnlich, erhöht aber den $iterator->counter nicht. Dadurch entstehen keine Lücken in der Nummerierung, wenn Sie den Zähler ausgeben und einige Elemente überspringen. Außerdem wird die {else}-Klausel gerendert, wenn alle Elemente übersprungen werden.

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

{exitIf}

Beendet das Rendern eines Templates oder Blocks, wenn eine Bedingung erfüllt ist (also ein “early exit”).

{exitIf !$messages}

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

Einbinden von Templates

{include 'file.latte'}

Siehe auch {include block} und {embed}

Der Tag {include} lädt das angegebene Template und rendert es. In unserer geliebten Sprache PHP entspricht das etwa:

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

Eingebundene Templates haben keinen Zugriff auf die Variablen des aktiven Kontexts, wohl aber auf globale Variablen.

Variablen übergeben Sie dem eingebundenen Template so:

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

Der Name des Templates kann ein beliebiger PHP-Ausdruck sein:

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

Ob ein Template existiert, lässt sich mit der Funktion hasTemplate() prüfen.

Der eingebundene Inhalt lässt sich mit Filtern verändern. Das folgende Beispiel entfernt sämtliches HTML und ändert die Groß-/Kleinschreibung:

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

Die Template-Vererbung spielt dabei standardmäßig keine Rolle. Sie können in eingebundenen Templates zwar Blöcke verwenden, sie ersetzen aber nicht die entsprechenden Blöcke in dem Template, in das sie eingebunden werden. Stellen Sie sich eingebundene Templates als eigenständige, abgeschirmte Teile von Seiten oder Modulen vor. Dieses Verhalten lässt sich mit dem Modifikator with blocks ändern:

{include 'template.latte' with blocks}

Die Beziehung zwischen dem im Tag angegebenen Dateinamen und der Datei auf der Festplatte hängt vom Loader ab.

{sandbox}

Wenn Sie ein Template einbinden, das ein Endbenutzer erstellt hat, sollten Sie es in einer Sandbox ausführen (mehr dazu in der Dokumentation zur Sandbox):

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

{block}

Siehe auch {block name}

Blöcke ohne Namen bieten die Möglichkeit, Filter auf einen Teil des Templates anzuwenden. So können Sie zum Beispiel den Filter spaceless anwenden, der überflüssige Leerzeichen entfernt:

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

Behandlung von Exceptions

{try}

Dank dieses Tags lassen sich äußerst robuste Templates erstellen.

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

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

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

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

Der Tag lässt sich auch als n:Attribut schreiben:

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

Es ist auch möglich, einen eigenen Exception-Handler zu definieren, zum Beispiel zum Loggen.

{rollback}

Der {try}-Block lässt sich mit {rollback} auch manuell anhalten und überspringen. So müssen Sie nicht alle Eingabedaten im Voraus prüfen und können erst beim Rendern entscheiden, dass das Objekt überhaupt nicht gerendert werden soll:

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

Variablen

{var} {default}

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

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

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

Der Tag {default} funktioniert ähnlich, erzeugt die Variablen aber nur dann, wenn sie noch nicht existieren. Existiert eine Variable bereits und enthält den Wert null, wird sie nicht überschrieben:

{default $lang = 'en'}

Sie können auch Typen von Variablen angeben. Vorerst sind sie nur informativ, Latte prüft sie nicht.

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

{parameters}

So wie eine Funktion ihre Parameter deklariert, kann 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 nur informativ, Latte prüft sie nicht.

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

{capture}

Fängt die Ausgabe in eine Variable ab:

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

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

Wie jeder Paar-Tag lässt sich auch dieser Tag als n:Attribut schreiben:

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

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

Sonstiges

{contentType}

Mit diesem Tag geben Sie an, welchen Typ von Inhalt das Template darstellt. Zur Auswahl stehen:

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

Seine Verwendung ist wichtig, weil er das kontextsensitive Escaping festlegt und Latte erst dann korrekt escapen kann. Zum Beispiel schaltet {contentType xml} in den XML-Modus, {contentType text} schaltet das Escaping vollständig ab.

Ist der Parameter ein vollständiger MIME-Typ, etwa 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}

Gibt die Stelle an, an der die Programmausführung angehalten wird. Er dient dem Debugging und erlaubt es dem Programmierer, die Laufzeitumgebung zu untersuchen und sicherzustellen, dass der Code wie erwartet läuft. Unterstützt wird Xdebug. Sie können zusätzlich eine Bedingung angeben, die bestimmt, wann das Programm anhalten 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 einen einzigen Ausdruck, siehe Einschränkungen von PHP.

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

Standardmäßig funktioniert {php} als veralteter Alias für {do} und wertet nur einen einzigen Ausdruck aus. Um beliebigen PHP-Code auszuführen, muss der Tag über die Extension RawPhpExtension aktiviert werden.

{spaceless}

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

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

Erzeugt:

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

Der Tag lässt sich auch als n:Attribut schreiben.

{syntax}

Latte-Tags müssen nicht nur in einfache geschweifte Klammern eingeschlossen sein. Sie können ein anderes Trennzeichen wählen, sogar zur Laufzeit. Dafür dient {syntax …}, wobei der Parameter sein kann:

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

Mit n:Attributen lässt sich Latte zum Beispiel für nur einen einzigen JavaScript-Block abschalten:

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

Latte lässt sich innerhalb von JavaScript sehr bequem verwenden, vermeiden Sie nur Konstrukte wie in diesem Beispiel, in dem unmittelbar auf { ein Buchstabe folgt, siehe Latte innerhalb von JavaScript oder CSS.

Wenn Sie Latte mit {syntax off} abschalten (also mit dem Tag, nicht mit dem n:Attribut), ignoriert es strikt alle Tags bis {/syntax}.

{trace}

Wirft eine Exception Latte\RuntimeException, deren Stack Trace dem Geist der Templates folgt. Statt Funktions- und Methodenaufrufen enthält er also Aufrufe von Blöcken und das Einbinden von Templates. Wenn Sie ein Werkzeug für die übersichtliche Anzeige geworfener Exceptions verwenden, etwa Tracy, sehen Sie den Aufrufstack samt aller übergebenen Argumente deutlich vor sich.

Helfer für HTML-Coder

n:class

Seit Latte 3.1 hat das übliche HTML-Attribut class dieselbe Funktionalität. Sie brauchen n:class also nicht mehr zu verwenden.

Dank n:class lässt sich das HTML-Attribut class sehr leicht genau so erzeugen, wie Sie es brauchen.

Beispiel: Ich brauche, dass das aktive Element die Klasse active hat:

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

Und weiter brauche ich, dass das erste Element die Klassen first und main hat:

{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, oder?

n:attr

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

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

Je nach den zurückgegebenen Werten gibt es zum Beispiel aus:

<input type="checkbox">

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

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

Auch die intelligenten Eigenschaften der Attribute in Latte 3.1, etwa das Weglassen von null-Werten oder die Übergabe von Arrays an class oder style, funktionieren innerhalb von n:attr:

<div n:attr="class: [a, b], title: $title"></div>

n:tag

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

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

Ist $heading === null, wird der Tag <h1> unverändert ausgegeben. Andernfalls wird der Name des Elements auf den Wert der Variablen geändert, für $heading === 'h3' schreibt er also:

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

Weil Latte ein sicheres Templating-System ist, prüft es, ob der neue Name des Tags gültig ist und keine unerwünschten oder bösartigen Werte enthält.

n:ifcontent

Verhindert die Ausgabe eines leeren HTML-Elements, also eines Elements, das nichts außer Leerraum enthält.

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

Je nach dem Wert der Variablen $error gibt es aus:

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

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

Übersetzung

Damit die Tags für die Übersetzung funktionieren, müssen Sie den Übersetzer aktivieren. 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 lassen sich auch weitere Parameter übergeben:

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

{translate}

Übersetzt Teile des Templates:

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

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

Der Tag lässt sich auch als n:Attribut schreiben, um das Innere des Elements zu übersetzen:

<h1 n:translate>Bestellung</h1>