XML  - AS3

Legt fest, ob XML-Kommentare ignoriert werden, wenn XML-Objekte die XML-Quelldaten analysieren. Standardmäßig werden Kommentare ignoriert (true). Um XML-Kommentare einzubeziehen, rufen Sie false auf. Die ignoreComments-Eigenschaft wird nur während der XML-Analyse verwendet, nicht etwa beim Aufruf von Methoden, wie myXMLObject.child(*).toXMLString(). Enthält das XML-Quelldokument Kommentarknoten, werden sie während der XML-Analyse durch den Parser beibehalten oder verworfen.

Verwandte API-Elemente

XML.ignoreComments = false;
var xml1:XML = 
        <foo>
            <!-- comment -->
        </foo>;
trace(xml1.toXMLString()); // <foo><!-- comment --></foo>

XML.ignoreComments = true;
var xml2:XML = 
        <foo>
            <!-- example -->
        </foo>;
trace(xml2.toXMLString()); // <foo/>

Legt fest, ob XML-Verarbeitungsanweisungen ignoriert werden, wenn XML-Objekte die XML-Quelldaten analysieren. Standardmäßig werden Verarbeitungsanweisungen ignoriert (true). Um XML-Verarbeitungsanweisungen einzubeziehen, rufen Sie false auf. Die ignoreProcessingInstructions-Eigenschaft wird nur während der XML-Analyse verwendet, nicht etwa beim Aufruf von Methoden wie myXMLObject.child(*).toXMLString(). Enthält das XML-Quelldokument Verarbeitungsanweisungen, werden sie während der XML-Analyse durch den Parser beibehalten oder verworfen.

Verwandte API-Elemente

XML.ignoreProcessingInstructions = false;
var xml1:XML = 
        <foo>
            <?exampleInstruction ?>
        </foo>;
trace(xml1.toXMLString()); // <foo><?exampleInstruction ?></foo>

XML.ignoreProcessingInstructions = true;
var xml2:XML = 
        <foo>
            <?exampleInstruction ?>
        </foo>;
trace(xml2.toXMLString()); // <foo/>

Legt fest, ob während der Analyse durch den Parser Leerraumzeichen am Anfang und Ende von Textknoten ignoriert werden. Standardmäßig wird Leerraum ignoriert (true). Besteht ein Textknoten zu 100 % aus Leerraum und die ignoreWhitespace-Eigenschaft ist auf true gesetzt, wird der Knoten nicht erstellt. Um Leerraum in einem Textknoten anzuzeigen, setzen Sie die ignoreWhitespace-Eigenschaft auf false.

Wenn Sie ein XML-Objekt erstellen, wird der aktuelle Wert der ignoreWhitespace-Eigenschaft zwischengespeichert. Durch das Ändern von ignoreWhitespace wird das Verhalten von vorhandenen XML-Objekten nicht geändert.

XML.ignoreWhitespace = false;
var xml1:XML = <foo>    </foo>;
trace(xml1.children().length()); // 1

XML.ignoreWhitespace = true;
var xml2:XML = <foo>    </foo>;
trace(xml2.children().length()); // 0

Legt die Breite der Einrückung fest, die von den Methoden toString() und toXMLString() angewendet wird, wenn die XML.prettyPrinting-Eigenschaft auf true gesetzt ist. Die Einrückung wird mit dem Leerzeichen angewendet und nicht etwa mit dem Tabulatorzeichen. Der Standardwert ist 2.

Verwandte API-Elemente

var xml:XML = <foo><bar/></foo>;
XML.prettyIndent = 0;
trace(xml.toXMLString());

XML.prettyIndent = 1;
trace(xml.toXMLString());

XML.prettyIndent = 2;
trace(xml.toXMLString());

Legt fest, ob die Methoden toString() und toXMLString() Leerraumzeichen zwischen einigen Tags normalisieren. Der Standardwert ist true.

Verwandte API-Elemente

var xml:XML = <foo><bar/></foo>;
XML.prettyPrinting = false;
trace(xml.toXMLString());

XML.prettyPrinting = true;
trace(xml.toXMLString());

Erstellt ein neues XML-Objekt. Vor dem Aufruf einer Methode der XML-Klasse muss der Konstruktor zum Erstellen eines XML-Objekts verwendet werden.

Verwenden Sie die Methode toXMLString(), um das XML-Objekt als String zurückzugeben, und zwar unabhängig davon, ob das XML-Objekt einen einfachen oder komplexen Inhalt besitzt.

Verwandte API-Elemente

//
// Requires:
//   - TextArea control UI component in the Flash Professional Library.
//
import fl.controls.TextArea;
 
var xml:XML;
 
var urlRequest:URLRequest = new URLRequest("http://www.helpexamples.com/flash/xml/menu.xml");
 
var urlLoader:URLLoader = new URLLoader();
urlLoader.addEventListener(Event.COMPLETE, urlLoader_complete);
urlLoader.load(urlRequest);
 
