Logische Operatoren #

Bedingungen in {if}, {elseif} und {while} sind Operatoraufrufe, denn die Template-Sprache kennt kein ==, <, && oder !. Die 13 Operatoren auf dieser Seite registriert eZTemplateLogicOperator (lib/eztemplate/classes/eztemplatelogicoperator.php) über lib/eztemplate/classes/eztemplateautoload.php.

Zwei ihrer Regeln überraschen alle, die PHP oder Smarty kennen, und beide werden unten belegt:

• lt, gt, le und ge vergleichen Anzahlen, keine Werte: Eine nicht numerische Zeichenkette zählt als ihre Länge, daher ist 'pear'|lt( 'apple' ) wahr (4 ist kleiner als 5).
• and und or geben einen ihrer Operanden zurück, nicht immer einen booleschen Wert.

Inhalt #

1. eq und ne
2. lt, gt, le und ge
3. and und or
4. not, null, true und false
5. choose
6. Verwandte Seiten

In den Beispielen macht choose( 'false', 'true' ) aus einem booleschen Wert ein Wort, denn ein boolesches true wird als 1 ausgegeben und false gibt nichts aus.

eq und ne #

eq #

Mit einem Parameter: ob die Eingabe über die Pipe ihm gleich ist. Mit zwei oder mehr Parametern: ob alle Parameter gleich sind (die Eingabe wird nicht verwendet). Der Vergleich ist das lose == von PHP, daher ist '5'|eq( 5 ) wahr. Ohne Parameter protokolliert er "Requires one parameter for input checking or two or more for parameter checking" und gibt false zurück.

Gibt einen booleschen Wert zurück. Erzeugte Referenz: eq.

ne #

Das Gegenteil: mit einem Parameter, ob sich die Eingabe von ihm unterscheidet; mit mehreren, ob sich irgendwelche zwei Nachbarn unterscheiden. Dieselbe Warnung ohne Parameter.

Gibt einen booleschen Wert zurück. Erzeugte Referenz: ne.

5|eq( 5 ) = {5|eq( 5 )|choose( 'false', 'true' )}
'5'|eq( 5 ) = {'5'|eq( 5 )|choose( 'false', 'true' )}
eq( 3, 3, 3 ) = {eq( 3, 3, 3 )|choose( 'false', 'true' )}
eq( 3, 3, 4 ) = {eq( 3, 3, 4 )|choose( 'false', 'true' )}
'abc'|ne( 'abd' ) = {'abc'|ne( 'abd' )|choose( 'false', 'true' )}
ne( 1, 1, 2 ) = {ne( 1, 1, 2 )|choose( 'false', 'true' )}

Ausgabe:

5|eq( 5 ) = true
'5'|eq( 5 ) = true
eq( 3, 3, 3 ) = true
eq( 3, 3, 4 ) = false
'abc'|ne( 'abd' ) = true
ne( 1, 1, 2 ) = true

lt, gt, le und ge #

lt, gt, le, ge #

lt (kleiner als), gt (größer als), le (kleiner oder gleich) und ge (größer oder gleich) vergleichen zwei Werte: die Eingabe über die Pipe mit dem benannten Parameter threshold oder, ohne Eingabe, den ersten Parameter mit dem zweiten.

Jede Seite wird zuerst von eZTemplateLogicOperator::comparisonCount() in eine Anzahl umgewandelt:

Jeder andere Typ protokolliert "Unsupported input type" und lässt den Wert unverändert. Wegen der Regel für Zeichenketten verwenden Sie zum Ordnen von Wörtern strcmp oder strnatcmp (siehe PHP-Zeichenkettenfunktionen: suchen und vergleichen). Kompilierte Templates rufen zur Laufzeit compareCounts() auf und wenden dieselbe Regel an.

Gibt einen booleschen Wert zurück. Erzeugte Referenzen: lt, gt, le, ge.

3|lt( 5 ) = {3|lt( 5 )|choose( 'false', 'true' )}
gt( 10, 2 ) = {gt( 10, 2 )|choose( 'false', 'true' )}
5|le( 5 ) = {5|le( 5 )|choose( 'false', 'true' )}
5|ge( 6 ) = {5|ge( 6 )|choose( 'false', 'true' )}
array( 1, 2, 3 )|gt( 2 ) = {array( 1, 2, 3 )|gt( 2 )|choose( 'false', 'true' )}
'banana'|gt( 'apple' ) = {'banana'|gt( 'apple' )|choose( 'false', 'true' )}
'pear'|lt( 'apple' ) = {'pear'|lt( 'apple' )|choose( 'false', 'true' )}
'10'|gt( '9' ) = {'10'|gt( '9' )|choose( 'false', 'true' )}

Ausgabe:

3|lt( 5 ) = true
gt( 10, 2 ) = true
5|le( 5 ) = true
5|ge( 6 ) = false
array( 1, 2, 3 )|gt( 2 ) = true
'banana'|gt( 'apple' ) = true
'pear'|lt( 'apple' ) = true
'10'|gt( '9' ) = true

and und or #

Beide werten nur ihre Parameter aus; die Eingabe über die Pipe wird nicht verwendet. Jeder Operand wird so beurteilt: null ist falsch, ein boolescher Wert ist er selbst, ein Array ist wahr, wenn es Elemente hat, eine Zahl ist wahr, wenn sie nicht 0 ist, ein Objekt ist wahr, wenn es die Methoden attributes() und attribute() hat, und eine Zeichenkette ist wahr, wenn sie etwas anderes als Leerraum enthält (and behandelt auch '' als falsch).

