教程 XML, XSLT 和 XPath Ruby

¿Qué es XML?

XML significa lenguaje de marcado extensible (eXtensible Markup Language).

El lenguaje de marcado extensible, un subconjunto del lenguaje de marcado general, es un lenguaje de marcado utilizado para marcar documentos electrónicos para que tengan una estructura.

Se puede usar para marcar datos, definir tipos de datos y es un lenguaje de origen que permite a los usuarios definir su propio lenguaje de marcado. Es muy adecuado para la transmisión en la web, proporcionando un método unificado para describir y intercambiar datos estructurados independientes de la aplicación o del proveedor.

Para obtener más información, consulte nuestra Tutorial de XML

Estructura del analizador de XML y API

Los analizadores de XML主要有DOM y SAX.

• El analizador SAX se basa en el procesamiento de eventos, se necesita escanear el documento XML de principio a fin, y en el proceso de escaneo, cada vez que se encuentra una estructura de sintaxis, se llama al programa de procesamiento de eventos de esa estructura de sintaxis específica y se envía un evento a la aplicación.

• DOM es el modelo de objeto de documento, que analiza la estructura de sintaxis de nivel de documento, construye una estructura de sintaxis de nivel de documento en la memoria, y establece un árbol DOM en la memoria. Los nodos del árbol DOM se identifican en forma de objeto, y después de que se complete el análisis del documento, todo el árbol DOM del documento se colocará en la memoria.

Análisis y creación de XML en Ruby

El análisis de documentos XML en RUBY se puede realizar utilizando esta biblioteca REXML.

La biblioteca REXML es un paquete de XML para Ruby, escrito en lenguaje Ruby puro y sigue el estándar XML.1.0 especificación.

en Ruby1.8versión y posteriores, la biblioteca estándar de RUBY incluirá REXML.

La ruta de la biblioteca REXML es: rexml/documento

todos los métodos y clases están encapsulados en un módulo REXML.

Los beneficios del analizador REXML en comparación con otros analizadores son los siguientes:

• 100% escrito en Ruby.

• aplicable a analizadores SAX y DOM.

• Es ligero, menos de2000 líneas de código.

• métodos y clases fáciles de entender.

• basado en SAX2 API y soporte XPath completo.

• se instala con Ruby, sin necesidad de instalarlo por separado.

A continuación, se muestra un ejemplo de código XML, guardado como movies.xml:

<colección estantería="Nuevas Llegadas">
<película título="Enemigo Detrás">
　　　<tipo>Guerra, Thriller</tipo>
　　　<formato>DVD</formato>
　　　<año>2003</año>
　　　<calificación>PG</calificación>
　　　<estrellas>10</estrellas>
　　　<descripción>Hablemos de un EE. UU.-guerra japonesa</descripción>
</película>
<película título="Transformers">
　　　<tipo>Anime, Ficción Científica</tipo>
　　　<formato>DVD</formato>
　　　<año>1989</año>
　　　<calificación>R</calificación>
　　　<estrellas>8</estrellas>
　　　<descripción>Ficción científica</descripción>
</película>
　　　<película título="Trigun">
　　　<tipo>Anime, Acción</tipo>
　　　<formato>DVD</formato>
　　　<episodios>4</episodios>
　　　<calificación>PG</calificación>
　　　<estrellas>10</estrellas>
　　　<descripción>Vash the Stampede!</descripción>
</película>
<película título="Ishtar">
　　　<tipo>Comedia</tipo>
　　　<formato>VHS</formato>
　　　<calificación>PG</calificación>
　　　<estrellas>2</estrellas>
　　　<descripción>Aburrimiento visible</descripción>
</película>
</colección>

analizador DOM

Vamos a analizar los datos XML primero, primero introducimos rexml/la biblioteca de documentos, generalmente podemos importar REXML en el espacio de nombres superior:

Ejemplo en línea

#!/usr/bin/ruby　-w
　
require 'rexml'/documento'
include REXML
　
xmlfile = File.new("movies.xml")
xmldoc = Document.new(xmlfile)
　
# obtener el elemento root
root = xmldoc.root
puts "elemento raíz : "　+　root.attributes["shelf"]
　
# A continuación, se mostrarán los atributos del elemento raíz
xmldoc.elements.each("collection",/# A continuación, se mostrarán los títulos de las películas　
　　　movie){　+　|e| puts "Título de la Película: "　
}
　
e.attributes["title"]
xmldoc.elements.each("collection",/movie/# A continuación, se mostrarán todos los tipos de películas
　　　|e| puts "Tipo de Película: "　+　e.text　
}
　
# A continuación, se mostrarán todas las descripciones de películas
xmldoc.elements.each("collection",/movie/description) {
　　　|e| puts "Descripción del Película: "　+　e.text　
}

El resultado de la salida del ejemplo anterior es:

Elemento raíz: New Arrivals
Título de la Película: Enemy Behind
Título de la Película: Transformers
Título de la Película: Trigun
Título de la Película: Ishtar
Tipo de Película: Guerra, Thriller
Tipo de Película: Anime, Ciencia Ficción
Tipo de Película: Anime, Acción
Tipo de Película: Comedia
Descripción del Película: Hablar de un EE. UU.-Guerra de Japón
Descripción del Película: Una ciencia ficción
Descripción del Película: Vash the Stampede!
Descripción del Película: Boredom visible
SAX-como Parsing:

Analizador SAX

Procesar el mismo archivo de datos: movies.xml, no se recomienda la解析 de un archivo pequeño con SAX, aquí hay un ejemplo simple:

