Zugriff auf Attribute #

$node.parent.name liest sich wie eine Kette von Array-Schlüsseln, aber $node ist ein PHP-Objekt. Die Template-Engine löst jeden Schritt über ein kleines Protokoll auf, und dieses Protokoll macht Knoten, Inhaltsobjekte, Benutzer und jedes andere Objekt des Kernels in Templates nutzbar. Der Code ist der Zweig TYPE_ATTRIBUTE von elementValue() in lib/eztemplate/classes/eztemplate.php. Die Beispiele nutzen Knoten 90 einer Entwicklungsinstallation, den Artikel „Privacy Policy“.

Inhalt #

1. Punkte und eckige Klammern
2. Wie ein Schritt aufgelöst wird
3. Felder und Funktionsattribute
4. Dynamische Schlüssel
5. Indizes
6. Attribute nach einem Operator
7. Ein fehlendes Attribut
8. In einen Wert hineinsehen: attribute und dump
9. Die eigene Klasse lesbar machen
10. Verwandte Seiten

Punkte und eckige Klammern #

.name und ['name'] sind derselbe Zugriff. In eckigen Klammern darf jeder Ausdruck stehen, eckige Klammern sind also die Form für berechnete Schlüssel; nach einem Punkt nur ein Name, eine Zahl oder eine Variable.

{def $node = fetch( 'content', 'node', hash( 'node_id', 90 ) )}
[{$node.name}] [{$node['name']}] [{$node.object.id}] [{$node.parent.name}]
[{$node.data_map.title.content}] [{$node['data_map']['title'].data_type_string}]

Ausgabe:

[Privacy Policy] [Privacy Policy] [88] [Fit & Healthy]
[Privacy Policy] [ezstring]

Wie ein Schritt aufgelöst wird #

Für jeden Schritt nimmt die Engine den Schlüssel (er muss eine Zahl, eine Zeichenkette oder ein boolescher Wert sein, sonst Cannot use type ... for attribute lookup) und dann:

Öffentliche Eigenschaften von PHP werden nicht gelesen: Nur das Attributprotokoll zählt.

Felder und Funktionsattribute #

Objekte des Kernels leiten sich von eZPersistentObject ab (kernel/classes/ezpersistentobject.php). Ihre definition() führt Felder (Datenbankspalten) und Funktionsattribute (Namen, die Methoden zugeordnet sind) auf, und attributes(), hasAttribute() und attribute() bedienen beide:

• ein Feld gibt das Mitglied zurück, das die Spalte hält, ohne Abfrage;
• ein Funktionsattribut ruft seine Methode auf, zum Beispiel ruft children_count eine Methode auf, die in der Datenbank zählt, data_map lädt die Felder des Objekts, url_alias baut die URL.

{def $node = fetch( 'content', 'node', hash( 'node_id', 90 ) )}
field:    node_id={$node.node_id} depth={$node.depth} path_string={$node.path_string}
function: children_count={$node.children_count} class_identifier={$node.class_identifier} url_alias={$node.url_alias}
object field: published={$node.object.published} section_id={$node.object.section_id}
object function: class_name={$node.object.class_name} main_node_id={$node.object.main_node_id}

Ausgabe:

field:    node_id=90 depth=3 path_string=/1/2/89/90/
function: children_count=0 class_identifier=ng_article url_alias=privacy-policy
object field: published=1674667522 section_id=1
object function: class_name=NG Article main_node_id=90

Dieser Unterschied zählt für die Geschwindigkeit: Ein Funktionsattribut in einer Schleife führt seine Methode in jedem Durchlauf aus. Lesen Sie es einmal mit {def} in eine Variable, wenn Sie es mehrfach brauchen.

Dynamische Schlüssel #

Eine Variable in eckigen Klammern, oder nach einem Punkt, liefert den Schlüssel:

{def $node = fetch( 'content', 'node', hash( 'node_id', 90 ) )
     $field = 'node_id'
     $keys = array( 'name', 'depth', 'class_identifier' )}
[{$node[$field]}] [{$node.$field}]
{foreach $keys as $k}[{$k}={$node[$k]}]{/foreach}

Ausgabe:

[90] [90][name=Privacy Policy][depth=3][class_identifier=ng_article]

Indizes #

Listen werden nach Position gelesen, mit einer Zahl nach dem Punkt oder einem beliebigen Ausdruck in eckigen Klammern:

{def $list = array( 'zero', 'one', 'two' ) $i = 2}
[{$list.0}] [{$list[1]}] [{$list[$i]}] [{$list[$i|dec]}]

Ausgabe:

[zero] [one] [two] [one]

Attribute nach einem Operator #

Ein Punkt oder eckige Klammern dürfen auf einen Operatoraufruf folgen, sodass sich das Ergebnis eines Fetch oder eines Array-Operators direkt lesen lässt:

[{fetch( 'content', 'node', hash( 'node_id', 89 ) ).name}]
[{fetch( 'content', 'node', hash( 'node_id', 89 ) ).children|count}]
[{array( 'x', 'y', 'z' )|reverse.0}]

Ausgabe:

[Fit & Healthy]
[16]
[z]

Ein fehlendes Attribut #

Ein Schlüssel, der nicht existiert, protokolliert einen Fehler und ergibt keinen Wert. Bei Arrays und Objekten führt die Meldung die vorhandenen Schlüssel auf (die ersten 25, bei Objekten aus attributes()), was sie zum schnellsten Weg macht herauszufinden, was ein Wert bietet:

{def $map = hash( 'red', 1, 'green', 2 )}
[{$map.blue}]

Ausgabe:

[]

Von der Template-Engine protokolliert:

ERROR : No such attribute for array(2): blue
Choose one of following: red, green

In einen Wert hineinsehen: attribute und dump #

Der Operator attribute (eZTemplateAttributeOperator) durchläuft einen Wert und führt seine Schlüssel und Typen auf, mit Werten, wenn der erste Parameter show ist. Seine Parameter sind show_values (show oder etwas anderes), max_val (Ebenen, in die er absteigt, Standard 2 bei attribute und 1 bei dump) und format (html oder text, Standard aus template.ini [AttributeOperator] DefaultFormatter, also html). dump ist derselbe Operator, mit standardmäßig angezeigten Werten.

{hash( 'title', 'Hello', 'sizes', array( 'S', 'M' ) )|attribute( show, 2, text )}

Ausgabe:

title (string='Hello')
sizes (array=Array(2))
    0 (string='S')
    1 (string='M')

{hash( 'title', 'Hello', 'count', 3 )|dump( show, 1, text )}

Ausgabe:

title (string='Hello')
count (integer=3)

Auf einem Objekt führt er jedes Attribut auf, das das Objekt bietet; so lassen sich die Attributnamen eines Knotens auf Ihrer eigenen Installation lesen. Die ersten 12 Zeilen für Knoten 90 (der Operator gibt Text zurück, die üblichen Zeichenketten- und Array-Operatoren können ihn also zuschneiden):

{def $node = fetch( 'content', 'node', hash( 'node_id', 90 ) )
     $list = $node|attribute( hide, 1, text )}
{$list|explode( "\n" )|extract_left( 12 )|implode( "\n" )}

Ausgabe:

node_id (integer)
parent_node_id (integer)
main_node_id (integer)
contentobject_id (integer)
contentobject_version (integer)
contentobject_is_published (integer)
depth (integer)
sort_field (integer)
sort_order (integer)
priority (integer)
modified_subnode (integer)
path_string (string)

Entfernen Sie den Operator wieder, bevor das Template live geht: Er ruft jedes Funktionsattribut des Objekts auf.

Die eigene Klasse lesbar machen #

Jedes PHP-Objekt wird in Templates lesbar, wenn es die drei Methoden hat. Eine Klasse, die eZPersistentObject erweitert, bekommt sie aus ihrer Definition. Eine einfache Klasse setzt sie selbst um:

class expExampleBox
{
    public function attributes()
    {
        return array( 'title', 'items' );
    }

    public function hasAttribute( $name )
    {
        return in_array( $name, $this->attributes() );
    }

    public function attribute( $name )
    {
        switch ( $name )
        {
            case 'title': return $this->title;
            case 'items': return $this->loadItems();
        }
        return null;
    }
}

Diese Skizze wurde nicht auf einer Entwicklungsinstallation ausgeführt; sie zeigt die Form, auf die die Engine prüft (method_exists( $value, 'attribute' ) und method_exists( $value, 'hasAttribute' )).

Verwandte Seiten #

• Zurück: Namensräume
• Weiter: Operatoren in Ausdrücken
• Attribute und Punktschreibweise
• Knoten, Objekte und Attribute
• attribute und dump
• Freie Dokumentation: Diese Seite darf unter der GNU FDL 1.3 frei kopiert, übersetzt und verbessert werden.