var textArea:TextArea = new TextArea();
textArea.move(5, 5);
textArea.setSize(stage.stageWidth - 10, stage.stageHeight - 10);
addChild(textArea);
 
function urlLoader_complete(evt:Event):void {
    xml = new XML(evt.currentTarget.data);
    textArea.text = xml.toXMLString();
}

var xml:XML;
var textArea:TextField = new TextField();
textArea.width = 300;
 
var urlRequest:URLRequest = new URLRequest("http://www.helpexamples.com/flash/xml/menu.xml");
var urlLoader:URLLoader = new URLLoader();
urlLoader.dataFormat = URLLoaderDataFormat.TEXT;
urlLoader.addEventListener(Event.COMPLETE, urlLoader_complete);
urlLoader.load(urlRequest);
 
function urlLoader_complete(evt:Event):void {
    xml = new XML(evt.target.data);
    textArea.text = xml.toXMLString();
    addChild(textArea);
}

Erweitert den Satz an gültigen Namespaces für das XML-Objekt um einen Namespace. Existiert der Namespace bereits im Namespace-Gültigkeitsbereich für das XML-Objekt (mit dem Präfix aus dem angegebenen Parameter), so wird das Präfix des bereits vorhandenen Namespaces auf undefined gesetzt. Handelt es sich beim Eingabeparameter um ein Namespace-Objekt, wird es direkt verwendet. Handelt es sich um ein QName-Objekt, wird der URI des Eingabeparameters verwendet, um einen neuen Namespace zu erstellen; andernfalls wird es in einen String konvertiert und der Namespace wird aus diesem String erstellt.

Parameter

var xml1:XML = <ns:foo xmlns:ns="www.example.com/ns" />;
var nsNamespace:Namespace = xml1.namespace();

var xml2:XML = <bar />;
xml2.addNamespace(nsNamespace);
trace(xml2.toXMLString()); // <bar xmlns:ns="www.example.com/ns"/>

Hängt das angegebene untergeordnete Objekt ans Ende der Eigenschaften des XML-Objekts an. Die Methode appendChild() akzeptiert ein XML-Objekt, ein XMLList-Objekt oder einen anderen Datentyp, der dann in einen String konvertiert wird.

Verwenden Sie den Operator delete, um den XML-Knoten zu entfernen.

Parameter

Verwandte API-Elemente

var xml:XML = 
        <body>
            <p>hello</p>
        </body>;
        
xml.appendChild(<p>world</p>);    
trace(xml.p[0].toXMLString()); // <p>hello</p>
trace(xml.p[1].toXMLString()); // <p>world</p>

Gibt den XML-Wert des Attributs zurück, das den mit dem Parameter attributeName übereinstimmenden Namen besitzt. Attribute befinden sich innerhalb von XML-Elementen. Im folgenden Beispiel hat das Element ein Attribut mit dem Namen "gender" und dem Wert "boy": <first gender="boy">John</first>.

Der Parameter attributeName kann einen beliebigen Datentyp besitzen; allerdings ist String der am häufigsten verwendete Datentyp. Wenn Sie ein beliebiges Objekt übergeben, das kein QName-Objekt ist, verwendet der Parameter attributeName die Methode toString(), um den Parameter in einen String zu konvertieren.

Wenn Sie eine qualifizierte Namensreferenz benötigen, können Sie ein QName-Objekt übergeben. Ein QName-Objekt definiert einen Namespace und den lokalen Namen, den Sie verwenden können, um den qualifizierten Namen eines Attributs zu definieren. Daher ist es nicht dasselbe, ob Sie attribute(qname) oder attribute(qname.toString()) aufrufen.

Parameter

Verwandte API-Elemente

 var xml:XML = <ns:node xmlns:ns = "http://uri" ns:attr = '7' />       
 var qn:QName = new QName("http://uri", "attr");
 trace (xml.attribute(qn)); // 7

 var xml:XML = <example class="first" />
 trace(xml.attribute("class"));
 

Gibt eine Liste von Attributwerten für ein bestimmtes XML-Objekt zurück. Verwenden Sie die Methode name() mit der Methode attributes(), um den Namen eines Attributs zurückzugeben. Die Verwendung von xml.attributes() entspricht xml.@*.

Verwandte API-Elemente

var xml:XML=<example id='123' color='blue'/>
trace(xml.attributes()[1].name()); //color

 
var xml:XML = <example id='123' color='blue'/>
var attNamesList:XMLList = xml.@*;

trace (attNamesList is XMLList); // true
trace (attNamesList.length()); // 2

for (var i:int = 0; i < attNamesList.length(); i++)
{ 
    trace (typeof (attNamesList[i])); // xml
    trace (attNamesList[i].nodeKind()); // attribute
    trace (attNamesList[i].name()); // id and color
} 

Listet die untergeordneten Knoten eines XML-Objekts auf. Bei einem untergeordneter XML-Knoten kann es sich um ein XML-Element, einen Textknoten, einen Kommentar oder eine Verarbeitungsanweisung handeln.

