Determina si los comentarios XML se ignoran cuando los objetos XML analizan los datos XML de origen. De forma predeterminada, los comentarios se ignoran (true). Para incluir comentarios XML, establezca esta propiedad con el valor false. La propiedad ignoreComments sólo se utiliza durante el análisis XML, no durante la llamada a métodos tales como myXMLObject.child(*).toXMLString(). Si el XML de origen incluye nodos de comentarios, éstos se mantendrán o se eliminarán durante el análisis XML.

Véase también

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

Determina si las instrucciones de procesamiento XML se ignoran cuando los objetos XML analizan los datos XML de origen. De forma predeterminada, las instrucciones de procesamiento se ignoran (true). Para incluir instrucciones de procesamiento XML, establezca esta propiedad con el valor false. La propiedad ignoreProcessingInstructions sólo se utiliza durante el análisis XML, no durante la llamada a métodos tales como myXMLObject.child(*).toXMLString(). Si el XML de origen incluye nodos de instrucciones de procesamiento, éstos se mantendrán o se eliminarán durante el análisis XML.

Véase también

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

Determina si los caracteres de espacio en blanco situados al comienzo y al final de los nodos de texto deben ignorarse durante el análisis. De manera predeterminada, el espacio en blanco se ignora (true). Si un nodo de texto es espacio en blanco al 100% y la propiedad ignoreWhitespace se define en el valor true, el nodo no se creará. Para mostrar el espacio en blanco en un nodo de texto, defina la propiedad ignoreWhitespace con el valor false.

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

Determina la cantidad de sangría que se aplica a los métodos toString() y toXMLString() cuando la propiedad XML.prettyPrinting se define con el valor true. La sangría se aplica con el carácter de espacio, no con el carácter de tabulador. El valor predeterminado es 2.

Véase también

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

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

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

Determina si los métodos toString() y toXMLString() normalizan los caracteres de espacio en blanco existentes entre algunas etiquetas. El valor predeterminado es true.

Véase también

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

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

Crea un nuevo objeto XML. Deberá utilizar el constructor para crear un objeto XML antes de llamar a cualquiera de los métodos de la clase XML.

Utilice el método toXMLString() para que se devuelva una representación de cadena del objeto XML, con independencia de si el objeto XML tiene contenido simple o complejo.

Véase también

Añade un espacio de nombres al conjunto de espacios de nombres del ámbito para el objeto XML. Si el espacio de nombres ya existe en los espacios de nombres del ámbito para el objeto XML (con un prefijo que coincide con el del parámetro especificado), el prefijo del espacio de nombres existente se establece en undefined. Si el parámetro de entrada es un objeto Namespace, éste se utiliza directamente. Si es un objeto QName, el URI del parámetro de entrada se utiliza para crear un nuevo espacio de nombres; en caso contrario, se convierte a una cadena y se crea un espacio de nombres a partir de la cadena.

Parámetros

Véase también

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"/>

Añade el elemento secundario en cuestión al final de las propiedades del objeto XML. El método appendChild() toma un objeto XML, un objeto XMLList o cualquier otro tipo de datos que luego se convierte a String.

Utilice el operador delete (XML) para eliminar nodos XML.

Parámetros

Véase también

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>

Devuelve el valor XML del atributo cuyo nombre coincide con el parámetro attributeName. Los atributos se encuentran dentro de los elementos XML. En el ejemplo siguiente, el elemento tiene un atributo llamado "gender" con el valor "boy": <first gender="boy">John</first>.

El parámetro attributeName puede tener cualquier tipo de datos; sin embargo, el tipo de datos que suele utilizarse es String. Al pasar cualquier objeto que no sea un objeto QName, el parámetro attributeName utiliza el método toString() para convertir el parámetro en una cadena.

Si necesita una referencia de nombre completa, puede pasar un objeto QName. Un objeto QName define un espacio de nombre y el nombre local, que puede utilizar para definir el nombre completo de un atributo. Por consiguiente, llamar a attribute(qname) no es lo mismo que llamar a attribute(qname.toString()).

