Werte und Literale #

Der Ausdrucksparser (lib/eztemplate/classes/eztemplateelementparser.php) kennt sechs Arten literaler Werte. Diese Seite führt sie mit den genauen Regeln des Parsers auf und zeigt jede auf einer Entwicklungsinstallation. get_type (aus eZTemplateTypeOperator) gibt den PHP-Typ eines Werts aus und wird hier deshalb genutzt, um zu zeigen, was aus einem Literal wird.

Inhalt #

1. Zeichenketten
2. Zahlen
3. Boolesche Werte
4. Arrays und Hashes
5. Bezeichner
6. Null
7. Wahrheitswerte
8. Verwandte Seiten

Zeichenketten #

Eine Zeichenkette wird in einfache oder doppelte Anführungszeichen geschrieben. Beide sind gleich: Keine interpoliert Variablen, also gibt "Hello $name" das Dollarzeichen und den Namen wörtlich aus. Verbinden Sie Zeichenketten mit concat.

unescapeCharacters() kennt diese Escapes, in beiden Arten von Anführungszeichen:

Innerhalb eines Tags muss eine } in einer Zeichenkette als \} geschrieben werden, sonst endet das Tag dort (siehe Lexikalische Struktur).

{def $name = 'World'}
[{'Hello $name'}] [{"Hello $name"}] [{concat( 'Hello ', $name )}]
[{'It\'s'}] [{"say \"hi\""}] [{'tab:\t:'}] [{'back\\slash'}] [{'unknown \q stays'}]
[{'line one\nline two'}]

Ausgabe:

[Hello $name] [Hello $name] [Hello World]
[It's] [say "hi"] [tab:	:] [back\slash] [unknown \q stays]
[line one
line two]

Zahlen #

Eine Zahl ist eine Folge von Ziffern mit einem wahlweise vorangestellten - und höchstens einem ., gefolgt von Ziffern. Ohne Punkt ist sie eine ganze Zahl, mit einem eine Gleitkommazahl (numericEndPos()). Auf einen Punkt muss eine Ziffer folgen: 1. ist die Zahl 1, gefolgt von einem Parserfehler (am Ende dieses Abschnitts gezeigt). Gleitkommazahlen werden von PHP ausgegeben, also gibt 1.50 den Wert 1.5 aus.

Zeichenketten aus Inhalten oder Anfragen bleiben Zeichenketten, bis ein Operator sie umwandelt; int und float tun es ausdrücklich. div gibt eine ganze Zahl zurück, wenn die Division ohne Rest aufgeht, und sonst eine Gleitkommazahl.

[{42}] [{-7}] [{3.14}] [{0.5}] [{1.50}]
[{42|get_type}] [{3.14|get_type}] [{'42'|get_type}] [{'42'|int|get_type}]
[{10|div( 4 )}] [{10|div( 5 )|get_type}]

Ausgabe:

[42] [-7] [3.14] [0.5] [1.5]
[integer] [double] [string[2]] [integer]
[2.5] [integer]

Ein Punkt ohne Ziffer danach:

[{1.|get_type}]

Ausgabe:

[1]

Von der Template-Engine protokolliert:

ERROR : parser error @ tl-values/07-number-dot.tpl:1[2]
Extra characters found in expression, they will be ignored.
.|get_type' (1)

Boolesche Werte #

Es gibt kein Schlüsselwort true oder false: true() und false() sind Operatoren von eZTemplateLogicOperator, die die booleschen Werte von PHP zurückgeben. Ausgegeben wird true zu 1 und false zur leeren Zeichenkette, wie in PHP.

[{true()}] [{false()}] [{true()|get_type}] [{false()|get_type}]
[{if 0}0 is true{else}0 is false{/if}] [{if '0'}'0' is true{else}'0' is false{/if}] [{if ''}empty is true{else}empty is false{/if}] [{if array()}empty array is true{else}empty array is false{/if}]

Ausgabe:

[1] [] [boolean[true]] [boolean[false]]
[0 is false] ['0' is false] [empty is false] [empty array is false]

Arrays und Hashes #

array( ... ) baut eine Liste mit den Schlüsseln 0, 1, 2 und hash( key, value, ... ) eine Zuordnung aus Paaren. Beide stammen aus eZTemplateArrayOperator, sind also Operatoren wie alle anderen und lassen sich verschachteln, durch die Pipe leiten und als Parameter übergeben. Elemente werden mit einem Punkt oder mit eckigen Klammern gelesen: $list.1, $map.red, $deep['count'].

{def $list = array( 'a', 'b', 'c' )
     $map  = hash( 'red', '#f00', 'green', '#0f0' )
     $deep = hash( 'sizes', array( 'S', 'M', 'L' ), 'count', 3 )}
[{$list|count}] [{$list.1}] [{$list|implode( '-' )}]
[{$map.red}] {foreach $map as $k => $v}[{$k}={$v}]{/foreach}
[{$deep.sizes.2}] [{$deep['count']}]
[{array()|count}] [{$list|get_type}] [{$map|get_type}]

Ausgabe:

[3] [b] [a-b-c]
[#f00] [red=#f00][green=#0f0][L] [3]
[0] [array[3]] [array[2]]

get_type fügt bei Arrays die Anzahl der Elemente und bei Zeichenketten die Länge hinzu, was es bei der Fehlersuche nützlich macht.

Bezeichner #

Ein bloßes Wort, auf das kein ( folgt, ist ein Bezeichner, und sein Wert ist das Wort selbst. Manche Operatoren und Funktionen nutzen Bezeichner, wo andere Sprachen Schlüsselwörter in Anführungszeichen nutzen würden, zum Beispiel attribute( show, 2 ) oder sequence array( odd, even ):

[{1|choose( zero, one, two )}] [{array( red, green )|implode( '+' )}]

Ausgabe:

[one] [red+green]

In Bezeichnern und Variablennamen erlaubt sind Buchstaben, Ziffern, _ und - (identifierEndPosition()). Ein Bindestrich gehört zum Namen, also ist $my-var eine einzige Variable, keine Subtraktion.

Null #

Es gibt kein Literal für null. null existiert, ist aber ein Test aus eZTemplateLogicOperator, der wahr ist, wenn seine Eingabe null ist, kein Wert. Null-Werte kommen aus PHP, zum Beispiel von einem Fetch, der nichts findet; prüfen Sie sie mit is_null oder is_set, und ersetzen Sie eine fehlende Variable mit first_set:

{def $empty = fetch( 'content', 'node', hash( 'node_id', 999999999 ) )}
[{$empty|get_type}] [{if $empty|is_null}is null{/if}] [{if is_set( $empty )}is set{else}not set{/if}] [{first_set( $missing, 'default' )}]

Ausgabe:

[null] [is null] [not set] [default]

Wahrheitswerte #

Bedingungen nutzen die Wahrheitswerte von PHP. 0, '0', die leere Zeichenkette, ein leeres Array, false() und null sind falsch; alles andere, auch ein Array, das eine 0 enthält, ist wahr. Die in dieser Schleife geprüften Werte sind 0, 1, '', 'x', '0', array(), array( 0 ), false() und true():

{foreach array( 0, 1, '', 'x', '0', array(), array( 0 ), false(), true() ) as $v}[{if $v}T{else}F{/if}]{/foreach}

Ausgabe:

[F][T][F][T][F][F][T][F][T]

Verwandte Seiten #

• Zurück: Lexikalische Struktur
• Weiter: Variablen im Detail
• Grundlagen der TPL-Syntax
• Array-Operatoren
• Die Typ-Operatoren
• Freie Dokumentation: Diese Seite darf unter der GNU FDL 1.3 frei kopiert, übersetzt und verbessert werden.