Verwenden Sie den Parameter propertyName, um den Inhalt eines bestimmten untergeordneten XML-Knotens aufzulisten. Um zum Beispiel den Inhalt eines untergeordneten Elements mit dem Namen <first>, zurückzugeben, rufen Sie child("first") für das XML-Objekt auf. Sie erzeugen dasselbe Ergebnis, wenn Sie die Indexnummer des untergeordneten Knotens verwenden. Die Indexnummer identifiziert die Position des untergeordneten Knotens in der Liste weiterer untergeordneter XML-Knoten. child(0) beispielsweise gibt den ersten untergeordneten Knoten in einer Liste zurück.

Verwenden Sie ein Sternchen (*), um alle untergeordneten Knoten eines XML-Dokuments auszugeben. Zum Beispiel doc.child("*").

Verwenden Sie die Methode length() mit dem Sternparameter (*) der Methode child(), um die Gesamtanzahl der untergeordneten Knoten auszugeben. Zum Beispiel numChildren = doc.child("*").length().

Parameter

Verwandte API-Elemente

var xml:XML = 
        <foo>
            <bar>text1</bar>
            <bar>text2</bar>
        </foo>;
trace(xml.child("bar").length());  // 2
trace(xml.child("bar")[0].toXMLString()); // <bar>text1</bar>
trace(xml.child("bar")[1].toXMLString()); // <bar>text2</bar>

Identifiziert die nullindizierte Position dieses XML-Objekts innerhalb des Kontexts des übergeordneten Objekts.

var xml:XML = 
            <foo>
                <bar />
                text
                <bob />
            </foo>;
trace(xml.bar.childIndex()); // 0
trace(xml.bob.childIndex()); // 2

Listet die untergeordneten Knoten des XML-Objekts auf, und zwar in der Reihenfolge, in der sie erscheinen. Bei einem untergeordneter XML-Knoten kann es sich um ein XML-Element, einen Textknoten, einen Kommentar oder eine Verarbeitungsanweisung handeln.

XML.ignoreComments = false;
XML.ignoreProcessingInstructions = false;
var xml:XML = 
        <foo id="22">
            <bar>44</bar>
            text
            <!-- comment -->
            <?instruction ?>
        </foo>;
trace(xml.children().length()); // 4
trace(xml.children()[0].toXMLString()); // <bar>44</bar>
trace(xml.children()[1].toXMLString()); // text
trace(xml.children()[2].toXMLString()); // <!-- comment -->
trace(xml.children()[3].toXMLString()); // <?instruction ?>

Listet die Eigenschaften des XML-Objekts auf, die XML-Kommentare enthalten.

XML.ignoreComments = false;
var xml:XML = 
        <foo>
            <!-- example -->
            <!-- example2 -->
        </foo>;
trace(xml.comments().length()); // 2
trace(xml.comments()[1].toXMLString()); // <!-- example2 -->

Vergleicht das XML-Objekt mit dem angegebenen value-Parameter.

Parameter

var xml:XML = 
        <order>
            <item>Rice</item>
            <item>Kung Pao Shrimp</item>
        </order>;
trace(xml.item[0].contains(<item>Rice</item>)); // true
trace(xml.item[1].contains(<item>Kung Pao Shrimp</item>)); // true
trace(xml.item[1].contains(<item>MSG</item>)); // false

Gibt eine Kopie des gegebenen XML-Objekts zurück. Die Kopie ist ein Duplikat der gesamten Knotenbaumstruktur. Das kopierte XML-Objekt hat kein übergeordnetes Objekt und gibt den Wert null zurück, wenn Sie versuchen, die parent()-Methode aufzurufen.

var xml1:XML = <foo />;
var xml2:XML = xml1.copy();
xml2.appendChild(<bar />);
trace(xml1.bar.length()); // 0
trace(xml2.bar.length()); // 1

Gibt ein Objekt zurück, bei dem die folgenden Eigenschaften auf die Standardwerte gesetzt sind: ignoreComments, ignoreProcessingInstructions, ignoreWhitespace, prettyIndent und prettyPrinting. Die Standardwerte lauten wie folgt:

• ignoreComments = true
• ignoreProcessingInstructions = true
• ignoreWhitespace = true
• prettyIndent = 2
• prettyPrinting = true

Hinweis: Sie wenden diese Methode nicht auf eine Instanz der XML-Klasse an, sondern, wie im folgenden Code gezeigt, auf XML: var df:Object = XML.defaultSettings().

Verwandte API-Elemente

XML.ignoreComments = false;
XML.ignoreProcessingInstructions = false;
var customSettings:Object = XML.settings();

var xml1:XML = 
        <foo>
            <!-- comment -->
            <?instruction ?>
        </foo>;
trace(xml1.toXMLString());
//    <foo>
//        <!-- comment -->
//         <?instruction ?>
//    </foo>

XML.setSettings(XML.defaultSettings());
var xml2:XML = 
        <foo>
            <!-- comment -->
            <?instruction ?>
        </foo>;
trace(xml2.toXMLString());

