Tutoriels Ruby XML, XSLT et XPath
Qu'est-ce que XML ?
XML fait référence à eXtensible Markup Language.
Extensible Markup Language, un sous-ensemble du Standard Universal Markup Language, un langage de balisage utilisé pour baliser les documents électroniques afin de les structurer.
Il peut être utilisé pour marquer des données et définir des types de données. C'est un langage source qui permet aux utilisateurs de définir leur propre langage de balisage. Il est parfaitement adapté au transport sur le World Wide Web, offrant une approche unifiée pour décrire et échanger des données structurées indépendamment des applications ou des fournisseurs.
Pour plus d'informations, veuillez consulter notre didacticiel XML
Structure et API de l'analyseur XML
Il existe deux principaux types d'analyseurs XML : DOM et SAX.
L'analyseur SAX est basé sur le traitement d'événements et doit analyser le document XML du début à la fin. Au cours du processus d'analyse, il sera appelé à chaque fois qu'une structure grammaticale est rencontrée. gestionnaire d'événements avec une structure syntaxique spécifique qui envoie un événement à l'application.
DOM est une analyse de modèle objet de document, qui construit la structure syntaxique hiérarchique du document et crée une arborescence DOM dans la mémoire. Les nœuds de l'arborescence DOM sont identifiés sous forme d'objets. . Une fois l'analyse du document terminée, l'intégralité de l'arborescence DOM du document est placée en mémoire.
Analyse et création de XML dans Ruby
Pour analyser des documents XML dans RUBY, vous pouvez utiliser la bibliothèque REXML.
La bibliothèque REXML est une boîte à outils XML pour Ruby. Elle est écrite en langage Ruby pur et est conforme à la spécification XML1.0.
Dans Ruby version 1.8 et versions ultérieures, REXML sera inclus dans la bibliothèque standard RUBY.
Le chemin de la bibliothèque REXML est : rexml/document
Toutes les méthodes et classes sont encapsulées dans un module REXML.
L'analyseur REXML présente les avantages suivants par rapport aux autres analyseurs :
100 % écrit en Ruby.
fonctionne avec les analyseurs SAX et DOM.
Il est léger, moins de 2000 lignes de code.
Méthodes et cours faciles à comprendre.
Basé sur l'API SAX2 et la prise en charge complète de XPath.
Utilise l'installation Ruby au lieu d'une installation séparée.
Ce qui suit est le code XML de l'exemple, enregistré sous movie.xml :
<collection shelf="New Arrivals"> <movie title="Enemy Behind"> <type>War, Thriller</type> <format>DVD</format> <year>2003</year> <rating>PG</rating> <stars>10</stars> <description>Talk about a US-Japan war</description> </movie> <movie title="Transformers"> <type>Anime, Science Fiction</type> <format>DVD</format> <year>1989</year> <rating>R</rating> <stars>8</stars> <description>A schientific fiction</description> </movie> <movie title="Trigun"> <type>Anime, Action</type> <format>DVD</format> <episodes>4</episodes> <rating>PG</rating> <stars>10</stars> <description>Vash the Stampede!</description> </movie> <movie title="Ishtar"> <type>Comedy</type> <format>VHS</format> <rating>PG</rating> <stars>2</stars> <description>Viewable boredom</description> </movie> </collection>
Analyseur DOM
Analysons le XML d'abord Données, nous introduisons d'abord la bibliothèque rexml/document. Habituellement, nous pouvons introduire REXML dans l'espace de noms de niveau supérieur :
#!/usr/bin/ruby -w
require 'rexml/document'
include REXML
xmlfile = File.new("movies.xml")
xmldoc = Document.new(xmlfile)
# 获取 root 元素
root = xmldoc.root
puts "Root element : " + root.attributes["shelf"]
# 以下将输出电影标题
xmldoc.elements.each("collection/movie"){
|e| puts "Movie Title : " + e.attributes["title"]
}
# 以下将输出所有电影类型
xmldoc.elements.each("collection/movie/type") {
|e| puts "Movie Type : " + e.text
}
# 以下将输出所有电影描述
xmldoc.elements.each("collection/movie/description") {
|e| puts "Movie Description : " + e.text
}Le résultat de sortie de l'exemple ci-dessus est :
Root element : New Arrivals Movie Title : Enemy Behind Movie Title : Transformers Movie Title : Trigun Movie Title : Ishtar Movie Type : War, Thriller Movie Type : Anime, Science Fiction Movie Type : Anime, Action Movie Type : Comedy Movie Description : Talk about a US-Japan war Movie Description : A schientific fiction Movie Description : Vash the Stampede! Movie Description : Viewable boredom SAX-like Parsing:
Analyseur SAX
Traitez le même fichier de données : movies.xml Il n'est pas recommandé d'analyser SAX dans un petit fichier. Ce qui suit est un exemple simple :
#!/usr/bin/ruby -w
require 'rexml/document'
require 'rexml/streamlistener'
include REXML
class MyListener
include REXML::StreamListener
def tag_start(*args)
puts "tag_start: #{args.map {|x| x.inspect}.join(', ')}"
end
def text(data)
return if data =~ /^\w*$/ # whitespace only
abbrev = data[0..40] + (data.length > 40 ? "..." : "")
puts " text : #{abbrev.inspect}"
end
end
list = MyListener.new
xmlfile = File.new("movies.xml")
Document.parse_stream(xmlfile, list)Le résultat de sortie ci-dessus est. :
tag_start: "collection", {"shelf"=>"New Arrivals"}
tag_start: "movie", {"title"=>"Enemy Behind"}
tag_start: "type", {}
text : "War, Thriller"
tag_start: "format", {}
tag_start: "year", {}
tag_start: "rating", {}
tag_start: "stars", {}
tag_start: "description", {}
text : "Talk about a US-Japan war"
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 : "A schientific fiction"
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 : "Viewable boredom"XPath et Ruby
On peut utiliser XPath pour visualiser XML XPath est un langage permettant de trouver des informations dans des documents XML (voir : Tutoriel XPath).
XPath est le langage de chemin XML, qui est un langage utilisé pour déterminer l'emplacement d'une certaine partie d'un document XML (un sous-ensemble du Standard Universal Markup Language). XPath est basé sur la structure arborescente de XML et offre la possibilité de rechercher des nœuds dans l'arborescence de la structure des données.
Ruby prend en charge XPath via la classe XPath de REXML, qui est une analyse basée sur une arborescence (Document Object Model).
#!/usr/bin/ruby -w
require 'rexml/document'
include REXML
xmlfile = File.new("movies.xml")
xmldoc = Document.new(xmlfile)
# 第一个电影的信息
movie = XPath.first(xmldoc, "//movie")
p movie
# 打印所有电影类型
XPath.each(xmldoc, "//type") { |e| puts e.text }
# 获取所有电影格式的类型，返回数组
names = XPath.match(xmldoc, "//format").map {|x| x.text }
p namesLe résultat de sortie de l'exemple ci-dessus est :
<movie title='Enemy Behind'> ... </> War, Thriller Anime, Science Fiction Anime, Action Comedy ["DVD", "DVD", "DVD", "VHS"]
XSLT et Ruby
Il existe deux analyseurs XSLT dans Ruby Une brève description est donnée ci-dessous :
Ruby-Sablotron
Cet analyseur est écrit. et maintenu par le juge Masayoshi Takahash. Ceci est principalement écrit pour le système d'exploitation Linux et nécessite les bibliothèques suivantes :
Sablot
Iconv
-
Expat
Vous pouvez trouver ces bibliothèques dans Ruby-Sablotron.
XSLT4R
XSLT4R écrit par Michael Neumann. XSLT4R est utilisé pour une interaction simple en ligne de commande et peut être utilisé par des applications tierces pour transformer des documents XML.XSLT4R nécessite le fonctionnement de XMLScan et inclut l'archive XSLT4R, qui est un module 100 % Ruby. Ces modules peuvent être installés à l'aide de la méthode d'installation standard de Ruby (c'est-à-dire Ruby install.rb).
Le format de syntaxe de XSLT4R est le suivant :
ruby xslt.rb stylesheet.xsl document.xml [arguments]
Si vous souhaitez utiliser XSLT4R dans votre application, vous pouvez introduire XSLT et saisir les paramètres dont vous avez besoin. Un exemple est le suivant :
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 )Pour plus d'informations
Pour l'analyseur REXML complet, veuillez consulter la documentation Documentation de l'analyseur REXML.
Vous pouvez télécharger XSLT4R à partir de la base de connaissances RAA.