Parámetros

Véase también

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

Devuelve una lista de valores de atributos para el objeto XML en cuestión. Utilice el método name() con el método attributes() para que se devuelva el nombre de un atributo. Utilice @* para que se devuelvan los nombres de todos los atributos.

Véase también

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
}

Enumera los elementos secundarios de un objeto XML. Un elemento secundario XML es un elemento XML, un nodo de texto, un comentario o una instrucción de procesamiento.

Utilice el parámetro propertyName para enumerar el contenido de un elemento secundario XML concreto. Por ejemplo, para que se devuelva el contenido de un elemento secundario llamado <first>, utilice child.name("first"). Puede generar el mismo resultado utilizando el número de índice del elemento secundario. El número de índice identifica la posición del elemento secundario en la lista de otros elementos secundarios XML. Por ejemplo, name.child(0) devuelve el primer elemento secundario de una lista.

Utilice un asterisco (*) para que en la salida se incluyan todos los elementos secundarios de un documento XML. Por ejemplo, doc.child("*").

Utilice el método length() con el parámetro de asterisco (*) del método child() para que en la salida se incluya el número total de elementos secundarios. Por ejemplo, numChildren = doc.child("*").length().

Parámetros

Véase también

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>

Identifica la posición de índice basada en cero de este objeto XML dentro del contexto de su elemento principal.

Véase también

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

Enumera los elementos secundarios del objeto XML en la secuencia en que aparecen. Un elemento secundario XML es un elemento XML, un nodo de texto, un comentario o una instrucción de procesamiento.

Véase también

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

Enumera las propiedades del objeto XML que contienen comentarios XML.

Véase también

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

Compara el objeto XML con el parámetro value especificado.

Parámetros

Véase también

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

Devuelve una copia del objeto XML en cuestión. La copia es un duplicado de todo el árbol de nodos. El objeto XML copiado no tiene elemento principal y devuelve null si intenta llamar al método parent().

Véase también

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

Devuelve un objeto con las siguientes propiedades configuradas con los valores predeterminados: ignoreComments, ignoreProcessingInstructions, ignoreWhitespace, prettyIndent y prettyPrinting. Los valores predeterminados son los siguientes:

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

Nota: este método no se aplica a una instancia de la clase XML, sino que se aplica a XML, como en el siguiente código: var df:Object = XML.defaultSettings().

Véase también

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

Devuelve todos los descendientes (elementos secundarios, terciarios, cuaternarios, etc.) del objeto XML que tiene el parámetro name. El parámetro name es opcional. El parámetro name puede ser un objeto QName, un tipo de datos String o cualquier otro tipo de datos que luego se convierte a un tipo de datos String.

Para devolver todos los descendientes, utilice el parámetro "*". Si no se pasa ningún parámetro, se pasa la cadena "*" y se devuelven todos los descendientes del objeto XML.

Parámetros

Véase también

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>

Enumera los elementos de un objeto XML. Un elemento consta de una etiqueta inicial y otra final; por ejemplo, <first></first>. El parámetro name es opcional. El parámetro name puede ser un objeto QName, un tipo de datos String o cualquier otro tipo de datos que luego se convierte a un tipo de datos String. Utilice el parámetro name para enumerar un elemento concreto. Por ejemplo, el elemento "first" devuelve "John" en este ejemplo: <first>John</first>.

Para enumerar todos los elementos, utilice el parámetro asterisco (*). El asterisco es también el parámetro predeterminado.

Utilice el método length() con el parámetro de asterisco para que en la salida se incluya el número total de elementos. Por ejemplo, numElement = addressbook.elements("*").length().

Parámetros

Véase también

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

