Durchsuchen von XML-Strukturen

Die parent() -Methode gibt den übergeordneten Knoten eines XML-Objekts zurück.

Sie können die ordinalen Indexwerte einer untergeordneten Liste verwenden, um auf bestimmte untergeordnete Objekte zuzugreifen. Stellen Sie sich beispielsweise das XML-Objekt myXML vor, das über zwei untergeordnete Eigenschaften mit dem Namen book verfügt. Jeder der untergeordneten Eigenschaften mit dem Namen book ist eine Indexnummer zugeordnet:

myXML.book[0] 
myXML.book[1]

Um auf bestimmte über zwei Stufen hinweg untergeordnete Eigenschaften zuzugreifen, können Sie Indexnummern für die jeweils untergeordneten Namen angeben:

myXML.book[0].title[0]

Wenn es jedoch nur eine untergeordnete Eigenschaft von x.book[0] mit dem Namen title gibt, können Sie den Indexverweis wie folgt weglassen:

myXML.book[0].title

Analog hierzu können Sie beide Indexverweise weglassen, wenn nur eine dem Objekt x untergeordnete Eigenschaft mit dem Namen „book“ vorliegt:

myXML.book.title

Wie im folgenden Beispiel dargestellt ist, können Sie die child() -Methode verwenden, um zu untergeordneten Eigenschaften mit Namen zu navigieren, die auf einer Variablen oder einem Ausdruck basieren:

var myXML:XML =  
        <order> 
            <book> 
                <title>Dictionary</title> 
            </book> 
        </order>; 
 
var childName:String = "book"; 
 
trace(myXML.child(childName).title) // output: Dictionary

Verwenden Sie das @ -Symbol (den Attributbezeichneroperator) wie im folgenden Code dargestellt, um auf Attribute eines XML- oder XMLList-Objekts zuzugreifen:

var employee:XML =  
    <employee id="6401" code="233"> 
        <lastName>Wu</lastName> 
        <firstName>Erin</firstName> 
    </employee>; 
trace(employee.@id); // 6401

Wie im folgenden Code dargestellt ist, können Sie das Platzhaltersymbol * zusammen mit dem @ -Symbol verwenden, um auf alle Attribute eines XML- oder XMLList-Objekts zuzugreifen:

var employee:XML =  
    <employee id="6401" code="233"> 
        <lastName>Wu</lastName> 
        <firstName>Erin</firstName> 
    </employee>; 
trace(employee.@*.toXMLString());  
// 6401 
// 233

Wie im folgenden Code dargestellt ist, können Sie mithilfe der attribute() -Methode oder der attributes() -Methode auf ein bestimmtes Attribut oder auf alle Attribute eines XML- oder XMLList-Objekts zugreifen:

var employee:XML =  
    <employee id="6401" code="233"> 
        <lastName>Wu</lastName> 
        <firstName>Erin</firstName> 
    </employee>; 
trace(employee.attribute("id")); // 6401 
trace(employee.attribute("*").toXMLString());  
// 6401 
// 233 
trace(employee.attributes().toXMLString());  
// 6401 
// 233

Beachten Sie, dass Sie für den Zugriff auf Attribute auch die im folgenden Beispiel dargestellte Syntax verwenden können:

employee.attribute("id") 
employee["@id"] 
employee.@["id"]

Jeder dieser Ausdrücke entspricht employee.@id . Die Syntax employee.@id ist jedoch der bevorzugte Ansatz.

Sie können die Klammernoperatoren ( und ) verwenden, um Elemente mit einem bestimmten Elementnamen oder Attributwert zu filtern. Gegeben ist das folgende XML-Objekt:

var x:XML =  
    <employeeList> 
        <employee id="347"> 
            <lastName>Zmed</lastName> 
            <firstName>Sue</firstName> 
            <position>Data analyst</position> 
        </employee> 
        <employee id="348"> 
            <lastName>McGee</lastName> 
            <firstName>Chuck</firstName> 
            <position>Jr. data analyst</position> 
        </employee> 
    </employeeList>