Gibt alle untergeordneten Elemente (direkt untergeordnete und über mehrere Zweige hinweg untergeordnete Knoten) des XML-Objekts zurück, die dem gegebenen name-Parameter entsprechen. Der Parameter name ist optional. Der name-Parameter kann ein QName-Objekt sein, ein Objekt des Datentyps String oder jeglichen sonstigen Datentyps, der sich in einen String konvertieren lässt.

Um alle untergeordneten Elemente zurückzugeben, verwenden Sie den Sternparameter (*). Wird kein Parameter übergeben, wird der String „*“ übergeben, sodass alle untergeordneten Elemente des XML-Objekts zurückgegeben werden.

Parameter

Verwandte API-Elemente

var xml:XML = 
  <enrollees>
    <student id="239">
        <class name="Algebra" />
        <class name="Spanish 2"/>
    </student>
    <student id="206">
        <class name="Trigonometry" />
        <class name="Spanish 2" />
    </student>
  </enrollees>
trace(xml.descendants("class")); 

XML.ignoreComments = false;
var xml:XML = 
        <body>
            <!-- comment -->
            text1
            <a>
                <b>text2</b>
            </a>
        </body>;
trace(xml.descendants("*").length()); // 5
trace(xml.descendants("*")[0]); // // <!-- comment -->
trace(xml.descendants("*")[1].toXMLString()); // text1
trace(xml.descendants("a").toXMLString()); // <a><b>text2</b></a>
trace(xml.descendants("b").toXMLString()); // <b>text2</b>

Listet die Elemente eines XML-Objekts auf. Ein Element besteht aus einem Start- und End-Tag, z. B. <first></first>. Der Parameter name ist optional. Der name-Parameter kann ein QName-Objekt sein, ein Objekt des Datentyps String oder jeglichen sonstigen Datentyps, der sich in einen String konvertieren lässt. Verwenden Sie den Parameter name, um ein bestimmtes Element aufzulisten. Im folgenden Beispiel gibt das Element "first" beispielsweise "John" zurück: <first>John</first>.

Um alle Element zurückzugeben, verwenden Sie das Sternchen (*) als Parameter. Das Sternchen ist auch der Standardparameter.

Verwenden Sie die Methode length() mit dem Sternparameter (*), um die Gesamtanzahl der Elemente auszugeben. Beispielsweise numElement = addressbook.elements("*").length().

Parameter

Verwandte API-Elemente

var xml:XML = 
        <foo>
            <!-- comment -->
            <?instruction ?>
            text
            <a>1</a>
            <b>2</b>
        </foo>;
trace(xml.elements("*").length()); // 2
trace(xml.elements("*")[0].toXMLString()); // <a>1</a>
trace(xml.elements("b").length()); // 1
trace(xml.elements("b")[0].toXMLString()); // <b>2</b>

var xml:XML =
 <student id="206">
    <class name="Trigonometry" />
    <class name="Spanish 2" />
 </student>
trace(xml.elements("class")); 

Prüft, ob das XML-Objekt komplexen Inhalt enthält. Ein XML-Objekt enthält komplexen Inhalt, wenn es untergeordnete Elemente besitzt. XML-Objekte, die Attribute, Kommentare, Verarbeitungsanweisungen oder Textknoten repräsentieren, haben keinen komplexen Inhalt. Doch auch ein Objekt, das diese Knoten enthält, kann komplexen Inhalt haben (nämlich wenn es zudem untergeordnete Elemente besitzt).

Verwandte API-Elemente

var xml:XML = 
        <foo>
            <a>
                text
            </a>
            <a>
                <b/>
            </a>
        </foo>;
trace(xml.a[0].hasComplexContent()); // false
trace(xml.a[1].hasComplexContent()); // true

trace(xml.a[0].hasSimpleContent()); // true
trace(xml.a[1].hasSimpleContent()); // false

Überprüft, ob die Eigenschaft des Objekts vom Parameter p angegeben wird.

Parameter

var xml:XML = 
        <foo>
            <a />
            <a>
                <b>10</b>
            </a>
            <a>
                <b>11</b>
            </a>
        </foo>;
trace(xml.a.(hasOwnProperty("b") && b == "11")); 

trace(xml.a.(b == "11"));

var xml:XML = 
        <orders>
            <order id='1'>
                <item>toothbrush</item>
                <item>toothpaste</item>
            </order>
            <order>
                <returnItem>shoe polish</returnItem>
            </order>
        </orders>;
trace(xml.order.(hasOwnProperty("item") && item.contains("toothbrush"))); 

Prüft, ob das XML-Objekt komplexen Inhalt enthält. Ein XML-Objekt enthält einfachen Inhalt, wenn es einen Textknoten, einen Attributknoten oder ein XML-Element ohne untergeordnete Elemente enthält. XML-Objekte, die Kommentare und Verarbeitungsanweisungen repräsentieren, enthalten keinen einfachen Inhalt.

Verwandte API-Elemente

var xml:XML = 
        <foo>
            <a>
                text
            </a>
            <a>
                <b/>
            </a>
        </foo>;
