S4: XML
- Tiempo: 2h (50 + 50min)
- Fecha: Martes, 21-Febrero-2023
-
Objetivos de la sesión:
- Aprender sobre XML
- Saber entender y usar archivos XML a nivel práctico
- Tener nociones sobre cómo definir nuestros propios lenguajes de marcado
- Introducción
- XML: Crea tu lenguaje de marcado
- VSCode y XML
- Usos del XML
- Sintáxis: Documentos bien formados
- Espacios de nombres
- Gramatica: Documentos válidos
- Autor
- Licencia
- Enlaces
Los lenguajes de marcado, como ya sabemos, son metalenguajes que nos permiten estructurar la información. Ya conocemos varios. Uno es HTML, con el que damos la estructura a las páginas web. Otro es el markdown, centrado más en la estrucura de las documentaciones, para poder hacerlas de forma fácil y rápidas
Hoy aprenderemos otro: XML. Este lenguaje se usa más para dar estructura a los datos que utilizan las aplicaciones. Y además, con XML, podemos construir nuestros propios lenguajes de marcado
En la sesión 1 vimos los lenguajes de marcado, que nos permiten establecer una estructura. Aunque los llamamos lenguajes de marcado, son en realidad metalenguajes, ya que hablan sobre otro lenguaje
El lenguaje SGML es un estándar industrial que nos permite construir nuestros propios lenguajes de marcado. A partir del SGML se creó una versión simplificada, conocida como XML que ha sido estandarizada por el W3C
En el XML se definen una serie de reglas sintácticas. Si el documento en xml cumple estas reglas se dice que es un documento bien formado o sintácticamente correcto. Además, nuestro lenguaje creado tiene una gramática: se definen las etiquetasy la relación entre ellas. Un documento bien formado que cumple con las reglas gramaticales se dice que es un documento válido
Existen multitud de herramientas para trabajar con documentos XML, y que nos permiten comprobar que están bien formados y que son válidos. Nosotros usaremos la extensión XML del Visual Studio Code
Con esta extensión podemos aprender XML de forma práctica, comprobando los ejemplos y modificándolos para ver qué ocurre
¿Y para qué queremos definir nuestro propio lenguaje de marcado? El uso fundamental es el de estructurar datos para poder almacenarlos e intercambiarlos fácilmente desde nuestras aplicaciones
Los usos principales de XML son:
- Ficheros de proyecto. El XML se usa para almacenar en un fichero los datos del proyecto actual creado con una aplicación. Por ejemplo, los documentos de muchas aplicaciones se guardan en xml: LibreOffice, Inkscape (Dibujos vectoriales en SVG)... En vez de tener que definir tu propio formato para los datos de tu aplicación, puedes usar directamente el XML que ya incorpora analizadores y te facilita la labor
- Ficheros de configuración. El archivo de configuración con las preferencias de una aplicación se puede guardar tambiéne en XML. Así no hay que inventarse un formato nuevo
- Bases de datos. Para el almacenamiento de datos de aplicaciones que no requieran procesamiento masivo, el XML es una buena opción
- Intercambio de datos entre aplicaciones: Envío/recepción de datos entre las aplicaciones
- Conversión entre formatos: El XML se usa mucho como formato intermedio para la conversión de unos formatos a otros. Casi todas las aplicaciones exportan sus datos a XML
En XML se definen las siguientes etiquetas
Más detalles de las etiquetas, con algunos ejemplos de uso
-
Comentarios
<!-- ... -->: Se pueden poner en cualquier sitio y pueden ocupar varias líneas
<!-- Este es un ejemplo de comentario en una línea -->
<!-- Este es un comentario
Multilínea
Ocupa
4 líneas
-->-
Declaración de XML:
<?xml ... ?>: Se pone al principio, para indicar que se trata de un documento XML. Entre los atributos que se pueden usar están version y encoding. La etiqueta típica que se pone al comienzo tiene esta pinta:
<?xml version="1.0" encoding="UTF-8" ?>-
Etiqueta raiz y definición del documento
<!DOCTYPE raiz opciones>: Indica cuál es la etiqueta Raiz y opcionalmente se puede indicar el archivo DTD con la definición del lengauje (Su gramática). La etiqueta DOCTYPE es opcional en XML
<!-- Ejemplo: Declaracion de la etiqueta raiz -->
<!DOCTYPE tienda><!-- Ejemplo: Añadir la definición del lenguaje creado,
que está en el fichero tienda.dtd -->
<!DOCTYPE tienda SYSTEM "tienda.dtd">-
Etiquetas de apertura
<tag atributos="valor">: Opcionalmente pueden contener atributos. Sus valores siempre se ponen entre comillas". Toda etiqueta de apertura tiene que tener su correspondiente de cierror:</tag>. Entre la etiqueta de apertura y cierre se encuentra el cuepor, que a su vez está formado por más etiquetas de apertura/cierre
<!-- Ejemplo: Etiquetas con cuerpo simple -->
<tienda>
Este es el texto del cuerpo
</tienda><!-- Ejemplo: Etiquetas con cuerpo compuesto -->
<tienda>
<producto codigo="1">
Placa Alhambra II
</producto>
<producto codigo="2>
Placa Icestick
</producto>
</tienda>-
<tag atributos="valor" />: Existen etiquetas que no definen cuerpo. Sólo tiene atributos por lo que son a su vez etiquetas de apertura y cierre
Es importante tener en cuenta que se distingue entre MAYÚSUCLAS y minúsculas
La estructura típica de un documento XML es esta:
Para escribir documentos XML no hace falta definir su gramática. Simplemente basta con empezar a colocar etiquetas de comienzo y de fin. Utilizaremos el VSCode
Este es nuestro primero ejemplo. Es un documento sintáxticamente correcto (bien formado), pero como NO se ha definido su gramática las herramientas automáticas no pueden saber si es un documento válido o no
<?xml version="1.0" encoding="UTF-8"?>
<!-- Estructura de mi tienda -->
<!-- Nodo raiz -->
<tienda>
<!-- Mi tienda contiene productos/articulos -->
<producto>
Un producto
</producto>
<producto>
Otro producto
</producto>
</tienda>Desde el VSCode lo escribimos muy fácilmente. Empezamos por el documento en blanco. Creamos un fichero nuevo: por ejemplo Ej-01-hola-mundo.xml. Nos ficjamos en la pestaña de OUTLINE. Ahí es donde irá apareciendo la estructura de nuestro documento
Como el documento está en blanco, NO es sintácticamente correcto y en el editor nos aparece un símbolo en rojo. En la parte de OUTLINE nos indica que NO se ha encontrado ningún símbolo
Tecleamos < y nos aparecen sugerencias:
Por defecto está seleccionada la primera: Declaración de XML. Pulsamos en TAB. Nos pide los valores para la versión y la codificación. Dejamos los que nos pone por defecto: Damos 4 veces al TAB
En esta animación se muestra el proceso
Ahora metemos un comentario. Tecleamos <! y nos aparecen las sugerencias:
Le damos al TAB. Escribimos el comentario y le damos de nuevo al TAB:
En esta animación lo vemos en acción:
Ahora escribimos la etiqeuta <tienda>. Al terminar nos aparece automáticamente la etiqueta de cierre correspondiente: </tienda>. Pulsamos Enter. El cursor se nos queda en el centro para escribir el cuerpo
Nos fijamos que en la parte de OUTLINE aparece el elemento tienda. También vemos que debajo de la etiqueta de apertura aparecen tres puntos. Si ponemos el ratón encima nos aparece este mensaje:
Nos está indicando que en este documento XML no hay gramática definida y que por tanto no puede saber si la etiqueta tienda es correcta o no. Esto NO es un error, simplemente es un aviso. El documento que hemos generado está bien formado, pero NO es valido
Ahora introducimos dos productos, usando la etiqueta <producto>. Al terminar, en la parte de OUTLINE vemos los dos nuevos productos introducidos, y cómo están dentro de tienda
En esta animación vemos su creación. Al principio hay que escribir la etiqueta <producto> completamante. Sin embargo, al segunda vez ya nos aparece en la sugerencias por lo que sólo hay que dar al TAB
La extensión XML del VSCode analiza el código XML y nos informa de si está bien formado. Vamos a cometer errores sintáticos para mostrar lo que sucede. En el ejemplo anterior modificamos la letra p de la etiqueta de cierre </producto> por P. Como XML es sensible a las mayúsculas, las etiquetas </producto> y </Producto> son distintas
En el editor se subraya en rojo la etiqueta de apertura <producto>. En la parte del esquema (OUTLINE) el primer producto también se pone en Rojo, indicando que hay un fallo. Si pasamos el ratón por encima de la etiqueta nos aparece más información sobre el error:
Nos indica que la etique de apertura <producto> debe tener una de cierre con el mismo nombre: </producto>. Lo podemos cambiar nosotros o podemos darle a la opción Quick Fix que nos aparece:
Al hacerlo nos aparecen dos opciones. Pinchamos en la primera: Reemplaza Producto con producto. Nos lo corregirá automáticamente y desaparecerá el error
Vamos a forzar otro error. Ahora metemos una etiqueta sin el > final:
Nos aparece un nuevo elemento, hola, en la parte izquierda, pero en rojo, porque contiene errores. En el editor lo vemos subrayado en rojo. Si ponemos el cursor encima vemos la causa del error:
Nos indique que en el elemento hola o bien debe venier un atributo o bien se debe cerrar con >. Pinchamos en Quick Fix:
Nos aparecen otras dos opciones. La buena es la segunda. Pinchamos en ella, y se nos completa la etiqueta de comienzo y se agrega la etiqueta de fin
Cuando se mezclan documentos XMLs podría ocurrir que haya etiquetas que tengan el mismo nombre, pero que se utilicen para cosas diferentes. En nuestro ejemplo de la tienda se usa la etiqueta <producto>, que tendrá unos campos determinados. Podría ser que en otro documento también se usase la etiqueta producto pero con otros campos. Si se juntasen en el mismo documento el analizador no podría distinguirlos. La etiqueta sería ambigüa
Para solucionar la ambiguedad se usan los espacios de nombres. La solución consiste en añadir un prefijo, al que se le asigna un nombre (URI) que lo identifique unívocamente. Esto se hace con el atributo xmlns
En este ejemplo se han definido los prefijos t1 y t2, que se encuentran en espacios de nombres distintos. Para identificar estos espacios de nombres se puede usar cualquier cadena. Pero típicamente se usa como nomenclatura una URL. Pero esto no quiere decir que en esa URL haya algo. El analizador de XML NO se conecta a esas URLs, sino que simplemente las usa para diferenciar los espacios de nombres y que no haya ambiguedad
Opcionalmente se puede añadir una gramática a nuestro lenguaje, para que los analizadores de XML puedan procesarlo automáticamente y determinar si es un documento válido o no. Para que sea válido, lo primero, por supuesto, es que esté bien formado. Si tiene errores sintácticos no se puede analizar y comprobar si es válido o no
La gramática de nuestro lenguaje se puede definir de dos formas diferentes:
- Mediante una definición de tipo de documento (DTD): Ficheros .dtd
- Mediante esquemas en XML (XML schema): Ficheros .xsd
Esta es la manera original de definir la gramática de nuestro lenguaje, heredada de SGML. Es un lenguaje nuevo que describe los nombres de las etiquetas permitidas así como su estructura
Vamos a aprender su uso básico mediante ejemplos. Para definir una gramática se usa la etiqueta <!DOCTYPE raiz opciones>, donde raiz es la etiqueta raiz de nuestro documento. XML nos permite definir la propia gramática bien en un archivo externo .dtd o bien dentro de la propia etiqueta DOCTYPE
Comenzaremos con ejemplos sencillos cuya definición se hace dentro de DOCTYPE
Este documento define la etiqueta raiz <tienda> como un elemento simple, que sólo puede contener una cadena de texto. No puede contener otras etiquetas
<?xml version="1.0" encoding="UTF-8"?>
<!-- Declaracion de la gramatica -->
<!DOCTYPE tienda [
<!ELEMENT tienda (#PCDATA)>
]>
<!-- Dentro del elemento tienda solo puede haber
cadenas de texto. Ninguna etiqueta -->
<tienda>
Esta es mi tienda
</tienda>Cada elemento se define con la etiqueta <!ELEMENT nombre (contenido)>, donde se especifica el nombre del elemento definido y entre paréntesis los nombres de los elementos que pueden estar en su interior. En este ejemplo tienda es una etiqueta simple que sólo puede contener cadenas. Se utiliza el nombre especial #PCDATA para indicar que en su cuerpo debe haber datos
Para crear las definiciones basta con empezar a escribir DOCTYPE. A los pocos caracteres nos aparecerá en la sugerencia. Pulsamos el TAB
Nos aparecen varias líneas con la estructura completa para definir la sintáxis. Se utiliza el nombre root-element como elemento raíz:
A continuación tecleamos el nombre del elemento raiz. En nuestro ejemplo es tienda y pulsamos en TAB. El cursor se mueve hacia el contenido de tienda, que por defecto se pone como #PCDATA
Como es el que queremos pulsamos TAB. El cursos se sitúa al final de la etiqueta de apertura <tienda>. Pulsamos ENTER y escribimos una cadena dentro
El proceso completo se muestra en esta animación
La validación del documento se hace automáticamente en VSCode. Si no fuese válido se indicarían en rojo las etiquetas que dan problemas. Este ejemplo es válido, y por tanto no aparecen errores
Si añadimos cualquier etiqueta dentro de tienda, el documento NO será válido, ya que en su gramática se ha especificado que sólo puede haber datos
En este ejemplo se definen dos elementos: tienda, que es el raiz, y producto. El elemento tienda sólo contiene el elemento producto (sólo uno). El elemento producto es simple, y sólo contiene datos
El tener definida la gramática de nuestro lenguaje tiene varias ventajas. Una de ellas es que el VSCode conoce la estructura de nuestro lenguaje, y por tanto nos puede ayudar. Si partimos del documento anterior sin haber colocado el elemento raiz, al escribir ti ya nos ofrece como sugerencia la etiqueta tienda. Esto antes no sucecía
Al darle al TAB nos aparece el elemento tienda, pero en rojo. Esto es debido a que NO es un documento válido. El contenido de la etiqueta tienda NO es válido, ya que sólo puede ser el elemento producto
Si en el cuerpo de <tienda> metemos otro elemento distinto de producto, tampoco será un documento válida y nos aparecerán elementos en rojo
Sólo cuando ponemos la etiqueta producto, entonces se convierte en un documento válido y no hay elementos en rojo
Pero si añadimos un producto adicional, tampoco será un documento válido:
Si queremos que dentro de un elemento haya 1 ó más elementos, debemos añadir el sufijo + en el nombre de la etiqueta que va entre paréntesis. Así, en el ejemplo anterior, si queremos permitir que se puedan poner varios productos, la definición del elemento tienda tiene que ser:
<!ELEMENT tienda (producto+)>Esto nos indica que tiende contiene uno o más productos. El siguiente documento es ahora válido:
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE tienda [
<!-- La tienda contiene uno o más productos -->
<!ELEMENT tienda (producto+)>
<!ELEMENT producto (#PCDATA)>
]>
<tienda>
<producto> Un producto</producto>
<producto> Otro poducto</producto>
<producto> y otro producto más...</producto>
</tienda>En la parte de OUTLINE vemos todos los productos dentro de la tienda. El documento es válido porque no hay nada en rojo
En la definición de la gramática podemos establecer todos los niveles de profundidad que queramos. Vamos a ampliar el ejemplo anterior para que el elemento producto tenga a su vez otros tres elementos: El nombre, la descripción y el stock disponible. De ellos, el elemento descripción es opcional (algunos productos lo tendrán, pero otros no).
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE tienda [
<!ELEMENT tienda (producto*)>
<!-- El elemento descripcion es opcional -->
<!ELEMENT producto (nombre, descripcion?, stock)>
<!ELEMENT nombre (#PCDATA)>
<!ELEMENT descripcion (#PCDATA)>
<!ELEMENT stock (#PCDATA)>
]>
<tienda>
<producto>
<nombre>Alhambra II</nombre>
<descripcion>Placa con FPGA ice40HX8K</descripcion>
<stock>3</stock>
</producto>
<producto>
<nombre>Icestick</nombre>
<stock>10</stock>
</producto>
</tienda>Como es un documento válido, no aparecen elementos en rojo en el esquema
Estos son algunos de los sufijos más utilizados con los elementos:
| Notación | Descripción |
|---|---|
| elemento | Sólo puede haber 1 elemento |
| elemento+ | Uno o más elementos |
| elemento* | Ninguno, uno o más elmentos |
| elemento? | Ninguno o uno (elemento opcional) |
La gramática del lenguaje la podemos colocar en un archivo externo, con extensión .dtd. Este sería la definición para la tienda, que hemos usado en los apartados anteriores:
<!-- Documento de definicion de mi tienda -->
<!-- Elemento raiz -->
<!-- La tienda esta compuesta de productos:
Ninguno, uno o muchos -->
<!ELEMENT tienda (producto*)>
<!-- La descripcion de los productos es opcional -->
<!ELEMENT producto (nombre, descripcion?, stock)>
<!-- Elementos simples -->
<!ELEMENT nombre (#PCDATA)>
<!ELEMENT descripcion (#PCDATA)>
<!ELEMENT stock (#PCDATA)>Ahora, en un fichero .xml separado utilizamos la etiqueta DOCTYPE con la opcion SYSTEM para indicar el fichero que contiene la definición del lenguaje:
<!DOCTYPE tienda SYSTEM "tienda.dtd">El documento .xml con datos de mi tienda sería este:
<?xml version="1.0" encoding="UTF-8"?>
<!-- Definicion de mi tienda -->
<!DOCTYPE tienda SYSTEM "tienda.dtd">
<tienda>
<producto>
<nombre>Alhambra II</nombre>
<descripcion>Placa con FPGA ice40HX8K</descripcion>
<stock>3</stock>
</producto>
<producto>
<nombre>Icestick</nombre>
<stock>10</stock>
</producto>
</tienda>Se trata de un documento válido, por lo que no hay etiquetas en rojo. En la parte del esquema vemos que aparece {} Grammars. Nos indica que la gramática del lenguaje está definida en un fichero separado
En XML se utilizaron los ficheros .dtd para las gramáticas, de forma que se mantenga la compatibilidad con SGML. Sin embargo se incluyó una nueva forma de definir las gramáticas: los esquemas XML. Los archivos de esquemas tiene la extensión .xsd
Algunas de las ventajas son:
- Los esquemas son más potentes
- Soporta tipos de datos: String, decimal, integer...
- Se usa el propio lenguaje XML para definir la gramática
Veremos algunos ejemplos para comprender los esquemas. Ahora tendremos siempre dos documentos: el .xml con nuestro documento y el .xsd con la definición de la gramática del lenguaje
Los esquemas se definen en el fichero .xsd, que es también un fichero XML por lo que se usa la misma sintáxis. Siempre comenzarán con la declaración <?xml ... ?>
Para comenzar el esquema utilizamos su elemento raiz: <xs:schema> donde xs es el prefijo estándar usado para el espacio de nombres. Se podría utilizar otro prefijo diferente, si se quisiera (Aunque nosotros usaremos siempre xs). El espacio de nombres estándar es: xmlns:xs="http://www.w3.org/2001/XMLSchema".
Dentro de este elemento raiz declaramos el resto de elementos del lenguaje, usando <xs:element name="nombre" ...>
Por tanto, nuestros esquemas siempre tendrán la siguiente pinta
<?xml version="1.0" encoding="UTF-8"?>
<!-- Elemento raiz del esquema. Se define su espacio
de nombres (xs) -->
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<!-- Aquí se definen el elemento raiz de mi lenguaje -->
<xs:element name="raiz">
<!-- Aqui se definen el resto de elementos -->
</xs:element>
</xs:schema>Definiremos el lenguaje de mi tienda de manera que sólo tenga el elemento simple tienda, cuyo valor sólo puede ser una cadena. Lo definimos en el fichero 01-xs-simple.xsd
<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:element name="tienda" type="xs:string">
</xs:element>
</xs:schema>Los tipos básicos disponibles son:
-
xs:string--> Cadena de caracteres -
xs:decimal--> Número en decimal -
xs:integer--> Número entero -
xs:boolean--> Valor booleano -
xs:date--> Fecha -
xs:time--> Hora
La plantilla para crear el esquema la obtenemos fácilmente escribiendo sch donde nos aparece la sugerencia New XML Schema
Pulsamos TAB y aparece la plantilla. El prefijo xs está resaltado para indicar que se puede cambiar por el que queramos
Lo dejamos como está, así que apretamos TAB. Debemos introducir el nombre del elemento raiz de nuestro lenguaje
Introducimos tienda. Y movemos el cursor para introducir el atributo type para definir el elemento tienda de tipo String
Al teclear ty nos aparece la sugerencia de type
Pulsamos en TAB. Se autocompleta y el cursos se sitúa dentro de la cadena vacia, para escribir el tipo
Escribimos xs:s y nos aparecen las sugerencias con los tipos básicos
Pulsamos Tab y ya lo tenemos. Ahora no aparecerá ningún elemento en rojo
En esta animación vemos el proceso completo:
Ahora usamos el esquema en nuestro documento 01-xs-simple.xml. Para ello hay que comenzar con la etiqueta raiz (tienda) donde se define el espacio de nombres. El espacio estandarizado tiene el prefijo xsi y el identificador es "http://www.w3.org/2001/XMLSchema-instance". Para referenciar el fichero se usa el atributo noNamespaceSchemaLocation
<?xml version="1.0" encoding="UTF-8"?>
<tienda xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="01-xs-simple.xsd">
Esta es mi tienda
</tienda>Por supuesto no tenemos que teclearlo todo nosotros. Basta con que escribamos sch y nos aparecerán las sugerencias
Seleccionamos la segunda: New XML bound with noNamespaceLocation
Se nos despliga la plantilla
Escribimos el nombre de la etiqueta raiz: tienda y le damos al TAB
Ahora escribimos el nombre del fichero con el esquema que queremos usar (01-xs-simple.xsd en nuestro caso)
Por último escribimos una cadena dentro tienda
Es un documento válido, ya que no aparecen mensajes en rojo
Sin embargo, si añadimos alguna etiqueta dentro de tienda sí que aparecerán errores y el documento ya no será válido
Los elementos que contienen otros elementos son del tipo complejo (Complex Type). Para indicarlo usamos la etiqueta xs:complexType. Dentro de un tipo complejo debemos indicar en qué orden aparecen los elementos, pueden aparecer en cualquier orden (xs:all), en un orden concreto (xs:sequence) o sólo uno de los dos indicados (xs:choice)
En este ejemplo vamos a crear el elemento producto dentro de tienda. Este es el esquema:
<?xml version="1.0" encoding="UTF-8"?>
<!-- Comienzo del esquema -->
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<!-- Elemento raiz -->
<xs:element name="tienda">
<!-- Es de tipo complejo porque contiene otros elementos -->
<xs:complexType>
<!-- Elementos en orden -->
<!-- En este caso como solo hay 1 os da igual -->
<xs:sequence>
<!-- Producto: Tipo simple: cadena -->
<xs:element name="producto" type="xs:string" />
</xs:sequence>
</xs:complexType>
</xs:element>
</xs:schema>En el VSCode vemos que está bien formado
Ahora creamos el documento 02-xs-compuesto-1.xml que usa ese esquema. Empezamos poniendo sólo la etiqueta raiz:
Nos sale un error: no es un documento válido, ya que tienda debe contener un producto. Añadimos un producto
Ahora ya es un documento válido
Para especificar la cantidad de veces que puede aparecer un elemento se utilizan los atributos maxOccurs y minOccurs. Si queremos que en el ejemplo anterior pueda haber 1 ó más productos (sin limitaciones) colocaremos el atributo maxOccurs="unbounded" al elemento producto. Por defecto, el atributo minOccurs está a 1:
<?xml version="1.0" encoding="UTF-8"?>
<!-- Comienzo del esquema -->
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<!-- Elemento raiz -->
<xs:element name="tienda">
<!-- Es de tipo complejo porque contiene otros elementos -->
<xs:complexType>
<!-- Elementos en orden -->
<!-- En este caso como solo hay 1 os da igual -->
<xs:sequence>
<!-- Producto: Tipo simple: cadena -->
<!-- Puede haber 1 ó más productos -->
<xs:element name="producto" type="xs:string" maxOccurs="unbounded"/>
</xs:sequence>
</xs:complexType>
</xs:element>
</xs:schema>Ahora este documento sería válido:
<?xml version="1.0" encoding="UTF-8"?>
<tienda
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="03-xs-compuesto-2.xsd">
<producto>
Este es un producto
</producto>
<producto>
Otro producto!!!!
</producto>
<producto>
Y otro más!!!!
</producto>
</tienda>- Define una manera estandarizada para acceder y manipular documentos XML
- Todos los elementos del documento XML se pueden acceder a través del DOM, localizarlos, cambiarlos, añadir nuevos o borrar existentes
- XML DOM define los objetos, propiedades y métodos de todos los elementos XML.
- Se puede ver como un modelo estandar de objetos para XML.
- Se puede ver como un API para programar usando documentos XML
- Es independiente de lenguaje y de plataforma
- Está estandarizado por el consorcio W3C
- Juan González-Gómez (Obijuan)
