XML-structuren doorlopen

De methode parent() retourneert het bovenliggende item van een object XML.

U kunt de ordinale indexwaarden van een lijst met onderliggende items gebruiken om toegang te krijgen tot bepaalde onderliggende objecten. Bekijk bijvoorbeeld een XML-object myXML dat twee onderliggende eigenschappen heeft met de naam book . Elke onderliggende eigenschap met de naam book heeft een indexnummer dat hieraan is gekoppeld:

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

U kunt indexnummers opgeven voor de naam van het onderliggende item van zowel het eerste als het tweede niveau om toegang te krijgen tot een bepaald onderliggend item op het tweede niveau:

myXML.book[0].title[0]

Wanneer er echter maar één onderliggend item is van x.book[0] met de naam title , kunt u de verwijzing naar de index als volgt weglaten:

myXML.book[0].title

Op dezelfde manier kunt u als volgt beide verwijzingen naar de index weglaten wanneer er slechts één onderliggend item book is van het object x en wanneer dat onderliggende object slechts één object title heeft:

myXML.book.title

U kunt de methode child() gebruiken om naar onderliggende items te navigeren met namen die zijn gebaseerd op een variabele of een expressie, zoals in het volgende voorbeeld wordt getoond:

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

Met het symbool @ (de operator voor kenmerkidentificatie) krijgt u toegang tot kenmerken in een object XML of een object XMLList, zoals wordt getoond in de volgende code:

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

U kunt het jokersymbool * gebruiken samen met het symbool @ om toegang te krijgen tot alle kenmerken van een object XML of een object XMLList, zoals wordt getoond in de volgende code:

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

Met de methoden attribute() of attributes() krijgt u toegang tot een specifiek kenmerk of tot alle kenmerken van een object XML of een object XMLList, zoals in de volgende code:

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

Met de volgende syntaxis krijgt u bovendien toegang tot kenmerken, zoals in het volgende voorbeeld wordt getoond:

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

Elk van deze is gelijk aan employee.@id . De syntaxis employee.@id heeft echter de voorkeur.

U kunt de ronde-haakjeoperatoren, ( en ) ) gebruiken om elementen met een specifieke elementnaam of kenmerkwaarde te filteren. Bekijk het volgende XML-object:

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>

De volgende expressies zijn allemaal geldig:

• x.employee.(lastName == "McGee") : dit is het tweede knooppunt employee .

• x.employee.(lastName == "McGee").firstName : dit is de eigenschap firstName van het tweede knooppunt employee .

• x.employee.(lastName == "McGee").@id : dit is de waarde van het kenmerk id van het tweede knooppunt employee .

• x.employee.(@id == 347) : het eerste knooppunt employee .

• x.employee.(@id == 347).lastName : dit is de eigenschap lastName van het eerste knooppunt employee .

• x.employee.(@id > 300) : dit is een XMLList met beide eigenschappen employee .

• x.employee.(position.toString().search("analyst") > -1) : dit is een XMLList met beide eigenschappen position .

Als u probeert te filteren op kenmerken of elementen die niet bestaan, treedt een uitzondering op. De laatste regel van de volgende code genereert bijvoorbeeld een fout omdat er geen kenmerk id bestaat in het tweede element p :

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

Op dezelfde manier genereert de laatste regel van de volgende code een fout omdat er geen eigenschap b bestaat van het tweede element p :

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

U kunt deze fouten vermijden door de eigenschappen die overeenkomende kenmerken of elementen hebben, te identificeren met de methoden attribute() en elements() , zoals in de volgende code:

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'));

U kunt ook de methode hasOwnProperty() gebruiken, zoals in de volgende code:

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 biedt ondersteuning voor de instructies for..in en for each..in om XMLList-objecten te doorlopen. Bekijk bijvoorbeeld het volgende XML-object ( myXML ) en het XMLList-object ( myXML.item ). Het XMLList-object ( myXML.item ) bestaat uit twee knooppunten item van het XML-object.

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>;

Met de lus for..in kunt u een set eigenschapnamen doorlopen in een XMLList:

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

Met de lus for each..in kunt u de eigenschappen doorlopen in de XMLList:

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