trace(xml.a[0].hasComplexContent()); // false
trace(xml.a[1].hasComplexContent()); // true

trace(xml.a[0].hasSimpleContent()); // true
trace(xml.a[1].hasSimpleContent()); // false

Listet, basierend auf dem übergeordneten Objekt, die Namespaces für das XML-Objekt auf.

Fügt den gegebenen child2-Parameter nach dem child1-Parameter in dieses XML-Objekt ein, und gibt das resultierende Objekt zurück. Hat der Parameter child1 den Wert null, fügt die Methode den Inhalt des Parameters child2 vor allen untergeordneten Knoten des XML-Objekts ein (oder anders ausgedrückt: nach none). Hat child1 jedoch einen Wert, existiert aber nicht im XML-Objekt, wird das XML-Objekt nicht geändert und es wird undefined zurückgegeben.

Wenn Sie diese Methode für einen untergeordneten XML-Knoten aufrufen, der kein Element ist (sondern Text, Attribut, Kommentar oder Verarbeitungsanweisung), so wird undefined zurückgegeben.

Verwenden Sie den Operator delete, um den XML-Knoten zu entfernen.

Parameter

Verwandte API-Elemente

var xml:XML = 
        <menu>
            <item>burger</item>
            <item>soda</item>
        </menu>;
xml.insertChildAfter(xml.item[0], <saleItem>fries</saleItem>);
trace(xml);

 <menu>
     <item>burger</item>
     <saleItem>fries</saleItem>
     <item>soda</item>
 </menu>

Fügt den gegebenen child2-Parameter vor dem child1-Parameter in dieses XML-Objekt ein und gibt das resultierende Objekt zurück. Hat der Parameter child1 den Wert null, fügt die Methode den Inhalt des Parameters child2 nach allen untergeordneten Knoten des XML-Objekts ein (oder anders ausgedrückt: vor none). Hat child1 jedoch einen Wert, existiert aber nicht im XML-Objekt, wird das XML-Objekt nicht geändert und es wird undefined zurückgegeben.

Wenn Sie diese Methode für einen untergeordneten XML-Knoten aufrufen, der kein Element ist (sondern Text, Attribut, Kommentar oder Verarbeitungsanweisung), so wird undefined zurückgegeben.

Verwenden Sie den Operator delete, um den XML-Knoten zu entfernen.

Parameter

Verwandte API-Elemente

var xml:XML = 
        <menu>
            <item>burger</item>
            <item>soda</item>
        </menu>;
xml.insertChildBefore(xml.item[0], <saleItem>fries</saleItem>);
trace(xml);

 <menu>
     <saleItem>fries</saleItem>
     <item>burger</item>
     <item>soda</item>
 </menu>

Für XML-Objekte gibt diese Methode immer die Ganzzahl 1 zurück. Die length()-Methode der XMLList-Klasse gibt für ein XMLList-Objekt, das nur einen Wert enthält, den Wert 1 zurück.

Gibt den Lokalteil des qualifizierten Namens des XML-Objekts zurück.

var xml:XML = 
        <soap:Envelope xmlns:soap="http://www.w3.org/2001/12/soap-envelope"
            soap:encodingStyle="http://www.w3.org/2001/12/soap-encoding">

                        <soap:Body xmlns:wx = "http://example.com/weather">
                <wx:forecast>
                    <wx:city>Quito</wx:city>
                </wx:forecast>
            </soap:Body>
        </soap:Envelope>;
        
trace(xml.localName()); // Envelope

Gibt den qualifizierten Namen des XML-Objekts zurück.

Verwandte API-Elemente

var xml:XML = 
        <soap:Envelope xmlns:soap="http://www.w3.org/2001/12/soap-envelope"
            soap:encodingStyle="http://www.w3.org/2001/12/soap-encoding">

                        <soap:Body xmlns:wx = "http://example.com/weather">
                <wx:forecast>
                    <wx:city>Quito</wx:city>
                </wx:forecast>
            </soap:Body>
        </soap:Envelope>;
        
trace(xml.name().localName); // Envelope
trace(xml.name().uri); // "http://www.w3.org/2001/12/soap-envelope"

var xml:XML = 
        <foo x="15" y="22">
            text
        </foo>;
        
trace(xml.name().localName); // foo
trace(xml.name().uri == ""); // true
trace(xml.children()[0]); // text
trace(xml.children()[0].name()); // null
trace(xml.attributes()[0]); // 15
trace(xml.attributes()[0].name()); // x

Wenn kein Parameter angegeben wird, gibt diese Methode den mit dem qualifizierten Namen dieses XML-Objekts verbundenen Namespace zurück. Wird ein prefix-Parameter angegeben, gibt die Methode den Namespace zurück, der dem prefix-Parameter entspricht und sich im Gültigkeitsbereich des XML-Objekts befindet. Gibt es keinen solchen Namespace, gibt die Methode den Wert undefined zurück.

Parameter