and #

Gibt beim ersten falschen Operanden false zurück; sind alle wahr, gibt er den letzten Operanden selbst zurück.

Erzeugte Referenz: and.

or #

Gibt den ersten wahren Operanden selbst zurück oder false, wenn keiner wahr ist. Damit eignet sich or zur Wahl eines Ersatzwerts, auch wenn first_set dafür klarer ist.

Erzeugte Referenz: or.

and( 1, 'yes', array( 1 ) ) = {and( 1, 'yes', array( 1 ) )|implode( ',' )}
and( 1, '  ', 3 ) = {and( 1, '  ', 3 )|choose( 'false', 'true' )}
or( false(), '', 'first', 'second' ) = {or( false(), '', 'first', 'second' )}
or( 0, array() ) = {or( 0, array() )|choose( 'false', 'true' )}

Ausgabe:

and( 1, 'yes', array( 1 ) ) = 1
and( 1, '  ', 3 ) = false
or( false(), '', 'first', 'second' ) = first
or( 0, array() ) = false

Die Regel für Leerraum ist die des Interpreters. Kompiliert auf einer Entwicklungsinstallation behandelte and( 1, ' ', 3 ) die leere Zeichenkette als wahr und gab 3 zurück, den letzten Operanden, woraufhin das folgende choose "Index 3 out of range" protokollierte und nichts ausgab. Entfernen Sie Leerraum, bevor Sie Zeichenketten prüfen ($text|trim), dann sind sich beide einig.

Ausgabe mit dem Template-Compiler (in einen Arbeitsordner kompiliert):

and( 1, 'yes', array( 1 ) ) = 1
and( 1, '  ', 3 ) = 
or( false(), '', 'first', 'second' ) = first
or( 0, array() ) = false

not, null, true und false #

not #

Verneint die Eingabe über die Pipe oder, wenn es keine Eingabe gibt, den ersten Parameter. "Leer" bedeutet: null, ein leeres Array, ein Objekt ohne Attribute, eine Zahl oder numerische Zeichenkette gleich 0 (also auch '0') oder eine leere Zeichenkette. Gibt einen booleschen Wert zurück.

Erzeugte Referenz: not.

null #

Ob die Eingabe über die Pipe genau null ist (===). Ein Fetch, der nichts findet, gibt null zurück. Keine Parameter. Erzeugte Referenz: null.

true und false #

Geben die booleschen Werte true und false zurück. So schreiben Sie ein boolesches Literal: true(), false(). Keine Parameter. Erzeugte Referenzen: true, false.

{def $empty = array()
     $node = fetch( 'content', 'node', hash( 'node_id', 89 ) )
     $missing = fetch( 'content', 'node', hash( 'node_id', 999999999 ) )}
$empty|not = {$empty|not|choose( 'false', 'true' )}
not( 0 ) = {not( 0 )|choose( 'false', 'true' )}
'0'|not = {'0'|not|choose( 'false', 'true' )}
''|not = {''|not|choose( 'false', 'true' )}
$node|not = {$node|not|choose( 'false', 'true' )}
$missing|null (no node has that id) = {$missing|null|choose( 'false', 'true' )}
true() = {true()|choose( 'false', 'true' )}, false() = {false()|choose( 'false', 'true' )}

Ausgabe:

$empty|not = true
not( 0 ) = true
'0'|not = true
''|not = true
$node|not = false
$missing|null (no node has that id) = true
true() = true, false() = false

choose #

choose #

Wählt anhand der Eingabe über die Pipe einen seiner Parameter: Eine Zahl ist der Index (0 wählt den ersten Parameter), ein boolescher Wert ist 0 oder 1 (false wählt also den ersten und true den zweiten), und null ist 0. Nur der gewählte Parameter wird ausgewertet. Eine Eingabe vom Typ Array oder Objekt protokolliert "Only supports numeric and boolean values"; ein Index außerhalb der Parameter protokolliert "Index ... out of range" und gibt false zurück.

Erzeugte Referenz: choose.

{def $n = 2
     $node = fetch( 'content', 'node', hash( 'node_id', 144 ) )}
$n|choose( 'zero', 'one', 'two' ) = {$n|choose( 'zero', 'one', 'two' )}
true()|choose( 'no', 'yes' ) = {true()|choose( 'no', 'yes' )}
The Recipes node {$node.children_count|gt( 0 )|choose( 'has no children', concat( 'has ', $node.children_count, ' children' ) )}.

Ausgabe:

$n|choose( 'zero', 'one', 'two' ) = two
true()|choose( 'no', 'yes' ) = yes
The Recipes node has 18 children.

Ein Index außerhalb der Liste ist ein Fehler:

3|choose( 'a', 'b' ) = {3|choose( 'a', 'b' )|choose( 'false', 'true' )}

Ausgabe:

3|choose( 'a', 'b' ) = false

Von der Template-Engine protokolliert:

ERROR choose: Index 3 out of range 0 => 1

Für eine Wahl zwischen zwei Möglichkeiten bei einer beliebigen Bedingung liest sich cond natürlicher.

Verwandte Seiten #

• Logik- und Vergleichsoperatoren für Designer
• If und Bedingungen
• Steueroperatoren: cond und first_set
• Typ-Operatoren: is_set, is_array und die anderen Prüfungen
• Alle Template-Operatoren (erzeugt)
• Freie Dokumentation: Diese Seite darf unter der GNU FDL 1.3 frei kopiert, übersetzt und verbessert werden.