{$text|shortify}
@@ -122,7 +122,7 @@ Filter .[#toc-filters] batch(int $length, mixed $item): array .[filter] ------------------------------------------------ -Filter, der die Auflistung von linearen Daten in Form einer Tabelle vereinfacht. Er gibt ein Array von Arrays mit der angegebenen Anzahl von Elementen zurück. Wenn Sie einen zweiten Parameter angeben, wird dieser verwendet, um fehlende Elemente in der letzten Zeile aufzufüllen. +Ein Filter, der die Ausgabe linearer Daten in Form einer Tabelle vereinfacht. Er gibt ein Array von Arrays mit der angegebenen Anzahl von Elementen zurück. Wenn Sie einen zweiten Parameter angeben, wird er verwendet, um fehlende Elemente in der letzten Zeile zu ergänzen. ```latte {var $items = ['a', 'b', 'c', 'd', 'e']} @@ -137,7 +137,7 @@ Filter, der die Auflistung von linearen Daten in Form einer Tabelle vereinfacht. ``` -Druckt: +Gibt aus: ```latte .[filter]
------------------------------
-Formatiert das Datum und die Uhrzeit entsprechend der Maske, die von der PHP-Funktion [php:date] verwendet wird. Der Filter akzeptiert das Datum im UNIX-Zeitstempelformat, als String oder als `DateTimeInterface` Objekt.
+Formatiert Datum und Uhrzeit gemäß der von der PHP-Funktion [php:date] verwendeten Maske. Der Filter akzeptiert Datum im UNIX-Timestamp-Format, als Zeichenkette oder als Objekt vom Typ `DateTimeInterface`.
```latte
{$today|date:'j. n. Y'}
```
-Siehe auch [localDate |#localDate].
+Siehe auch [#localDate].
escapeUrl .[filter]
-------------------
-Entfernt eine Variable, die als Parameter in einer URL verwendet werden soll.
+Escapet eine Variable zur Verwendung als Parameter in einer URL.
```latte
<a href=)
{$name}
```
-Siehe auch [Abfrage |#query].
+Siehe auch [#query].
explode(string $separator='') .[filter]
---------------------------------------
-Teilt eine Zeichenkette durch den angegebenen Begrenzer und gibt ein Array von Zeichenketten zurück. Alias für `split`.
+Teilt eine Zeichenkette anhand eines Trennzeichens in ein Array. Alias für `split`.
```latte
-{='one,two,three'|explode:','} {* liefert ['one', 'two', 'three'] *}
+{='one,two,three'|explode:','} {* gibt ['one', 'two', 'three'] zurück *}
```
Wenn das Trennzeichen eine leere Zeichenkette ist (Standardwert), wird die Eingabe in einzelne Zeichen aufgeteilt:
```latte
-{='123'|explode} {* liefert ['1', '2', '3'] *}
+{='123'|explode} {* gibt ['1', '2', '3'] zurück *}
```
Sie können auch den Alias `split` verwenden:
```latte
-{='1,2,3'|split:','} {* liefert ['1', '2', '3'] *}
+{='1,2,3'|split:','} {* gibt ['1', '2', '3'] zurück *}
```
-Siehe auch [implode |#implode].
+Siehe auch [#implode].
first .[filter]
---------------
-Gibt das erste Element eines Arrays oder ein Zeichen einer Zeichenkette zurück:
+Gibt das erste Element eines Arrays oder das erste Zeichen einer Zeichenkette zurück:
```latte
-{=[1, 2, 3, 4]|first} {* gibt 1 *}
-{='abcd'|first} {* gibt 'a' *}
+{=[1, 2, 3, 4]|first} {* gibt 1 aus *}
+{='abcd'|first} {* gibt 'a' aus *}
```
-Siehe auch [last |#last], [random |#random].
+Siehe auch [#last], [#random].
floor(int $precision=0) .[filter]
@@ -316,30 +316,30 @@ floor(int $precision=0) .[filter]
Rundet eine Zahl auf eine bestimmte Genauigkeit ab.
```latte
-{=3.5|floor} {* gibt 3 *}
-{=135.79|floor:1} {* gibt 135.7 *}
-{=135.79|floor:3} {* gibt 135.79 *}
+{=3.5|floor} {* gibt 3 aus *}
+{=135.79|floor:1} {* gibt 135.7 aus *}
+{=135.79|floor:3} {* gibt 135.79 aus *}
```
-Siehe auch [ceil |#ceil], [round |#round].
+Siehe auch [#ceil], [#round].
firstUpper .[filter]
--------------------
-Konvertiert den ersten Buchstaben eines Wertes in Großbuchstaben. Erfordert die PHP-Erweiterung `mbstring`.
+Konvertiert den ersten Buchstaben in einen Großbuchstaben. Erfordert die PHP-Erweiterung `mbstring`.
```latte
-{='the latte'|firstUpper} {* gibt 'The latte' *}
+{='the latte'|firstUpper} {* gibt 'The latte' aus *}
```
-Siehe auch [capitalize |#capitalize], [lower |#lower], [upper |#upper].
+Siehe auch [#capitalize], [#lower], [#upper].
group(string|int|\Closure $by): array .[filter]{data-version:3.0.16}
--------------------------------------------------------------------
-Der Filter gruppiert die Daten nach verschiedenen Kriterien.
+Filter, der Daten nach verschiedenen Kriterien gruppiert.
-In diesem Beispiel werden die Zeilen in der Tabelle nach der Spalte `categoryId` gruppiert. Die Ausgabe ist ein Array von Arrays, wobei der Schlüssel der Wert in der Spalte `categoryId` ist. Lesen Sie die [ausführliche Anleitung |cookbook/grouping].
+In diesem Beispiel werden die Tabellenzeilen nach der Spalte `categoryId` gruppiert. Die Ausgabe ist ein Array von Arrays, wobei der Schlüssel der Wert in der Spalte `categoryId` ist. [Lesen Sie die detaillierte Anleitung |cookbook/grouping].
```latte
{foreach ($items|group: categoryId) as $categoryId => $categoryItems}
@@ -351,28 +351,28 @@ In diesem Beispiel werden die Zeilen in der Tabelle nach der Spalte `categoryId`
{/foreach}
```
-Siehe auch [Batch |#batch], die [Gruppenfunktion |functions#group] und das [iterateWhile-Tag |tags#iterateWhile].
+Siehe auch [#batch], die Funktion [group |functions#group] und das Tag [iterateWhile |tags#iterateWhile].
implode(string $glue='') .[filter]
----------------------------------
-Gibt eine Zeichenkette zurück, die die Verkettung der Zeichenketten im Array ist. Alias für `join`.
+Gibt eine Zeichenkette zurück, die eine Verkettung der Elemente einer Sequenz ist. Alias für `join`.
```latte
-{=[1, 2, 3]|implode} {* gibt '123' *}
-{=[1, 2, 3]|implode:'|'} {* gibt '1|2|3' *}
+{=[1, 2, 3]|implode} {* gibt '123' aus *}
+{=[1, 2, 3]|implode:'|'} {* gibt '1|2|3' aus *}
```
-Sie können auch einen Alias `join` verwenden:
+Sie können auch den Alias `join` verwenden:
```latte
-{=[1, 2, 3]|join} {* gibt '123' *}
+{=[1, 2, 3]|join} {* gibt '123' aus *}
```
indent(int $level=1, string $char="\t") .[filter]
-------------------------------------------------
-Rückt einen Text von links um eine bestimmte Anzahl von Tabulatoren oder anderen Zeichen ein, die wir im zweiten optionalen Argument angeben. Leerzeilen werden nicht eingerückt.
+Rückt Text von links um eine bestimmte Anzahl von Tabulatoren oder anderen Zeichen ein, die im zweiten Argument angegeben werden können. Leere Zeilen werden nicht eingerückt.
```latte
one < two
'|stripHtml} {* gibt 'one < two' *} +{='one < two
'|stripHtml} {* gibt 'one < two' aus *} ``` -Der resultierende reine Text kann natürlich Zeichen enthalten, die HTML-Tags darstellen, zum Beispiel wird `'<p>'|stripHtml` in ``. Geben Sie den resultierenden Text niemals mit `|noescape` aus, da dies zu einer Sicherheitslücke führen kann. +Der resultierende reine Text kann natürlich Zeichen enthalten, die HTML-Tags darstellen, zum Beispiel wird `'<p>'|stripHtml` zu `
` konvertiert. Geben Sie den so erzeugten Text auf keinen Fall mit `|noescape` aus, da dies zu einer Sicherheitslücke führen kann.
substr(int $offset, ?int $length=null) .[filter]
------------------------------------------------
-Extrahiert einen Ausschnitt aus einer Zeichenkette. Dieser Filter wurde durch einen [Slice-Filter |#slice] ersetzt.
+Extrahiert einen Teil einer Zeichenkette. Dieser Filter wurde durch den Filter [#slice] ersetzt.
```latte
{$string|substr: 1, 2}
@@ -817,57 +817,57 @@ Extrahiert einen Ausschnitt aus einer Zeichenkette. Dieser Filter wurde durch ei
translate(...$args) .[filter]
-----------------------------
-Er übersetzt Ausdrücke in andere Sprachen. Um den Filter verfügbar zu machen, müssen Sie den [Übersetzer ein richten|develop#TranslatorExtension]. Sie können auch die [Tags für die Übersetzung |tags#Translation] verwenden.
+Übersetzt Ausdrücke in andere Sprachen. Damit der Filter verfügbar ist, muss ein [Übersetzer eingerichtet |develop#TranslatorExtension] sein. Sie können auch [Tags für Übersetzungen |tags#Translation] verwenden.
```latte
-{='Baskter'|translate}
+{='Cart'|translate}
{$item|translate}
```
trim(string $charlist=" \t\n\r\0\x0B\u{A0}") .[filter]
------------------------------------------------------
-Entfernen Sie führende und nachgestellte Zeichen, standardmäßig Leerzeichen.
+Entfernt Leerzeichen (oder andere Zeichen) vom Anfang und Ende einer Zeichenkette.
```latte
-{=' I like Latte. '|trim} {* gibt 'I like Latte.' *}
-{=' I like Latte.'|trim: '.'} {* gibt ' I like Latte' *}
+{=' I like Latte. '|trim} {* gibt 'I like Latte.' aus *}
+{=' I like Latte.'|trim: '.'} {* gibt ' I like Latte' aus *}
```
truncate(int $length, string $append='…') .[filter]
---------------------------------------------------
-Kürzt eine Zeichenkette auf die maximal angegebene Länge, versucht aber, ganze Wörter zu erhalten. Wenn die Zeichenkette abgeschnitten ist, wird am Ende ein Auslassungszeichen hinzugefügt (dies kann durch den zweiten Parameter geändert werden).
+Kürzt eine Zeichenkette auf die angegebene maximale Länge, wobei versucht wird, ganze Wörter zu erhalten. Wenn die Zeichenkette gekürzt wird, wird am Ende ein Auslassungszeichen hinzugefügt (kann mit dem zweiten Parameter geändert werden).
```latte
{var $title = 'Hello, how are you?'}
-{$title|truncate:5} {* Hell… *}
-{$title|truncate:17} {* Hello, how are… *}
-{$title|truncate:30} {* Hello, how are you? *}
+{$title|truncate:5} {* Hell… *}
+{$title|truncate:17} {* Hello, how are… *}
+{$title|truncate:30} {* Hello, how are you? *}
```
upper .[filter]
---------------
-Konvertiert einen Wert in Großbuchstaben. Erfordert die PHP-Erweiterung `mbstring`.
+Konvertiert eine Zeichenkette in Großbuchstaben. Erfordert die PHP-Erweiterung `mbstring`.
```latte
-{='latte'|upper} {* gibt 'LATTE' *}
+{='latte'|upper} {* gibt 'LATTE' aus *}
```
-Siehe auch [capitalize |#capitalize], [firstUpper |#firstUpper], [lower |#lower].
+Siehe auch [#capitalize], [#firstUpper], [#lower].
webalize .[filter]
------------------
-Konvertiert nach ASCII.
+Konvertiert eine UTF-8-Zeichenkette in die in URLs verwendete Form.
-Konvertiert Leerzeichen in Bindestriche. Entfernt Zeichen, die keine alphanumerischen Zeichen, Unterstriche oder Bindestriche sind. Konvertiert in Kleinbuchstaben. Entfernt auch führende und nachfolgende Leerzeichen.
+Es wird in ASCII konvertiert. Konvertiert Leerzeichen in Bindestriche. Entfernt Zeichen, die nicht alphanumerisch, Unterstriche oder Bindestriche sind. Konvertiert in Kleinbuchstaben. Entfernt auch führende und abschließende Leerzeichen.
```latte
-{var $s = 'Our 10. product'}
-{$s|webalize} {* gibt 'our-10-product' *}
+{var $s = 'Unser 10. Produkt'}
+{$s|webalize} {* gibt 'unser-10-produkt' aus *}
```
.[caution]
-Erfordert das Paket [nette/utils |utils:].
+Erfordert die Bibliothek [nette/utils |utils:].
diff --git a/latte/de/tags.texy b/latte/de/tags.texy
index c0ef1f3af7..23ecde451c 100644
--- a/latte/de/tags.texy
+++ b/latte/de/tags.texy
@@ -2,167 +2,167 @@ Latte Tags
**********
.[perex]
-Zusammenfassung und Beschreibung aller in Latte integrierten Tags.
+Eine Übersicht und Beschreibung aller Latte-Template-System-Tags, die standardmäßig zur Verfügung stehen.
.[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
+|## Ausgabe
+| `{$var}`, `{...}` oder `{=...}` | [gibt eine escaped Variable oder einen Ausdruck aus|#Ausgabe]
+| `{$var\|filter}` | [gibt mit Verwendung von Filtern aus|#Filter]
+| `{l}` oder `{r}` | gibt das Zeichen `{` oder `}` aus
.[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]
+| `{if}` … `{elseif}` … `{else}` … `{/if}` | [if-Bedingung|#if-elseif-else]
+| `{ifset}` … `{elseifset}` … `{/ifset}` | [ifset-Bedingung|#ifset-elseifset]
+| `{ifchanged}` … `{/ifchanged}` | [Test, ob eine Änderung aufgetreten ist|#ifchanged]
+| `{switch}` `{case}` `{default}` `{/switch}` | [switch-Bedingung|#switch-case-default]
+| `n:else` | [alternativer Inhalt 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]
+| `{foreach}` … `{/foreach}` | [#foreach]
+| `{for}` … `{/for}` | [#for]
+| `{while}` … `{/while}` | [#while]
+| `{continueIf $cond}` | [mit der nächsten Iteration fortfahren|#continueif-skipif-breakif]
+| `{skipIf $cond}` | [Iteration überspringen|#continueif-skipif-breakif]
+| `{breakIf $cond}` | [Schleife abbrechen|#continueif-skipif-breakif]
+| `{exitIf $cond}` | [vorzeitige Beendigung|#exitif]
+| `{first}` … `{/first}` | [ist es der erste Durchlauf?|#first-last-sep]
+| `{last}` … `{/last}` | [ist es der letzte Durchlauf?|#first-last-sep]
+| `{sep}` … `{/sep}` | [wird noch ein Durchlauf folgen?|#first-last-sep]
+| `{iterateWhile}` … `{/iterateWhile}` | [strukturiertes foreach|#iterateWhile]
+| `$iterator` | [spezielle Variable innerhalb von foreach|#$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]
+|## Einbindung weiterer Templates
+| `{include 'file.latte'}` | [lädt ein Template aus einer anderen Datei|#include]
+| `{sandbox 'file.latte'}` | [lädt ein Template 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]
+|## Blöcke, Layouts, Template-Vererbung
+| `{block}` | [anonymer Block|#block]
+| `{block blockname}` | [definiert einen Block|template-inheritance#blocks]
+| `{define blockname}` | [definiert einen Block zur späteren Verwendung|template-inheritance#definitions]
+| `{include blockname}` | [Darstellung eines Blocks|template-inheritance#printing-blocks]
+| `{include blockname from 'file.latte'}` | [stellt einen Block aus einer Datei dar|template-inheritance#printing-blocks]
+| `{import 'file.latte'}` | [lädt Blöcke aus einem Template|template-inheritance#horizontal-reuse]
+| `{layout 'file.latte'}` / `{extends}` | [bestimmt die Layout-Datei|template-inheritance#layout-inheritance]
+| `{embed}` … `{/embed}` | [lädt ein Template oder einen Block und ermöglicht das Überschreiben von Blöcken|template-inheritance#unit-inheritance]
+| `{ifset blockname}` … `{/ifset}` | [Bedingung, ob ein Block existiert|template-inheritance#checking-block-existence]
.[table-latte-tags language-latte]
|## Ausnahmebehandlung
-| `{try}`... `{else}`... `{/try}` | [Abfangen von Ausnahmen |#try]
-| `{rollback}` | [verwirft try-Block |#rollback]
+| `{try}` … `{else}` … `{/try}` | [Abfangen von Ausnahmen|#try]
+| `{rollback}` | [Verwerfen eines try-Blocks|#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]
+| `{var $foo = value}` | [erstellt eine Variable|#var-default]
+| `{default $foo = value}` | [erstellt eine Variable, wenn sie nicht existiert|#var-default]
+| `{parameters}` | [deklariert Variablen, Typen und Standardwerte|#parameters]
+| `{capture}` … `{/capture}` | [erfasst einen Block in eine Variable|#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]
+| `{varType}` | [deklariert den Typ einer Variable|type-system#varType]
+| `{varPrint}` | [schlägt Typen für Variablen vor|type-system#varPrint]
+| `{templateType}` | [deklariert Variablentypen basierend auf einer Klasse|type-system#templateType]
+| `{templatePrint}` | [schlägt eine Klasse mit Variablentypen vor|type-system#templatePrint]
.[table-latte-tags language-latte]
-|## Übersetzung
-| `{_string}` | [druckt übersetzt |#Translation]
-| `{translate}`... `{/translate}` | [übersetzt den Inhalt |#Translation]
+|## Übersetzungen
+| `{_...}` | [gibt eine Übersetzung aus|#übersetzungen]
+| `{translate}` … `{/translate}` | [übersetzt den Inhalt|#übersetzungen]
.[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]
+|## Sonstiges
+| `{contentType}` | [schaltet das Escaping um und sendet einen HTTP-Header|#contenttype]
+| `{debugbreak}` | [platziert einen Breakpoint im Code|#debugbreak]
+| `{do}` | [führt Code aus, gibt aber nichts aus|#do]
+| `{dump}` | [dumpt Variablen in die Tracy Bar|#dump]
+| `{php}` | [führt beliebigen PHP-Code aus|#php]
+| `{spaceless}` … `{/spaceless}` | [entfernt überflüssige Leerzeichen|#spaceless]
+| `{syntax}` | [Änderung der Syntax zur Laufzeit|#syntax]
+| `{trace}` | [zeigt den Stack-Trace an|#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]
+|## Helfer für HTML-Codierer
+| `n:class` | [dynamische Schreibweise des HTML-Attributs class|#n:class]
+| `n:attr` | [dynamische Schreibweise beliebiger HTML-Attribute|#n:attr]
+| `n:tag` | [dynamische Schreibweise des HTML-Element-Namens|#n:tag]
+| `n:ifcontent` | [lässt einen leeren HTML-Tag aus|#n:ifcontent]
.[table-latte-tags language-latte]
-|## Nur in Nette Framework verfügbar
-| `n:href` | [Link in `` 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]
+|## Nur im Nette Framework verfügbar
+| `n:href` | [Link, der in HTML-Elementen `` verwendet wird|application:creating-links#In the Presenter Template]
+| `{link}` | [gibt einen Link aus|application:creating-links#In the Presenter Template]
+| `{plink}` | [gibt einen Link zu einem Presenter aus|application:creating-links#In the Presenter Template]
+| `{control}` | [rendert eine Komponente|application:components#Rendering]
+| `{snippet}` … `{/snippet}` | [ein Snippet, das per AJAX gesendet werden kann|application:ajax#snippets-in-latte]
+| `{snippetArea}` | [Wrapper für Snippets|application:ajax#snippet-areas]
+| `{cache}` … `{/cache}` | [cached einen Teil des Templates|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]
+| `{form}` … `{/form}` | [rendert Formular-Tags|forms:rendering#form]
+| `{label}` … `{/label}` | [rendert ein Label für ein Formularelement|forms:rendering#label-input]
+| `{input}` | [rendert ein Formularelement|forms:rendering#label-input]
+| `{inputError}` | [gibt eine Fehlermeldung für ein Formularelement aus|forms:rendering#inputError]
+| `n:name` | [aktiviert ein Formularelement|forms:rendering#n:name]
+| `{formContainer}` … `{/formContainer}` | [Zeichnen eines Formular-Containers|forms:rendering#special-cases]
-Drucken .[#toc-printing]
+Ausgabe .[#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:
+In Latte wird das Tag `{=...}` verwendet, um einen beliebigen Ausdruck auszugeben. Latte legt Wert auf Ihren Komfort, daher ist es nicht nötig, das Gleichheitszeichen zu schreiben, wenn der Ausdruck mit einer Variable oder einem Funktionsaufruf beginnt. Das bedeutet in der Praxis, dass es fast nie notwendig ist, es zu schreiben:
```latte
Name: {$name} {$surname} {='one < two'} one < two {='one < two'} one < two In stock {$count} items {$count} Artikel auf Lager
-Age: {date('Y') - $birth}
+Alter: {date('Y') - $birth}
```
-Sie können alles, was Sie aus PHP kennen, als Ausdruck schreiben. Sie müssen nur keine neue Sprache lernen. Zum Beispiel:
+Als Ausdruck können Sie alles schreiben, was Sie aus PHP kennen. Sie müssen einfach 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 :-)
+Bitte suchen Sie in dem vorherigen Beispiel keinen Sinn, aber wenn Sie einen finden sollten, schreiben Sie uns :-)
-Ausweichende Ausgabe .[#toc-escaping-output]
---------------------------------------------
+Ausgabe escapen .[#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:
+Was ist die wichtigste Aufgabe eines Template-Systems? Sicherheitslücken zu verhindern. Und genau das macht Latte immer, wenn Sie etwas ausgeben. Es escaped es automatisch:
```latte
-