var xml:XML = 
        <soap:Envelope xmlns:soap="http://www.w3.org/2001/12/soap-envelope"
            soap:encodingStyle="http://www.w3.org/2001/12/soap-encoding">

                        <soap:Body xmlns:wx = "http://example.com/weather">
                <wx:forecast>
                    <wx:city>Quito</wx:city>
                </wx:forecast>
            </soap:Body>
        </soap:Envelope>;
        
var soap:Namespace = xml.namespace();
trace(soap.prefix); // soap
trace(soap.uri); // http://www.w3.org/2001/12/soap-envelope

var body:XML = xml.soap::Body[0];
trace(body.namespace().prefix); // soap
trace(xml.namespace().uri); // http://www.w3.org/2001/12/soap-envelope
trace(body.namespace("wx").uri); // "http://example.com/weather"

var xml:XML = 
        <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" 
            xmlns:dc="http://purl.org/dc/elements/1.1/" 
            xmlns="http://purl.org/rss/1.0/">
                <!-- ... -->
        </rdf:RDF>;
                    
trace(xml.namespace()); // http://www.w3.org/1999/02/22-rdf-syntax-ns#
trace(xml.namespace("dc")); // http://purl.org/dc/elements/1.1/
trace(xml.namespace("foo")); // undefined

Listet Namespace-Deklarationen auf, die mit dem XML-Objekt im Kontext des übergeordneten Knotens verbunden wurden.

Verwandte API-Elemente

var xml:XML = 
        <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" 
            xmlns:dc="http://purl.org/dc/elements/1.1/" 
            xmlns="http://purl.org/rss/1.0/">

            <!-- ... -->
            
        </rdf:RDF>;
                    
for (var i:uint = 0; i < xml.namespaceDeclarations().length; i++) {
    var ns:Namespace = xml.namespaceDeclarations()[i]; 
    var prefix:String = ns.prefix;
    if (prefix == "") {
        prefix = "(default)";
    }
    trace(prefix + ":" , ns.uri);
}

rdf: http://www.w3.org/1999/02/22-rdf-syntax-ns#
 dc: http://purl.org/dc/elements/1.1/
 (default): http://purl.org/rss/1.0/

Gibt den Typ des Knotens an: Text-, Kommentar-, Verarbeitungsanweisungs-, Attribut- oder Elementknoten.

Verwandte API-Elemente

XML.ignoreComments = false;
XML.ignoreProcessingInstructions = false;

var xml:XML = 
    <example id="10">
        <!-- this is a comment -->
        <?test this is a pi ?>
        and some text
    </example>;

trace(xml.nodeKind()); // element
trace(xml.children()[0].nodeKind()); // comment
trace(xml.children()[1].nodeKind()); // processing-instruction
trace(xml.children()[2].nodeKind()); // text
trace(xml.@id[0].nodeKind()); // attribute

Für das XML-Objekt und alle seine untergeordneten Elemente werden benachbarte Textknoten zusammengeführt und leere Textknoten entfernt.

var xml:XML = <body></body>;
xml.appendChild("hello");
xml.appendChild(" world");
trace(xml.children().length()); // 2
xml.normalize();
trace(xml.children().length()); // 1

Gibt den übergeordneten Knoten des XML-Objekts zurück. Besitzt das XML-Objekt keinen übergeordneten Knoten, gibt die Methode den Wert undefined zurück.

var xml:XML = 
    <body>
        <p id="p1">Hello</p>
        <p id="p2">Test:
            <ul>
                <li>1</li>
                <li>2</li>
            </ul>
        </p>
    </body>;
var node:XML = xml.p.ul.(li.contains("1"))[0]; // == <ul> ... </ul>
trace(node.parent().@id); // p2

Fügt eine Kopie des bereitgestellten child-Objekts vor irgendwelchen vorhandenen XML-Eigenschaften für dieses Element in das XML-Element ein.

Verwenden Sie den Operator delete, um den XML-Knoten zu entfernen.

Parameter

Verwandte API-Elemente

var xml:XML = 
        <body>
            <p>hello</p>
        </body>;
        
xml.prependChild(<p>world</p>);    
trace(xml.p[0].toXMLString()); // <p>world</p>
trace(xml.p[1].toXMLString()); // <p>hello</p>

Wird ein name-Parameter bereitgestellt, werden alle untergeordneten Knoten des XML-Objekts aufgelistet, die Verarbeitungsanweisungen mit diesem Namen (name) enthalten. Ohne Parameter listet diese Methode alle untergeordneten Knoten des XML-Objekts auf, die irgendwelche Verarbeitungsanweisungen enthalten.

Parameter

XML.ignoreProcessingInstructions = false;
var xml:XML =
    <body>
            foo
            <?xml-stylesheet href="headlines.css" type="text/css" ?>
            <?instructionX ?>
            
    </body>;

trace(xml.processingInstructions().length()); // 2
trace(xml.processingInstructions()[0].name()); // xml-stylesheet

Prüft, ob sich die Eigenschaft p in dem Satz an Eigenschaften befindet, die in einer auf das XML-Objekt angewendeten for..in-Anweisung durchlaufen werden können. Gibt nur true zurück, wenn toString(p) == "0".