Die folgenden Ausdrücke sind alle gültig:

• x.employee.(lastName == "McGee") – Dies ist der zweite employee -Knoten.

• x.employee.(lastName == "McGee").firstName – Dies ist die firstName -Eigenschaft des zweiten employee -Knotens.

• x.employee.(lastName == "McGee").@id – Dies ist der Wert des id -Attributs des zweiten employee -Knotens.

• x.employee.(@id == 347) – Der erste employee -Knoten.

• x.employee.(@id == 347).lastName – Dies ist die lastName -Eigenschaft des ersten employee -Knotens.

• x.employee.(@id > 300) – Dies ist ein XMLList-Objekt mit beiden employee -Eigenschaften.

• x.employee.(position.toString().search("analyst") > -1) – Dies ist ein XMLList-Objekt mit beiden position -Eigenschaften.

Wenn Sie versuchen, anhand von Attributen oder Elementen zu filtern, die nicht vorhanden sind, wird eine Ausnahme ausgegeben. Die letzte Zeile des folgenden Codes erzeugt beispielsweise einen Fehler, da im zweiten p -Element kein id -Attribut vorhanden ist:

var doc:XML =  
            <body> 
                <p id='123'>Hello, <b>Bob</b>.</p> 
                <p>Hello.</p> 
            </body>; 
trace(doc.p.(@id == '123'));

Analog erzeugt die letzte Zeile des folgenden Codes einen Fehler, da keine b -Eigenschaft des zweiten p -Elements vorhanden ist:

var doc:XML =  
            <body> 
                <p id='123'>Hello, <b>Bob</b>.</p> 
                <p>Hello.</p> 
            </body>; 
trace(doc.p.(b == 'Bob'));

Um solche Fehler zu vermeiden, können Sie Eigenschaften mit übereinstimmenden Attributen und Elementen angeben, indem Sie wie im folgenden Code die Methoden attribute() und elements() verwenden:

var doc:XML =  
            <body> 
                <p id='123'>Hello, <b>Bob</b>.</p> 
                <p>Hello.</p> 
            </body>; 
trace(doc.p.(attribute('id') == '123')); 
trace(doc.p.(elements('b') == 'Bob'));

Sie können auch wie im folgenden Code die hasOwnProperty() -Methode verwenden:

var doc:XML =  
            <body> 
                <p id='123'>Hello, <b>Bob</b>.</p> 
                <p>Hello.</p> 
            </body>; 
trace(doc.p.(hasOwnProperty('@id') && @id == '123')); 
trace(doc.p.(hasOwnProperty('b') && b == 'Bob'));

ActionScript 3.0 enthält die for..in -Anweisung und die for each..in -Anweisung zum schrittweisen Durchlaufen von XMLList-Objekten. Gegeben sind beispielsweise das folgende XML-Objekt myXML und das XMLList-Objekt myXML.item . Das XMLList-Objekt myXML.item enthält die beiden item -Knoten des XML-Objekts.

var myXML:XML =  
    <order> 
        <item id='1' quantity='2'> 
            <menuName>burger</menuName> 
            <price>3.95</price> 
        </item> 
        <item id='2' quantity='2'> 
            <menuName>fries</menuName> 
            <price>1.45</price> 
        </item> 
    </order>;

Die for..in -Anweisung ermöglicht es Ihnen, eine Gruppe von Eigenschaftsnamen eines XMLList-Objekts zu durchlaufen:

var total:Number = 0; 
for (var pname:String in myXML.item) 
{ 
    total += myXML.item.@quantity[pname] * myXML.item.price[pname]; 
}

Die for each..in -Anweisung ermöglicht es Ihnen, die Eigenschaften des XMLList-Objekts zu durchlaufen:

var total2:Number = 0; 
for each (var prop:XML in myXML.item) 
{ 
    total2 += prop.@quantity * prop.price; 
}