Ejemplo en línea

#!/usr/bin/ruby　-w
　
require 'rexml'/documento'
require 'rexml'/streamlistener'
include REXML
　
　
class MyListener
　　include REXML::StreamListener
　　def tag_start(*args)
　　　　puts "tag_start: #{args.map {|x| x.inspect}.join(', ')}"
　　fin
　
　　def text(data)
　　　　return if data =~　/^\w*$/　　　　　# solo espacio en blanco
　　　　abbrev = data[0..40]　+　(data.length　>}　40　?　"..."　:　"")
　　　　puts　"　　text　　　:　　　#{abbrev.inspect}"
　　fin
fin
　
list　=　MyListener.new
xmlfile = File.new("movies.xml")
Document.parse_stream(xmlfile,　list)

El resultado de la salida anterior es：

tag_start:　"collection",　{"shelf"=>"Nuevas Llegadas"}
tag_start:　"movie",　{"title"=>"Enemy Behind"}
tag_start:　"type",　{}
　　text　　　:　　　"Guerra, Thriller"
tag_start:　"format",　{}
tag_start:　"year",　{}
tag_start:　"rating",　{}
tag_start:　"stars",　{}
tag_start:　"description",　{}
　　text　　　:　　　"Hablemos de una guerra de EE. UU."-Guerra de Japón"
tag_start:　"movie",　{"title"=>"Transformers"}
tag_start:　"type",　{}
　　text　　　:　　　"Anime, Science Fiction"
tag_start:　"format",　{}
tag_start:　"year",　{}
tag_start:　"rating",　{}
tag_start:　"stars",　{}
tag_start:　"description",　{}
　　text　　　:　　　"Una ciencia ficción"
tag_start:　"movie",　{"title"=>"Trigun"}
tag_start:　"type",　{}
　　text　　　:　　　"Anime, Action"
tag_start:　"format",　{}
tag_start:　"episodes",　{}
tag_start:　"rating",　{}
tag_start:　"stars",　{}
tag_start:　"description",　{}
　　text　　　:　　　"Vash the Stampede!"
tag_start:　"movie",　{"title"=>"Ishtar"}
tag_start:　"type",　{}
tag_start:　"format",　{}
tag_start:　"rating",　{}
tag_start:　"stars",　{}
tag_start:　"description",　{}
　　text　　　:　　　"Aburrimiento visible"

XPath y Ruby

Podemos usar XPath para ver XML, XPath es un lenguaje utilizado para encontrar información en documentos XML (ver:)Tutorial de XPath)。

XPath es el lenguaje de paths XML, que es un lenguaje utilizado para determinar la ubicación de una parte de un documento XML (subconjunto del lenguaje de marcado general). XPath se basa en la estructura en árbol del XML, proporcionando la capacidad de buscar nodos en la estructura de datos en árbol.

Ruby mediante la clase XPath de REXML admite XPath, que es una análisis basado en árboles (modelo de objeto de documento).

Ejemplo en línea

#!/usr/bin/ruby　-w
　
require 'rexml'/documento'
include REXML
　
xmlfile = File.new("movies.xml")
xmldoc = Document.new(xmlfile)
　
# Información del primer película
movie = XPath.first(xmldoc, ""//movie)
p movie
　
# Imprimir todos los tipos de películas
XPath.each(xmldoc, ""//type) { |e| puts e.text }
　
# Obtener todos los tipos de formatos de películas, devolver un array
names = XPath.match(xmldoc, ""//format).map { |x| x.text }
p names

El resultado de la salida del ejemplo anterior es:

<movie title='Enemy Behind'> ... </>
Guerra, Thriller
Anime, Ciencia Ficción
Anime, Acción
Comedia
["DVD", "DVD", "DVD", "VHS"]

XSLT y Ruby

Ruby tiene dos analizadores XSLT, a continuación se proporciona una descripción breve:

Ruby-Sablotron

Este analizador fue escrito y mantenido por Masayoshi Takahashi. Este es principalmente para el sistema operativo Linux, y requiere las siguientes bibliotecas:

• Sablot

• Iconv

• Expat

Puede encontrar Ruby-Sablotron Encontrar estas bibliotecas.

XSLT4R

XSLT4R fue escrito por Michael Neumann. XSLT4R se utiliza para interacción de línea de comandos simple y puede ser utilizado por aplicaciones de terceros para convertir documentos XML.

XSLT4R necesita la operación XMLScan, que contiene XSLT4El archivo de archivo R, que es una100% de los módulos de Ruby. Estos módulos se pueden instalar utilizando el método de instalación estándar de Ruby (es decir, Ruby install.rb).

XSLT4El formato de sintaxis de R es el siguiente:

ruby xslt.rb stylesheet.xsl document.xml [arguments]

Si desea usar XSLT en su aplicación4R, puede introducir XSLT y los parámetros necesarios. Ejemplo a continuación:

Ejemplo en línea

require "xslt"
　
stylesheet = File.readlines("stylesheet.xsl").to_s
xml_doc　=　File.readlines("document.xml").to_s
arguments　=　{　'image_dir'　=>　'/....'　}
　
sheet　=　XSLT::Stylesheet.new(　stylesheet,　arguments　)
　
#　output　to　StdOut
sheet.apply(　xml_doc　)
　
#　output　to　'str'
str　=　""
sheet.output　=　[　str　]
sheet.apply(　xml_doc　)

Más información

• Análisis completo del analizador REXML, consulte el documento Documentación del analizador REXML。

• Puedes obtener desde Base de conocimientos RAA Descargar XSLT aquí4R。