contenidos unidad 4 - wordpress.com · otra utilidad del cdata es la posibilidad de visualización...
TRANSCRIPT
1
Índice
4.1. Concepto y Elementos de XML .......................................................................3 Características........................................................................................................3 Ventajas ..................................................................................................................4 4.1.1 Elementos XML ............................................................................................4 Elementos ...............................................................................................................5 Elementos con contenido .....................................................................................5 Elementos vacíos ...................................................................................................6 Anidamiento............................................................................................................6 Atributos..................................................................................................................7 Entidades predefinidas..........................................................................................8 CDATA......................................................................................................................8
4.2. Documentos XML ..............................................................................................9 Declaración ........................................................................................................... 10 Codificación........................................................................................................... 10
4.3. Documentos bien formados y válidos ......................................................... 10 4.3.1. Documentos bien formados ................................................................... 10 Estructura jerárquica de elementos ................................................................. 11 Etiquetas vacías ................................................................................................... 11 Un solo elemento raíz ......................................................................................... 11 Valores de atributos ............................................................................................ 11 Tipos de letras, espacios en blanco .................................................................. 11 Nombrando cosas ................................................................................................ 12 Marcado y datos................................................................................................... 12 4.3.2. Documentos válidos ................................................................................ 12 Declaraciones Tipo Elemento............................................................................. 13 Modelos de contenido ......................................................................................... 14 Declaraciones de lista de atributos................................................................... 15 Tipos de atributos ................................................................................................ 16 Declaración de entidades ................................................................................... 17 Ejemplos de DTD ................................................................................................. 18
2.4. Namespaces..................................................................................................... 19 2.5. Parser................................................................................................................ 20 Editores XML......................................................................................................... 20 Editores de DTD ................................................................................................... 20 Procesadores XML................................................................................................ 20
2
Unidad IV
Introducción a XML Objetivo
� Permitir que los alumnos conozcan los aspectos teóricos y prácticos fundamentales del lenguaje de marcas XML y de las tecnologías relacionadas.
� Introducir los fundamentos del Lenguaje de Marcas Extensible –XML.
� Conocer las reglas de los documentos XML.
� Conocer cómo definir lo que puede y no puede contener un documento XML
3
4.1. Concepto y Elementos de XML
XML, sigla en inglés de eXtensible Markup Language («lenguaje de marcas extensible»), es un metalenguaje extensible de etiquetas desarrollado por el World Wide Web Consortium (W3C). Es una simplificación y adaptación del SGML y permite definir la gramática de lenguajes específicos (de la misma manera que HTML es a su vez un lenguaje definido por SGML). Por lo tanto XML no es realmente un lenguaje en particular, sino una manera de definir lenguajes para diferentes necesidades. XML describe un conjunto de documentos llamados "documentos XML" y da indicios de cómo debieran ser leídos esos documentos por ciertas aplicaciones. Un documento XML consiste de un conjunto de entidades, que son principalmente texto y marcas.
XML no ha nacido sólo para su aplicación en Internet, sino que se propone como un estándar para el intercambio de información estructurada entre diferentes plataformas.
XML es una tecnología sencilla que tiene a su alrededor otras que la complementan y la hacen mucho más grande y con unas posibilidades mucho mayores. Tiene un papel muy importante en la actualidad ya que permite la compatibilidad entre sistemas para compartir la información de una manera segura, fiable y fácil.
En un nivel lógico, un documento contiene:
• Declaraciones (definen un elemento)
• Elementos
• Comentarios (ignorados)
• Instrucciones de proceso (destinados a la aplicación que trata el documento, pero no parte de la información)
• Referencias a caracteres
Al software que manipula el documento XML se le denomina procesador XML y puede estar dentro de otra aplicación.
Características
Como lenguaje de marcado, encierra entre etiquetas los datos a los que se refieren. Estas etiquetas pueden anidarse y pueden poseer atributos.
• Similar a HTML pero no es HTML.
• Al contrario que las etiquetas HTML (formato), las etiquetas XML nos dicen lo que significan los datos.
• De la misma forma que definimos los nombres de los campos para una estructura de datos, podemos usar cualquier etiqueta XML que tenga sentido para una aplicación dada
4
• Para que múltiples aplicaciones usen el mismo dato XML, tienen que estar de acuerdo con los nombres de etiquetas que intentan usar.
• Las etiquetas no están predefinidas: Nosotros somos responsables de definir las etiquetas. Uno puede nombrarlas como desee y puede utilizarlas para representar cualquier cosa que se quiera.
• Un documento XML acompañado de un DTD o un schema XML es autodescriptivo.
• XML es una recomendación de W3C.
XML no hace nada. XML no es para diseñar una pagina web ni para cambiar la manera en la cual se construyen sitios.
• XML se utiliza para estructurar y describir datos � se unifica la forma de leer, mostrar y enviar datos.
Ventajas
• Representa un formato legible para personas y maquinas.
• Es auto descriptivo ya que describe estructura, nombres y valores de los campos.
• Los algoritmos de análisis o parseo son simples y óptimos.
• Es independiente de la plataforma.
• Se trabaja sobre archivos de texto por lo que no se requieren licencias.
4.1.1 Elementos XML
Existen tres términos comúnmente usados para describir las partes de un documento XML: etiquetas, elementos y atributos. Aquí está un documento de ejemplo que ilustra estos términos:
<direccion>
<nombre>
<titulo>Sra.</titulo>
<nombre>
Maria
</nombre>
<apellidos>
Rodriguez
</apellidos>
</nombre>
<calle>
5
Estrada 2345
</calle>
<ciudad Provincia="Santa Fe">Santa Fe</ciudad>
<codigo-postal>
3000
</codigo-postal>
</direccion>
Una etiqueta es un texto entre el símbolo menor que (<) y el símbolo mayor que (>).
Existen etiquetas de inicio (como <nombre>) y etiquetas de fin (como </nombre>).
Un elemento consta de la etiqueta de inicio, la etiqueta de fin y de todo aquello que este entre ambas. En el ejemplo anterior, el elemento <nombre> contiene tres elementos hijos:
<titulo>, <nombre>, y <apellidos>.
Un atributo es un par nombre-valor dentro de la etiqueta de inicio de un elemento. En este ejemplo, provincia es un atributo del elemento <ciudad>.
Elementos
Las etiquetas usadas están formadas por una palabra (o un número de palabras) encerradas entre < > y < / >.
<message> Hola a todos </message>
En XML las etiquetas no son predefinidas.
Los elementos XML pueden tener contenido (más elementos, caracteres, o ambos a la vez), o bien ser elementos vacíos.
Elementos con contenido
Comienzan con una < etiqueta> que puede contener atributos o no, y terminan con una < / etiqueta> que debe tener el mismo nombre.
• A diferencia de HTML, en XML siempre se debe "cerrar" un elemento.
• El símbolo "< " siempre se interpreta como inicio de una etiqueta XML. Si no es el caso, el documento no estará bien formado. Para usar ciertos símbolos se usan las entidades predefinidas.
Ejemplo:
<mensaje
6
tema=“XML es muy interesante”>
<texto>
Cuantas maneras de usar un documento XML existen?
<texto>
</mensaje>
Elementos vacíos
Un elemento que no encierra ningún contenido, se llama elemento vacío.
Ejemplo:
<mensaje
tema=“XML es muy interesante”>
<flag/>
<texto>
Cuantas maneras de usar un documento XML existen?
<texto>
</mensaje>
Al no tener una etiqueta de cierre que delimite un contenido, se utiliza la forma < etiqueta/ >, que puede contener atributos o no.
Anidamiento
Los elementos XML pueden anidarse.
Ejemplo:
<mensaje>
<encabezado>
<destino>[email protected]</destino>
<remite>[email protected]</remite>
<tema>XML es muy chevere</tema>
</encabezado>
<texto>Cuantas maneras de usar un documento XML existen?</texto>
</mensaje>
<mensaje> es el elemento raíz. La totalidad de los demás tags o etiquetas se anidan dentro del tag mensaje.
<encabezado> indica la información que contiene en el encabezado del mensaje de mail. Este también tiene tags anidados (remitente).
El anidamiento en XML es muy importante y debe estar correctamente definido.
Elemento vacío
7
Atributos
Describen, en la forma nombre=valor, las propiedades de los elementos de un documento.
<pelicula tipo=“accion" calidad= "buena"> Terminator< / pelicula>
Se ubican siempre en la etiqueta de inicio de un elemento.
En un documento de Definición de Tipo de Documento (DTD), se especifican los atributos que pueden tener cada tipo de elemento, así como sus valores y tipos de valor posible.
Deben estar marcados entre comillas simples (') o doble ("). Al usarse uno para delimitar el valor del atributo, el otro tipo se puede usar dentro.
<verdura clase= "zanahoria" longitud= '15 y media'>
<cita texto= " 'Hola buenos dias', dijo él">
Un elemento con contenido, puede modelarse como un elemento vacío con atributos.
<gato>
<nombre> Felix< / nombre>
<raza> Persa< / raza>
</gato>
<gato raza= "Persa"> Felix< / gato>
<gato raza= "Persa" nombre= “Felix" />
Lo conveniente es utilizar atributos tan poco como sea posible y concentrarnos en estructurar los documentos de forma correcta.
Los atributos son otra forma de almacenar datos usando XML.
<mensaje>
<encabezado>
<de> [email protected] </de>
<para> [email protected] </para>
<asunto> Comentarios del sitio</asunto>
</encabezado>
<cuerpo>
El diseño está muy bueno y el contenido es muy interesante
</cuerpo>
</mensaje>
Aquí las etiquetas son simples y sin atributos.
8
Entidades predefinidas
En XML 1.0, se definen cinco entidades predefinidas.
Representan caracteres especiales y no se interpretan como marcas.
Ejemplo: Usar el carácter "< " sin que se interprete como el comienzo de una etiqueta XML.
Las entidades se expanden cuando el documento es parseado por un analizador o parser XML.
Cuando necesitamos incluir gran cantidad de estas entidades en un documento XML se torna engorroso la utilización de las entidades predefinidas. Para estos casos existe el elemento CDATA.
CDATA
Útil cuando se analizan todos los datos en el documento XML.
<body> Las ventas fueron menores que el año pasado</body>
Texto y etiquetas se analizan Î no hay problemas.
<body> Las ventas fueron <que el año pasado</body>
Problema el analizador toma el signo < como comienzo de un nuevo tag y lanza un error ya que éste no es cerrado.
Las etiquetas predefinidas permiten mostrar los símbolos correctos y el analizador XML trabajará correctamente.
<body> Las ventas fueron < ; que el año pasado</body>
CDATA permite que el analizador ignore todo lo que esta contenido en él.
< ! [CDATA[ Texto que es ignorado por el analizador o parser ] ] >
Ejemplo usando entidades predefinidas:
<ejemplo> < html>
< head> < title> Rock& Roll< ;/title> < /head>
9
</ejemplo>
Ejemplo usando bloque CDATA:
<ejemplo>
<![CDATA[
<html> <head> <title> Rock & Roll</title> </head>]]>
</ejemplo>
Lo que está dentro de CDATA es ignorado. La cadena "]]>" indica el fin del bloque y no puede utilizarse dentro de una sección CDATA.
Otra utilidad del CDATA es la posibilidad de visualización de código XML como parte del texto. Las etiquetas dentro del texto no serán analizadas o parseadas.
Comentarios
Los comentarios pueden aparecer en cualquier lugar en el documento; incluso antes o después del elemento raíz. Un comentario comienza con <!- y termina con -->. Un comentario no puede contener un guión doble (--), excepto al final; con esta excepción, un comentario puede contener cualquier cosa. Aún más importante, cualquier marca dentro de un comentario será ignorada; si quiere eliminar una gran sección de un documento XML simplemente introdúzcala en un comentario. (Para restaurar la sección comentada simplemente elimine las etiquetas de comentario.) Aquí presentamos un ejemplo que contiene un comentario
<!.Esto es un comentario -->
Se pueden introducir en cualquier parte del documento excepto dentro de las declaraciones, etiquetas u otros comentarios.
4.2. Documentos XML
Un objeto de datos es un documento XML si esta bien-formado, tal y como se define en la especificación. Un documento XML bien-formado puede además ser válido si cumple una serie de restricciones.
Un documento XML tiene dos estructuras, una lógica y otra física.
• Físicamente, el documento está compuesto por unidades llamadas entidades. Una entidad puede hacer referencia a otras entidades para que éstas sean incluidas en el documento.
• Cada documento comienza con una entidad documento, también llamada raíz.
• Lógicamente, el documento está compuesto de declaraciones, elementos, comentarios, referencias a caracteres e instrucciones de procesamiento, todos los cuales están indicados por una marca explícita.
XML debe ser independiente de la plataforma sobre la cual se ejecute. El mismo código debe correr en una PC, MAC, etc.
10
• XML solo define datos. Los desarrolladores realizan software que utiliza estos datos para una plataforma en particular.
• Es importante que el código XML se estructure de la misma manera de forma que el software pueda ser fácilmente desarrollado.
• Restricción de código correcto: por estándar, cualquier error (por ejemplo por tags anidados incorrectamente) que se encuentre en un documento XML hará que no se ejecute y dará un mensaje de error.
• Para escribir documentos en XML es muy importante la sintaxis.
Declaración
Declarar un documento como XML:
< ?xml version= "1.0"?>
• Esto le dice a cualquier software que recibe este documento que:
– El contenido es XML
– Debe estar elaborado conforme con la especificación versión 1.0.
• Es opcional pero se recomienda su inclusión.
• En la actualidad esto no es un tag XML por lo tanto no necesita el correspondiente para cerrarlo.
Codificación
Un documento XML es básicamente un documento de texto. Se puede codificar en cualquier editor.
Las etiquetas a utilizar no están predefinidas y se escriben anidadas, unas dentro de otras.
El documento debe tener extensión XML.
<?xml version=" 1.0 " encoding=" UTF-8 " standalone= " yes "?> <ficha> <nombre> Juan </nombre> <apellido> Lupo </apellido> <direccion> San Martin 200 </direccion> </ficha>
4.3. Documentos bien formados y válidos
4.3.1. Documentos bien formados
Un documento XML se dice que está bien formado si encaja con las especificaciones XML de producción, lo que implica:
11
Estructura jerárquica de elementos
Los documentos XML deben seguir una estructura estrictamente jerárquica con lo que respecta a las etiquetas que delimitan sus elementos. Una etiqueta debe estar correctamente "incluida" en otra. Asimismo, los elementos con contenido, deben estar correctamente "cerrados". A continuación se muestra un ejemplo incorrecto y posteriormente otro ejemplo escrito correctamente.
<li>HTML <b> permite <i> esto </b> </i>. <li>En XML la <b> estructura <i> es </i> jerárquica </b>.</li>
Etiquetas vacías
HTML permite elementos sin contenido. XML también, pero la etiqueta debe ser de la siguiente forma <elemento sin contenido/>. A continuación se muestra un ejemplo incorrecto y posteriormente otro correcto.
<li>Esto es HTML <br> en el que casi todo está permitido </li> <li>En XML, es <br/> más restrictivo.</li>
Un solo elemento raíz
Los documentos XML sólo permiten un elemento raiz, del que todos los demás sean parte. Es decir, la jerarquía de elemento de un documento XML bien formado sólo puede tener un elemento inicial.
Valores de atributos
Los valores de atributos en XML siempre deben estar encerradas entre comillas simples (') o doble ("). En el siguiente ejemplo, la primera línea sería incorrecta en XML, no así la segunda:
<a HREF=http://www.campusvirtual.frsf.utn.edu.ar/> <a HREF="http:// campusvirtual.frsf.utn.edu.ar /">
Tipos de letras, espacios en blanco
El XML es sensible al tipo de letra que se utiliza, es decir, trata las mayúsculas y minúsculas como caracteres diferentes. Por lo tanto, los elemento definidos como "FICHA", "Ficha", "ficha" y "fiCha" serían elementos diferentes.
Existe un conjunto de caracteres denominados "espacios en blanco" que los procesadores XML tratan de forma diferente en el marcado XML. Estos caracteres son los ":espacios", tabuladores, retornos de carro y los saltos de línea.
La especificación XML 1.0 permite el uso de esos "espacios en blanco" para hacer más legible el código, y en general son ignorados por los procesadores XML.
En estos casos, sin embargo, los "espacios en blanco" resultan muy significativos, por ejemplo, para separar las palabras de un texto, o separa líneas de párrafos diferentes.
12
Nombrando cosas
Al utilizar XML, es necesario asignar nombres a las estructuras, tipos de elementos, entidades, elementos particulares, etc. En XML los nombres tienen algunas características en común.
No se pueden crear nombres que empiecen con la cadena "xml", "xML", "XML" o cualquier otra variante. Las letras y rayas se pueden usar en cualquier parte del nombre. También se pueden incluir dígitos, guiones y caracteres de punto, pero no se puede empezar por ninguno de ellos. El resto de caracteres, como algunos símbolos, y espacios en blanco, no se pueden usar.
Marcado y datos
Las construcciones con etiquetas, referencias de entidad y declaraciones se denominan "marcas".Éstas son las partes del documento que el procesador XML espera entender. El resto del documento que se encuentra entre las marcas son los datos que resultan entendibles por las personas.
Es sencillo reconocer las marcas en un documento XML. Son aquellas porciones que empiezan con "<" y acaban con ">", o bien, en el caso de las referencias de entidad, empiezan por "&" y acaban con ";".
4.3.2. Documentos válidos
Crear una definición del tipo de documento (DTD) es como crear nuestro propio lenguaje de marcado, para una aplicación específica. Por ejemplo, podríamos crear un DTD que defina una tarjeta de visitas. A partir de ese DTD, tendríamos una serie de elemento XML que nos permitirían definir tarjetas de visita.
La DTD define los tipos de elementos, atributos y entidades permitidas, y puede expresar algunas limitaciones para combinarlos.
Los documentos que se ajustan a su DTD, se denominan "válidos". El concepto de "validez" no tiene nada que ver con el de estar "bien formado". Un documento "bien formado" simplemente respeta la estructura y sintaxis definida por la especificación de XML. Un documento "bien formado" puede además ser "válido" si cumple las reglas de una DTD determinada. También existen documentos XML sin una DTD asociada, en ese caso no son "válido", pero tampoco "inválido"... simplemente "bien formados"... o no.
Una DTD puede residir en un archivo externo, y quizás compartido por varios (puede que miles) de documentos. O bien, puede estar contenido en el propio documento XML, como parte de su declaración de tipo de documento.
Veamos un ejemplo
<! DOCTYPE etiqueta[ <!ELEMENT etiqueta (nombre, calle, ciudad, pais, codigo)> <!ELEMENT nombre (#PCDATA)> <!ELEMENT calle (#PCDATA)> <!ELEMENT ciudad (#PCDATA)> <!ELEMENT pais (#PCDATA)> <!ELEMENT codigo (#PCDATA)> ]>
13
<etiqueta> <nombre>Fulano Mendez</nombre> <calle>San Jeronimo 234</calle> <ciudad>Santa Fe</ciudad> <pais>Argentina</pais> <codigo>3000</codigo> </etiqueta>
La declaración del tipo de documento empieza en la primera línea y termina con "]>". Las declaraciones DTD son las líneas que empiezan con "<!ELEMENT" y se denominan declaraciones de tipo elemento. También se pueden declarar atributos, entidades y anotaciones para una DTD.
En el ejemplo anterior, todas las declaraciones DTD se definen "etiquetas" residen dentro del documento. Sin embargo, la DTD se puede definir parcial o completamente en otro ejemplo. Por ejemplo:
<?xml version="1.0"?> <!DOCTYPE coche SYSTEM "http://www.sitio.com/dtd/coche.dtd"> <coche> <modelo>...</modelo> ... </coche>
Declaraciones Tipo Elemento
Los elementos son la base de las marcas XML, y deben ajustarse a un tipo de documento declarado en un DTD para que el documento XML sea considerado válido.
Las declaraciones de tipo de elemento deben empezar con "<!ELEMENT" seguidas por el identificador genérico del elemento que se declara. A continuación tienen una especificación de contenido.
Por ejemplo:
<!ELEMENT receta (titulo, ingredientes, procedimiento)>
En este ejemplo, el elemento <receta> puede contener dentro elementos <titulo>, <ingredientes> y <procedimiento>, que, a su vez, estarán definidos también en la DTD y podrán contener más elementos.
Siguiendo la definición de elemento anterior, este ejemplo de documento XML sería válido:
<receta> <titulo>...</titulo> <ingredientes>...</ingredientes> <procedimiento>...</procedimiento> </receta>
Pero no este:
<receta> <parrafo>Esto es un párrafo</parrafo>
14
<titulo>...</titulo> <ingredientes>...</ingredientes> <procedimiento>...</procedimiento> </receta>
La especificación de contenido puede ser de cuatro tipos:
EMPTY
Puede no tener contenido. Suele usarse para los atributos.
<!ELEMENT salto-de-pagina EMPTY>
ANY
Puede tener cualquier contenido. No se suele usar, ya que es conveniente estructurar adecuadamente nuestros documenteo XML.
<!ELEMENT cualquier ANY>
Mixed
Puede tener caracteres de tipo dato o una mezcla de caracteres y sub-elementos especificados en la especificación de contenido mixto.
<!ELEMENT enfasis (#PCDATA)>
<!ELEMENT parrafo (#PCDATA|enfasis)*>
Por ejemplo, el primer elemento definido en el ejemplo (<enfasis>) puede contener datos de carácter (#PCDATA). Y el segundo (<parrafo>) puede contener tanto datos de carácter (#PCDATA) como subelementos de tipo <enfasis>.
Element
Sólo puede contener sub-elementos especificados en la especificación de contenido.
<!ELEMENT mensaje (remite, destinatario, texto)>
Para declarar que un tipo de elemento tenga contenido de elementos se especifica un modelo de contenido en lugar de una especificación de contenido mixto o una de las claves ya descritas.
Modelos de contenido
Un modelo de contenido es un patrón que establece los sub-elementos aceptados, y el orden en que se acepta.
Un modelo sencillo puede tener un solo tipo de sub-elemento:
<!ELEMENT aviso (parrafo)>
Esto indica que <aviso> sólo puede contener un solo <parrafo>.
<!ELEMENT aviso (titulo, parrafo)>
La coma, en este caso, denota una secuencia. Es decir, el elemento <aviso> debe contener un <titulo> seguido de un <parrafo>.
15
<!ELEMENT aviso (parrafo | grafico)>
La barra vertical "|"indica una opción. Es decir, <aviso> puede contener o bien un <parrafo> o bien un <grafico>. El número de opciones no está limitado a dos, y se pueden agrupar usando paréntesis.
<!ELEMENT aviso (titulo, (parrafo | grafico))>
En este último caso, el <aviso> debe contener un <titulo> seguido de un <parrafo> o un <grafico>.
Además, cada partícula de contenido puede llevar un indicador de frecuencia, que siguen directamente a un identificador general, una secuencia o una opción, y no pueden ir precedidos por espacios en blanco.
Indicadores de frecuencia
? Opcional (0 o 1 vez)
* Opcional y repetible (0 o más veces)
+ Necesarui y repetible (1 o más veces)
Para entender esto, vamos a ver un ejemplo.
<!ELEMENT aviso (titulo?, (parrafo+, grafico)*)>
En este caso, <aviso> puede tener <titulo> o no (pero sólo uno), y puede tener cero o más conjuntos <parrafo><grafico>, <parrafo><parrafo><grafico>, etc.
Declaraciones de lista de atributos
Los atributos permiten añadir información adicional a los elementos de un documento. La principal diferencia entre los elementos y los atributos, es que los atributos no pueden contener sub-atributos. Se usan para añadir información corta, sencilla y desestructurada.
<mensaje prioridad="urgente"> <de>Alfredo Reino</de> <a>Hans van Parijs</a> <texto idioma="holandés"> Hallo Hans, hoe gaat het? ... </texto> </mensaje>
Otra diferencia entre los atributos y los elementos, es que cada uno de los atributos sólo se puede especificar una vez, y en cualquier orden.
En el ejemplo anterior, para declara la lista de atributo de los elementos <mensaje> y <texto> haríamos lo siguiente:
<!ELEMENT mensaje (de, a, texto)> <!ATTLIST mensaje prioridad (normal | urgente) normal>
16
<!ELEMENT texto (#PCDATA)> <!ATTLIST texto idioma CDATA #REQUIRED>
Las declaraciones de los atributos empiezan con "<!ATTLIST", y a continuación del espacio en blanco viene el identificador del elemento al que se aplica el atributo. Después viene el nombre del atributo, su tipo y su valor por defecto. En el ejemplo anterior, el atributo "prioridad" puede estar en el elemento <mensaje> y puede tener el valor "normal" o "urgente", siendo "normal" el valor por defecto si no especificamos el atributo.
El atributo "idioma", pertenece al atributo texto, y puede contener datos de carácter CDATA. Es más, la palabra #REQUIRED significa que no tiene valor por defecto, ya que es obligatoria especificar este atributo.
A menudo interesa que se pueda omitir un atributo, sin que se adopte automáticamente un valor por defecto. Para esto se usa la condición "#IMPLIED". Por ejemplo, en una supuesta DTD que define la etiqueta <IMG> de HTML:
<!ATTLIST IMG URL CDATA #REQUIRED> <!ALT CDATE #IMPLIED>
Es decir, el atributo "URL" es obligatorio, mientras que el "ALT" es opcional (y si se omite, no toma ningún elemento por defecto).
Tipos de atributos
Atributos CDATA y NMTOKEN
Los atributos CDATA (Character DATA)son los más sencillos, y pueden contener casi cualquier cosa. Los atributos NMTOKEN (NaMe TOKEN) son parecidos, pero sólo aceptan los caracteres válidos para nombrar cosas (letras, números, puntos, guiones, subrayados y los dos puntos).
<!ATTLIST mensaje fecha CDATA #REQUIRED> <mensaje fecha="15 de Diciembre de 1999"> <!ATTLIST mensaje fecha NMTOKEN #REQUIRED> <mensaje fecha="15-12-1999">
Atributos enumerados y notaciones
Los atributos enumerados son aquellos que sólo pueden contener un valor de entre un número reducido de opciones.
<!ATTLIST mensaje prioridad (normal | urgente) normal>
Existe otro tipo de atributo parecido, llamado de notación (NOTATION). Este tipo de atributo permite al autor declarar que su valor se ajusta a una notación declarada.
<!ATTLIST mensaje fecha NOTATION (ISO-DATE | EUROPEAN-DATE) #REQUIRED>
Para declarar las notaciones, se utiliza "<!NOTATION" con una definición externa de la notación. La definición externa puede ser pública o un identificador del sistema para la documentación de la notación, una especificación formal o un asistente de la aplicación que contenga objetos representados en la notación
17
<!NOTATION HTML SYSTEM "http://www.w3.org/Markup">
<!NOTATION HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
Atributos ID e IDREF
El tipo ID permite que un tipo determinado tenga un nombre único que podrá ser referenciado por un atributo de otro elemento que sea de tipo IDREF. Por ejemplo, para implementar un sencillo sistema de hipervínculos en un documento:
<!ELEMENT enlace EMPTY> <!ATTLIST enlace destino IDREF #REQUIRED> <!ELEMENT capitulo (parrafo)*> <!ATTLIST capitulo referencia ID #IMPLIED>
En este caso, una etiqueta <enlace destino="seccion-3"> haría referencia a un <capitulo referencia="seccion-3">, de forma que el procesador XML lo podría convertir en un hipervínculos, u otra cosa.
Declaración de entidades
XML hace referencia a objetos (ficheros, páginas web, imágenes, cualquier cosa) que no deben ser analizados sintácticamente según las reglas de XML, mediante el uso de entidades. Se declaran en la DTD mediante el uso de "<!ENTITY"
Una entidad puede no ser más que una abreviatura que se utiliza como una forma corta de algunos textos. Al usar una referencia a esta entidad, el analizador sintáctico reemplaza la referencia con su contenido. En otras ocasiones es una referencia a un objeto externo o local.
Las entidades pueden ser:
• Internas o Externas
• Analizadas o No analizadas
• Generales o Parámetro
Entidades generales internas
Son las más sencillas. Son básicamente abreviaturas definidas en la sección de la DTD del documento XML. Son siempre entidades analizadas, es decir, una vez reemplazada la referencia a la entidad por su contenido, pasa a ser parte del documento XML y como tal, es analizada por el procesador XML.
<!DOCTYPE texto [ <!ENTITY alf "Alien Life From"> ]> <texto><titulo>Un día en la vida de un &alf</titulo></texto>
Entidades generales externas analizadas
Las entidades externas obtienen su contenido en cualquier otro sitio del sistema, ya sea otro archivo del disco duro, una página web o un objeto de una base de
18
datos. Se hace referencia al contenido de una entidad así mediante la palabra SYSTEM seguida de un URI (Universal Resource Identifier)
<!ENTITY intro SYSTEM "http://www.miservidor.com/intro.xml">
Entidades no analizadas
Evidentemente, si el contenido de la entidad es un archivo MPG o una imagen GIF o un fichero ejecutable EXE, el procesador XML no debería intentar interpretarlo como si fuera texto XML. Este tipo de entidades siempre son generales y externas.
<!ENTITY logo SYSTEM "http://www.miservidor.com/logo.gif">
Entidades parámetro internas y externas
Se denominan entidades parámetro a aquellas que sólo pueden usarse en la DTD, y no en el documento XML. Se puede utilizar para agrupar ciertos elementos del DTD que se repitan mucho. Se diferencian las entidades parámetro de las generales, en que para hacer referencia a ellas, se usa el símbolo "%" en lugar de "&" tanto para declararlas como para usarlas.
<!DOCTYPE texto [ <!ENTITY % elemento-alf "<!ELEMENT ALF (#PCDATA)>"> ... %elemento-alf; ]>
También puede ser externa:
<!DOCTYPE texto [ <!ENTITY % elemento-alf SYSTEM "alf.ent"> ... %elemento-alf; ]>
Ejemplos de DTD
Un ejemplo de DTD que puede servir para resumir todo lo visto hasta ahora podría ser un DTD que nos defina un lenguaje de marcado para una base de datos de personas con direcciones e-mail.
El fichero LISTIN.DTD podría ser algo así:
<?xml encoding="UTF-8"?> <!ELEMENT listin (persona)+> <!ELEMENT persona (nombre, email*, relacion?)> <!ATTLIST persona id ID #REQUIRED> <!ATTLIST persona sexo (hombre | mujer) #IMPLIED> <!ELEMENT nombre (#PCDATA)> <!ELEMENT email (#PCDATA)> <!ELEMENT relacion EMPTY> <!ATTLIST relacion amigo-de IDREFS #IMPLIED enemigo-de IDREFS #IMPLID>
19
Basándonos en este DTD, podríamos escribir nuestro primer listín en XML de la siguiente manera:
<?xml version="1.0"?> <!DOCTYPE listin SYSTEM "listin.dtd"> <listin> <persona sexo="hombre" id="ricky"> <nombre>Ricky Martin</nombre> <email>[email protected]</email> <relacion amigo-de="leatitia"> </persona> <persona sexo="mujer" id="leatitia"> <nombre>Leatitia Casta</nombre> <email>[email protected]</email> </persona> </listin>
2.4. Namespaces
El poder de XML proviene de su flexibilidad, del hecho de que usted, yo y millones de otras personas podamos definir nuestras propias etiquetas para describir nuestros datos. ¿Recuerda el ejemplo del documento XML con el nombre y dirección de una persona? Ese documento incluía el elemento <titulo> para el título o tratamiento de cortesía, una elección perfectamente razonable como nombre de un elemento. Si usted crea una librería online, podría elegir el crear un elemento <titulo> para almacenar el título de un libro. Si crea una compañía hipotecaria online, podría elegir crear un elemento <titulo> Para el título de una propiedad. Todas son elecciones razonables, pero todas ellas crean elementos con el mismo nombre. ¿Cómo saber si, dado un elemento <titulo> se refiere a una persona, un libro o una propiedad? Con los namespaces.
Para usar un namespace, debe definir un prefijo namespace y mapearlo a una cadena particular.
Así es cómo se deberían definir prefijos namespace para nuestros tres elementos <titulo>:
<?xml version="1.0"?>
<resumen_usuario
xmlns:direccion="http://www.xyz.com/direcciones/"
xmlns:libros="http://www.zyx.com/libros/"
xmlns:hipoteca="http://www.yyz.com/hipotecas/"
>
... <direccion:nombre><titulo>Mrs.</titulo> ... </direccion:nombre> ...
... <libros:titulo>El Señor de los Anillos</libros:titulo> ...
... <hipoteca:titulo>NC2948-388-1983</hipoteca:titulo> ...
20
En este ejemplo, los tres prefijos del namespace son direccion, libros e hipoteca.
Dese cuenta que la definición de un namespace para un elemento particular significa que todos los elementos hijos pertenecen al mismo namespace. El primer elemento <titulo> pertenece al namespace direccion debido a que su elemento padre <direccion:Nombre>, ya pertenecía a ese namespace.
El punto final: La cadena de una definición de namespace es solo una cadena. Si, esa cadena parece una URL, pero no lo es. Podría definir xmlns:direccion="mike" y funcionaría exactamente igual, Lo único que importa acerca de la cadena del namespace es que sea única; por esto la mayor parte de las definiciones de namespace parecen URLs. Los parser XML no van a la dirección http://www.zyx.com/libros/ para buscar una DTD o un Esquema, simplemente usan esos textos como cadenas. Es confuso, pero así es como funcionan los namespaces.
2.5. Parser
Editores XML
Un editor XML es una herramienta que nos ofrece facilidades para crear y editar documentos XML. Inicialmente podemos trabajar con un simple editor de textos si estamos familiarizados con la sintaxis y características del XML aunque es recomendable un editor específico. Dentro de estos, existen dos tipos principales:
• Los que representan los ficheros en forma de árbol y nos permiten construir nuestro documento trabajando sobre este árbol y formularios adicionales (por ejemplo: XML Notepad de Microsoft o Visual XML).
• Los que representan el documento XML en su formato original y que normalmente son editores de ficheros de texto con facilidades para XML (por ejemplo: XED o PSGML de Emacs).
Entre ambos tipos hay que diferenciar los que trabajan con una DTD y por lo tanto validan el contenido de lo que escribimos y los que simplemente nos aseguran que el documento XML es bien formado, es decir, sintácticamente correcto respecto de las especificaciones del XML.
Editores de DTD
Como hemos comentado anteriormente, en una DTD se define como es la estructura de un documento XML, es decir, los elementos que formarán ese tipo de documento y como están relacionados. A diferencia que en SGML, en XML no es obligatorio crearlas, aunque es recomendable por que nos facilitará la validación de documentos. Algunos ejemplos de estos editores son el TDTD para Emacs o el EZDTD que también trabaja con SGML.
Procesadores XML
El parser o procesador de XML es la herramienta principal de cualquier aplicación XML. Mediante este parser no solamente podemos comprobar si nuestros documentos son bien formados o válidos, sino que también podemos incorporarlos
21
a nuestras aplicaciones, de manera que estas puedan manipular y trabajar con documentos XML.
De acuerdo con su función, los procesadores XML se dividen en dos tipos: validadores y no-validadores. En común tienen que ambos deben informar de las violaciones de las restricciones de documento bien formado dadas en su especificación. Además, los procesadores validadores, deben informar de la violación de las restricciones expresadas por las declaraciones del DTD.
Document Object Model
El Document Object Model, comúnmente llamado DOM, define un conjunto de interfaces a la versión parseada de un documento XML. El parser lee el documento completo y construye un árbol en la memoria, de forma que el código puede entonces utilizar las interfaces DOM para manipular ese árbol. Es posible moverse a través del árbol para ver lo que el documento original contenía, se pueden borrar secciones del árbol, reordenarlo, añadir nuevas ramas, etc.
DOM fue creado por el W3C, y es una Recomendación Oficial del consorcio.
Limitaciones de DOM
DOM proporciona un rico conjunto de funciones que pueden usarse para interpretar y manipular un documento XML, pero esas funciones tienen un precio. Tan pronto como el DOM para XML original empezó a desarrollarse, mucha gente en la lista de correos de XML-DEV empezó a preocuparse acerca de lo siguiente:
� DOM construye un árbol en la memoria con el documento entero. Si el documento es muy grande ser requiere una cantidad significativa de memoria.
� DOM crea objetos que los representan todo en el documento original, incluyendo elementos, texto, atributos y espacios en blanco. Si solo se tiene interés en una pequeña parte del documento original, es extremadamente costoso crear todos esos objetos que nunca se usarán.
� Un parser DOM tiene que leer el documento entero antes de que el código pueda tomar el control. Para documentos muy grandes esto puede causar un retraso significativo.
Estas son algunas de las debilidades derivadas del diseño del Document Object Model; independientemente de estas, el API DOM es una forma muy útil de parsear documentos XML.
Simple API for XML
Para soslayar las carencias de DOM, los participantes de XML-DEV (liderados por David Megginson) crearon la interfaz SAX. SAX tiene diversas características que solucionan las limitaciones de DOM.
� Un parser SAX envía eventos al código. El parser le dice cuando ha encontrado el comienzo y/o fín del documento, elemento, texto, etc. Usted decide que eventos son importantes y que tipo de estructura de datos desea crear para almacenarlos. Si no salva explícitamente los datos de un evento, se perderán.
22
� Un parser SAX no crea ningún objeto en absoluto, simplemente envía eventos hacía su aplicación. Si desea crear objetos basados en esos eventos, es cosa suya.
� Un parser SAX empieza a enviar eventos tan pronto como se inicia. Su código recibirá un evento cuando el parser encuentre el inicio del documento, cuando encuentre el inicio de un elemento, texto, etc. Su aplicación comenzará a generar resultados inmediatamente, sin tener que esperar hasta que el documento entero haya sido parseado. Aún mejor, si solo está buscando algunas cosas en el documento, su código puede elevar una excepción sólo si ha encontrado lo que estaba buscando. Una excepción detiene el parser SAX y su código entonces puede hacer cualquier cosa que necesite hacer con los datos encontrados.
Dicho esto, tanto SAX como DOM tienen su lugar respectivo. El resto de esta sección discute el porqué usted querría usar una u otra interfaz.
Limitaciones de SAX
Para ser sinceros, los parsers SAX tienen limitaciones que pueden causar preocupación:
� Los eventos SAX no tienen estado. Cuando un parser SAX encuentra texto en un documento XML, envía un evento a su código. Este evento solo le indica el texto encontrado; no le dice que elemento contenía ese texto. Si quiere saberlo, tiene que escribir el código para la gestión de estado usted mismo.
� Los eventos SAX no son permanentes. Si su aplicación necesita una estructura de datos que modele el documento XML, debe escribir ese código usted mismo. Si necesita acceder a los datos de un evento SAX y no los ha almacenado en su código, tiene que parsear el documento de nuevo.
� SAX no está controlado por una organización centralizada. Aunque esto no ha causado problemas hasta hoy, algunos desarrolladores se sentirían más cómodos si SAX estuviese controlado por una organización como la W3C.