Parameter

var xml:XML = 
        <body>
             <p>Hello</p>
               <p>World</p>
        </body>;

trace(xml.propertyIsEnumerable(0)); // true
trace(xml.propertyIsEnumerable(1)); // false

for (var propertyName:String in xml) {
    trace(xml[propertyName]);
}

var list:XMLList = xml.p;
trace(list.propertyIsEnumerable(0)); // true
trace(list.propertyIsEnumerable(1)); // true
trace(list.propertyIsEnumerable(2)); // false

for (var propertyName:String in list) { 
    trace(list[propertyName]);
}

Entfernt den gegebenen Namespace für dieses Objekt und alle untergeordneten Elemente. Die removeNamespaces()-Methode entfernt keinen Namespace, wenn vom qualifizierten Namen des Objekts darauf verwiesen wird oder vom qualifizierten Namen des Objektattributs.

Parameter

var xml:XML = 
    <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" 
        xmlns:dc="http://purl.org/dc/elements/1.1/" 
        xmlns="http://purl.org/rss/1.0/">
    
        <!-- ... -->
        
    </rdf:RDF>;

trace(xml.namespaceDeclarations().length); // 3
trace(xml.namespaceDeclarations()[0] is String); // 
var dc:Namespace = xml.namespace("dc");
xml.removeNamespace(dc);
trace(xml.namespaceDeclarations().length); // 2

Ersetzt die im Parameter propertyName angegebenen Eigenschaften durch den gegebenen value-Parameter. Werden keine Eigenschaften gefunden, die mit propertyName übereinstimmen, bleibt das XML-Objekt unverändert.

Parameter

var xml:XML = 
    <body>
        <p>Hello</p>
        <p>World</p>
        <hr/>
    </body>;

xml.replace(1, <p>Bob</p>);
trace(xml);

 <body>
     <p>Hello</p>
     <p>Bob</p>
     <hr/>
 </body>
 

var xml:XML = 
    <body>
        <p>Hello</p>
        <p>World</p>
        <hr/>
    </body>;

xml.replace("p", <p>Hi</p>); 
trace(xml);

 <body>
     <p>Hi</p>
     <hr/>
 </body>;
 

var xml:XML = 
    <ns:body xmlns:ns = "myNS">
        <ns:p>Hello</ns:p>
        <ns:p>World</ns:p>
        <hr/>
    </ns:body>;

var qname:QName = new QName("myNS", "p");
xml.replace(qname, <p>Bob</p>);
trace(xml);

 <ns:body xmlns:ns = "myNS">
     <p>Bob</p>
     <hr/>
 </ns:body>
 

var xml:XML = 
    <body>
        <p>Hello</p>
        <p>World</p>
        <hr/>
    </body>;

xml.replace("*", <img src = "hello.jpg"/>);
trace(xml);

 <body>
     <img src="hello.jpg"/>
 </body>
 

Ersetzt die untergeordneten Eigenschaften des XML-Objekts durch das angegebene Set an XML-Eigenschaften, das im Parameter value bereitgestellt wird.

Parameter

var xml:XML = 
    <body>
        <p>Hello</p>
        <p>World</p>
    </body>;

var list:XMLList = xml.p;

xml.setChildren(<p>hello</p>);
trace(xml);

//    <body>
//        <p>hello</p>
//    </body>

xml.setChildren(list);
trace(xml);

//    <body>
//        <p>Hello</p>
//        <p>World</p>
//    </body>

Ändert den Lokalteil des XML-Objektnamens in den gegebenen name-Parameter.

Parameter

var xml:XML = 
    <ns:item xmlns:ns="http://example.com">
        toothbrush
    </ns:item>;
    
xml.setLocalName("orderItem");
trace(xml.toXMLString()); // <ns:orderItem xmlns:ns="http://example.com">toothbrush</ns:orderItem>

Setzt den Namen des XML-Objekts auf den gegebenen qualifizierten Namen oder Attributnamen.

Parameter

var xml:XML = 
    <item>
        toothbrush
    </item>;
    
xml.setName("orderItem");
trace(xml.toXMLString()); // <orderItem>toothbrush</orderItem>

Setzt den mit dem XML-Objekt verbundenen Namespace.

Parameter

var xml1:XML = 
        <soap:Envelope xmlns:soap="http://www.w3.org/2001/12/soap-envelope"
            soap:encodingStyle="http://www.w3.org/2001/12/soap-encoding">
            <!-- ... -->
        </soap:Envelope>;
var ns:Namespace = xml1.namespace("soap");

var xml2:XML = 
    <Envelope>
        <Body/>
    </Envelope>;
    
xml2.setNamespace(ns);

trace(xml2);

Setzt die Werte für die folgenden XML-Eigenschaften: ignoreComments, ignoreProcessingInstructions, ignoreWhitespace, prettyIndent und prettyPrinting. Im folgenden sind die Standardeinstellungen aufgelistet, die anwendet werden, wenn kein setObj-Parameter bereitgestellt wird.

