Tutoriel Ruby de base

Tutoriel Ruby avancé

教程 XML, XSLT 和 XPath Ruby

Qu'est-ce que l'XML ?

XML signifie le langage de balisage extensible (eXtensible Markup Language).

Langage de balisage extensible, sous-ensemble du langage de balisage général standard, un langage de balisage utilisé pour marquer des documents électroniques afin qu'ils aient une structure.

Il peut être utilisé pour marquer des données, définir des types de données, c'est une source de langage qui permet aux utilisateurs de définir leur propre langage de balisage. Il est très approprié pour le transfert du web, fournissant une méthode uniforme pour décrire et échanger des données structurées indépendantes de l'application ou du fournisseur.

Pour plus de détails, veuillez consulter notre Tutoriel XML

Structure et API de l'analyseur XML

Les analyseurs XML principaux sont DOM et SAX.

L'analyseur SAX est basé sur le traitement des événements, il faut scanner le document XML de la tête à la queue, pendant le processus de balayage, chaque fois qu'il rencontre une structure syntaxique, il appelle le programme de traitement des événements de cette structure syntaxique spécifique et envoie un événement à l'application.
DOM est le modèle objet de document (DOM) pour analyser, construire une structure syntaxique hiérarchique de document, établit un arbre DOM en mémoire, les nœuds de l'arbre DOM sont identifiés sous forme d'objets, après l'analyse du document, l'arbre DOM entier du document sera placé en mémoire.

Analyse et création de XML en Ruby

L'analyse de documents XML en Ruby peut utiliser cette bibliothèque REXML.

La bibliothèque REXML est un ensemble d'outils XML pour ruby, écrite en pure Ruby, conforme à XML1.0 spécification.

Dans Ruby1.8et versions ultérieures, RUBY standard library contiendra REXML.

Le chemin de la bibliothèque REXML est : rexml/document

Toutes les méthodes et classes sont encapsulées dans un module REXML.

Les avantages de l'analyseur REXML par rapport aux autres analyseurs sont les suivants :

100% écrit en Ruby.
Appliquable aux analyseurs SAX et DOM.
C'est léger, pas plus de2000 lignes de code.
Méthodes et classes faciles à comprendre.
Basé sur SAX2 Support complet de l'API et de l'XPath.
Il peut être installé avec Ruby sans installation séparée.

Voici un exemple de code XML, sauvegardé sous movies.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>Parler d'un US-Guerre du Japon</description>
</movie>
<movie title="Transformers">
　　　<type>Anime, Science Fiction</type>
　　　<format>DVD</format>
　　　<year>1989</year>
　　　<rating>R</rating>
　　　<stars>8</stars>
　　　<description>Une science-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>Comédie</type>
　　　<format>VHS</format>
　　　<rating>PG</rating>
　　　<stars>2</stars>
　　　<description>Boredom visible</description>
</movie>
</collection>

Analyseur DOM

Laissons d'abord analyser les données XML, d'abord, nous devons d'abord inclure rexml/La bibliothèque document, nous pouvons généralement inclure REXML dans l'espace de noms de niveau supérieur :

Exemple en ligne

#!/usr/bin/ruby　-w
　
require 'rexml'/document'
include REXML
　
xmlfile = File.new("movies.xml")
xmldoc = Document.new(xmlfile)
　
# Obtenir l'élément root
root = xmldoc.root
puts "Element racine : "　+　root.attributes["shelf"]
　
# Voici la sortie des titres de films
xmldoc.elements.each("collection",/movie"){　
　　　|e| puts "Titre du film : "　+　e.attributes["title"]　
}
　
# Voici la sortie de tous les types de films
xmldoc.elements.each("collection",/movie/type") {
　　　|e| puts "Type de film : "　+　e.text　
}
　
# Voici la sortie de toutes les descriptions de films
xmldoc.elements.each("collection",/movie/description) {
　　　|e| puts "Description du film : "　+　e.text　
}

Le résultat de la sortie de l'exemple ci-dessus est :

Élément racine : New Arrivals
Titre du film : Enemy Behind
Titre du film : Transformers
Titre du film : Trigun
Titre du film : Ishtar
Type de film : Guerre, Thriller
Type de film : Anime, Science Fiction
Type de film : Anime, Action
Type de film : Comédie
Description du film : Parler d'un US-Guerre japonaise
Description du film : Une science-fiction
Description du film : Vash the Stampede!
Description du film : Boredom visible
SAX-comme Analyse :

Analyseur SAX

Traitement du même fichier de données : movies.xml, il est déconseillé d'utiliser SAX pour un fichier de petite taille, voici un exemple simple :