Comprueba si el objeto XML tiene un contenido complejo. Un objeto XML tiene contenido complejo si tiene elementos secundarios. Los objetos XML que representan atributos, comentarios, instrucciones de procesamiento y nodos de texto no tienen contenido complejo. Sin embargo, puede considerarse que un objeto que contains alguno de los elementos anteriores tiene contenido complejo (si el objeto tiene elementos secundarios).

Véase también

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

Comprueba si el objeto tiene la propiedad especificada por el parámetro p.

Parámetros

Véase también

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

Comprueba si el objeto XML tiene un contenido simple. Un objeto XML tiene contenido simple si representa un nodo de texto, un nodo de atributo o un elemento XML que no tiene elementos secundarios. Los objetos XML que representan comentarios e instrucciones de procesamiento no tienen contenido simple.

Véase también

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

Enumera los espacios de nombres para el objeto XML basándose en el elemento principal del objeto.

Véase también

Introduce el parámetro child2 especificado tras el parámetro child1 en este objeto XML y devuelve el objeto resultante. Si el parámetro child1 es null, el método introduce el contenido de child2 delante de todos los elementos secundarios del objeto XML (dicho de otro modo, detrás de ninguno). Si se proporciona child1 pero no existe en el objeto XML, el objeto XML no se modifica y se devuelve undefined.

Si llama a este método en un elemento secundario XML que no es un elemento (texto, atributos, comentarios, pi, etc.), se devuelve undefined.

Utilice el operador delete (XML) para eliminar nodos XML.

Parámetros

Véase también

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>

Introduce el parámetro child2 especificado antes del parámetro child1 en este objeto XML y devuelve el objeto resultante. Si el parámetro child1 es null, el método introduce el contenido de child2 delante de todos los elementos secundarios del objeto XML (dicho de otro modo, detrás de ninguno). Si se proporciona child1 pero no existe en el objeto XML, el objeto XML no se modifica y se devuelve undefined.

Si llama a este método en un elemento secundario XML que no es un elemento (texto, atributos, comentarios, pi, etc.), se devuelve undefined.

Utilice el operador delete (XML) para eliminar nodos XML.

Parámetros

Véase también

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

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

En el caso de objetos XML, este método siempre devuelve el entero 1. El método length() de la clase XMLList devuelve el valor 1 para un objeto XMLList que contiene un solo valor.

Véase también

Proporciona la parte local del nombre completo del objeto XML.

Véase también

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

Proporciona el nombre completo del objeto XML.

Véase también

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

Si no se especifica ningún parámetro, proporciona el espacio de nombres asociado al nombre completo de este objeto XML. Si se especifica un parámetro prefix, el método devuelve el espacio de nombres que coincida con el parámetro prefix y esté en el ámbito del objeto XML. Si no existe el espacio de nombres en cuestión, el método devuelve undefined.

Parámetros

Véase también

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

Enumera las declaraciones de espacio de nombres asociadas al objeto XML en el contexto de su elemento principal.

Véase también

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/

Especifica el tipo de nodo: texto, comentario, instrucción de procesamiento, atributo o elemento.

Véase también

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

Para el objeto XML y todos los objetos XML descendientes, funde los nodos de texto adyacentes y elimina los nodos de texto vacíos.

Véase también

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

Devuelve el elemento principal del objeto XML. Si el objeto XML carece de elemento principal, el método devuelve undefined.

Véase también

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

Introduce una copia del objeto child (secundario) proporcionado en el elemento XML delante de cualquier propiedad XML existente para dicho elemento.

Utilice el operador delete (XML) para eliminar nodos XML.

Parámetros

Véase también

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>

Si se proporciona un parámetro name, enumera todos los elementos secundarios del objeto XML que contienen instrucciones de procesamiento con dicho nombre name. Si no hay parámetros, el método enumera todos los elementos secundarios del objeto XML que contienen instrucciones de procesamiento.

Parámetros

Véase también

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

Comprueba si la propiedad p está en el conjunto de propiedades que se pueden repetir en una sentencia for..in aplicada al objeto XML. Devuelve true sólo si toString(p) == "0".

Parámetros