• XML.ignoreComments = true
• XML.ignoreProcessingInstructions = true
• XML.ignoreWhitespace = true
• XML.prettyIndent = 2
• XML.prettyPrinting = true

Hinweis: Sie wenden diese Methode nicht auf eine Instanz der XML-Klasse an, sondern auf XML, wie im folgenden Code gezeigt: XML.setSettings().

Parameter

Verwandte API-Elemente

XML.ignoreComments = false;
XML.ignoreProcessingInstructions = false;
var customSettings:Object = XML.settings();

var xml1:XML = 
        <foo>
            <!-- comment -->
            <?instruction ?>
        </foo>;
trace(xml1.toXMLString());
//    <foo>
//        <!-- comment -->
//         <?instruction ?>
//    </foo>

XML.setSettings(XML.defaultSettings());
var xml2:XML = 
        <foo>
            <!-- comment -->
            <?instruction ?>
        </foo>;
trace(xml2.toXMLString());

Ruft die folgenden Eigenschaften ab: ignoreComments, ignoreProcessingInstructions, ignoreWhitespace, prettyIndent und prettyPrinting.

Verwandte API-Elemente

XML.ignoreComments = false;
XML.ignoreProcessingInstructions = false;
var customSettings:Object = XML.settings();

var xml1:XML = 
        <foo>
            <!-- comment -->
            <?instruction ?>
        </foo>;
trace(xml1.toXMLString());
//    <foo>
//        <!-- comment -->
//         <?instruction ?>
//    </foo>

XML.setSettings(XML.defaultSettings());
var xml2:XML = 
        <foo>
            <!-- comment -->
            <?instruction ?>
        </foo>;
trace(xml2.toXMLString());

Gibt ein XMLList-Objekt zurück mit allen XML-Eigenschaften des XML-Objekts, die XML-Textknoten darstellen.

var xml:XML =
        <body>
            text1
            <hr/>
            text2
        </body>;
trace(xml.text()[0]); // text1
trace(xml.text()[1]); // text2

Stellt eine überschreibbare Methode zum Anpassen der JSON-Kodierung von Werten in einem XML-Objekt bereit.

Die JSON.stringify()-Methode sucht bei jedem Objekt, das untersucht wird, nach einer toJSON()-Methode. Wenn die toJSON()-Methode gefunden wird, ruft JSON.stringify() diese für jeden gefundenen Wert auf und übergibt dabei den Schlüssel, der diesem Wert zugeordnet ist.

XML stellt eine standardmäßige Implementierung von toJSON() bereit, die einfach den Namen der Klasse zurückgibt. Kunden, die XML-Objekte für JSON exportieren möchten, müssen ihre eigene Implementierung verwenden. Dazu können Sie die toJSON()-Methode für den Klassenprototyp neu definieren.

Die toJSON()-Methode kann einen Wert eines beliebigen Typs zurückgeben. Wenn sie ein Objekt zurückgibt, führt stringify() eine Rekursion in dieses Objekt aus. Wenn toJSON() einen String zurückgibt, führt stringify() keine Rekursion aus und setzt die Untersuchung fort.

Parameter

Verwandte API-Elemente

Gibt das XML-Objekt als String zurück. Nach welchen Regeln diese Konvertierung vollzogen wird, ist abhängig davon, ob das XML-Objekt einen einfachen oder komplexen Inhalt hat:

• Hat das XML-Objekt einen einfachen Inhalt, gibt toString() den String-Inhalt des XML-Objekts zurück, wobei das Start-Tag, vorhandene Attribute, Namespace-Deklarationen und das Endtag entfernt werden.

• Hat das XML-Objekt einen komplexen Inhalt, gibt toString() das gesamte XML-Objekt als XML-kodierten String zurück, einschließlich Start-Tag, Attributen, Namespace-Deklarationen und End-Tag.

Damit jedes Mal das gesamte XML-Objekt zurückgegeben wird, verwenden Sie die Methode toXMLString().

Verwandte API-Elemente

var test:XML = <type name="Joe">example</type>;
trace(test.toString()); //example

var test:XML = 
<type name="Joe">
    <base name="Bob"></base>
    example
</type>;
trace(test.toString());
  // <type name="Joe">
  // <base name="Bob"/>
  // example
  // </type> 

Gibt das XML-Objekt als String zurück. Im Gegensatz zur Methode toString() gibt die Methode toXMLString() immer das Start-Tag, vorhandene Attribute und das End-Tag des XML-Objekts zurück, unabhängig davon, ob das XML-Objekt einen einfachen oder komplexen Inhalt hat. (Die Methode toString() entfernt alle diese Elemente für XML-Objekte mit einfachem Inhalt.)

Verwandte API-Elemente

var xml:XML =
        <p>hello</p>;
trace(xml); // hello
trace(xml.toXMLString()); // <p>hello</p>

Gibt das XML-Objekt zurück.

var xml:XML = <p>hello</p>;
trace(xml.valueOf() === xml); // true