Exemple en ligne

#!/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(', ')}"
　　fin
　
　　def text(data)
　　　　return if data =~　/^\w*$/　　　　　# seuls des espaces blancs
　　　　abbrev = data[0..40]　+　(data.length >　40 ? "..." : "")
　　　　puts "texte : #{abbrev.inspect}"
　　fin
fin
　
list = MyListener.new
xmlfile = File.new("movies.xml")
Document.parse_stream(xmlfile, list)

Le résultat de la sortie ci-dessus est :

tag_start: "collection", {"shelf"=>"New Arrivals"}
tag_start: "movie", {"title"=>"Enemy Behind"}
tag_start: "type", {}
　　texte : "Guerre, Thriller"
tag_start: "format", {}
tag_start: "year", {}
tag_start: "rating", {}
tag_start: "stars", {}
tag_start: "description", {}
　　texte : "Parler d'une guerre américaine-guerre du Japon"
tag_start: "movie", {"title"=>"Transformers"}
tag_start: "type", {}
　　texte : "Anime, Science Fiction"
tag_start: "format", {}
tag_start: "year", {}
tag_start: "rating", {}
tag_start: "stars", {}
tag_start: "description", {}
　　texte : "Une science-fiction"
tag_start: "movie", {"title"=>"Trigun"}
tag_start: "type", {}
　　texte : "Anime, Action"
tag_start: "format", {}
tag_start: "episodes", {}
tag_start: "rating", {}
tag_start: "stars", {}
tag_start: "description", {}
　　texte : "Vash the Stampede!"
tag_start: "movie", {"title"=>"Ishtar"}
tag_start: "type", {}
tag_start: "format", {}
tag_start: "rating", {}
tag_start: "stars", {}
tag_start: "description", {}
　　texte : "Boredom visible"

XPath et Ruby

Nous pouvons utiliser XPath pour visualiser XML, XPath est un langage utilisé pour trouver des informations dans un document XML (voir :Tutoriel XPath)。

XPath est le langage de chemin XML, un langage utilisé pour déterminer la position d'une partie d'un document XML (sous-ensemble du langage de balisage général standard). XPath est basé sur la structure arborescente de XML et offre la capacité de trouver des nœuds dans une structure de données arborescente.

Ruby prend en charge XPath via la classe XPath de REXML, qui est basée sur une analyse en arbre (modèle objet de document).

Exemple en ligne

#!/usr/bin/ruby　-w
　
require 'rexml'/document'
include REXML
　
xmlfile = File.new("movies.xml")
xmldoc = Document.new(xmlfile)
　
# Informations sur le premier film
film = XPath.first(xmldoc, ""//film)
p film
　
# Imprimer tous les types de films
XPath.each(xmldoc, ""//type) { |e| puts e.text }
　
# Obtenir tous les types de formats de films, retourner un tableau
noms = XPath.match(xmldoc, ""//format).map { |x| x.text }
p noms

Le résultat de la sortie de l'exemple ci-dessus est :

<movie title='Enemy Behind'> ... </>
Guerre, Thriller
Anime, Science Fiction
Anime, Action
Comédie
["DVD", "DVD", "DVD", "VHS"]

XSLT et Ruby

Il y a deux analyseurs XSLT dans Ruby. Voici une description succincte :

Ruby-Sablotron

Ce analyseur a été écrit et maintenu par Masayoshi Takahashi. Il a été principalement écrit pour le système d'exploitation Linux et nécessite les bibliothèques suivantes :

Sablot
Iconv
Expat

Vous pouvez dans Ruby-Sablotron Trouvez ces bibliothèques.

XSLT4R

XSLT4R a été écrit par Michael Neumann. XSLT4R est utilisé pour des interactions en ligne de commande simples et peut être utilisé par des applications tierces pour convertir des documents XML.

XSLT4R nécessite l'opération XMLScan, qui contient XSLT4L'archive R, qui est une100% des modules Ruby. Ces modules peuvent être installés avec la méthode d'installation standard de Ruby (c'est-à-dire Ruby install.rb).

XSLT4Le format de syntaxe de R est le suivant :

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

Si vous souhaitez utiliser XSLT dans une application4R, vous pouvez inclure XSLT et entrer les paramètres nécessaires. Voici un exemple :

Exemple en ligne

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　)

Plus de ressources

Parseur REXML complet, voir la documentation Documentation du parseur REXML。
Vous pouvez partir de Base de connaissances RAA Télécharger XSLT ici4R 。

Web Service Ruby 编程 Socket Ruby