English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية

Ruby XML, XSLT and XPath Tutorial

Cos'è XML?

XML sta per linguaggio di markup estensibile (eXtensible Markup Language).

Linguaggio di markup estensibile, un sottoinsieme del linguaggio di markup generale, un linguaggio di markup utilizzato per etichettare file elettronici in modo che abbiano una struttura.

Può essere utilizzato per etichettare dati, definire tipi di dati, è una fonte linguistica che permette agli utenti di definire il proprio linguaggio di markup. È particolarmente adatto per il trasporto del web, fornendo un metodo uniforme per descrivere e scambiare dati strutturati indipendenti dall'applicazione o dal fornitore.

Per ulteriori informazioni, consulta la nostra Corso XML

Struttura e API del parser XML

I principali parser XML sono DOM e SAX.

  • Il parser SAX è basato sul trattamento degli eventi, è necessario scansionare l'intero documento XML da capo a fondo, durante la scansione, ogni volta che si incontra una struttura grammaticale, viene chiamato il programma di gestione eventi della struttura grammaticale specifica, inviando un evento all'applicazione.

  • DOM è il parser modello oggetto documento, costruisce la struttura grammaticale gerarchica del documento, costruisce un albero DOM in memoria, i nodi dell'albero DOM sono identificati come oggetti, dopo la解析del documento, l'intero albero DOM del documento viene messo in memoria.

解析e creazione XML in Ruby

La解析e la creazione di documenti XML in Ruby possono utilizzare questa libreria REXML.

La libreria REXML è un pacchetto di strumenti XML per Ruby, scritto interamente in Ruby, che segue la specifica XML 1.0.

A partire dalla versione Ruby 1.8 e successive, la libreria standard Ruby conterrà REXML.

Il percorso della libreria REXML è: rexml/document

Tutti i metodi e le classi sono encapsulati in un modulo REXML.

I vantaggi del parser REXML rispetto agli altri parser sono i seguenti:

  • 100% scritto in Ruby.

  • Apportabile per parser SAX e DOM.

  • È leggero, con meno di 2000 righe di codice.

  • Metodi e classi facili da comprendere.

  • Basato API SAX2 e supporto completo XPath.

  • Installare Ruby senza bisogno di installare separatamente。

Ecco un esempio di codice XML,salvare come movies.xml:

<collection shelf="Nuovi Arrivi">
<movie title="Enemy Behind">
   <type>Guerra, Thriller</type>
   <format>DVD</format>
   <year>2003</year>
   <rating>PG</rating>
   <stars>10</stars>
   <description>Parlare di una guerra US-Japan</description>
</movie>
<movie title="Transformers">
   <type>Animazione, Fantascienza</type>
   <format>DVD</format>
   <year>1989</year>
   <rating>R</rating>
   <stars>8</stars>
   <description>Un romanzo scientifico</description>
</movie>
   <movie title="Trigun">
   <type>Animazione, Azione</type>
   <format>DVD</format>
   <episodes>4</episodes>
   <rating>PG</rating>
   <stars>10</stars>
   <description>Vash the Stampede!</description>
</movie>
<movie title="Ishtar">
   <type>Commedia</type>
   <format>VHS</format>
   <rating>PG</rating>
   <stars>2</stars>
   <description>Tristezza visibile</description>
</movie>
</collection>

Analizzatore DOM

Prima di  tutto,analizziamo i dati XML,prima di tutto importiamo la libreria rexml/document,solitamente possiamo importare REXML nel namespace principale:

Esempio online

#!/usr/bin/ruby -w
 
require 'rexml/document'
include REXML
 
xmlfile = File.new("movies.xml")
xmldoc = Document.new(xmlfile)
 
# Ottenere l'elemento root
root = xmldoc.root
puts "Elemento radice : " + root.attributes["shelf"]
 
# Ecco l'output del titolo del film
xmldoc.elements.each("collection/movie"){ 
   |e| puts "Titolo del Film : " + e.attributes["title"] 
}
 
# Ecco i tipi di tutti i film
xmldoc.elements.each("collection/movie/type") {
   |e| puts "Movie Type: " + e.text 
}
 
# Ecco le descrizioni di tutti i film
xmldoc.elements.each("collection/movie/description") {
   |e| puts "Movie Description: " + e.text 
}

Il risultato dell'esempio sopra è:

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 scientific fiction
Movie Description: Vash the Stampede!
Movie Description: Visibile boredom
SAX-like Parsing:

SAX 解析器

处理相同的数据文件:movies.xml,不建议SAX的解析为一个小文件,以下是个简单的示例:

Esempio online

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

Il risultato di output sopra è:

tag_start: "collection", {"shelf": "Nuovi Arrivi"}
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: "Parlare di una guerra tra Stati Uniti e Giappone"
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 scienza di fantasia"
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: "Visibile noia"

XPath e Ruby

Possiamo utilizzare XPath per visualizzare XML, XPath è un linguaggio utilizzato per trovare informazioni nei documenti XML (vedi:)Tutorial XPath)。

XPath è il linguaggio di percorso XML, un linguaggio utilizzato per determinare la posizione di una parte di un documento XML (sottoinsieme del linguaggio di markup generale standard). XPath si basa sulla struttura ad albero dell'XML, fornendo la capacità di trovare nodi in una struttura ad albero di dati.

Ruby supporta XPath tramite la classe REXML, che è basata sull'analisi a albero (modello oggetto documento).

Esempio online

#!/usr/bin/ruby -w
 
require 'rexml/document'
include REXML
 
xmlfile = File.new("movies.xml")
xmldoc = Document.new(xmlfile)
 
# Informazioni del primo film
movie = XPath.first(xmldoc, "//movie")
p movie
 
# Stampa il primo film
# Stampa tutti i tipi di film
 
# Ottieni tutti i tipi di formato dei film, restituisci un array
names = XPath.match(xmldoc, "//format").map {|x| x.text}
p names

Il risultato dell'esempio sopra è:

<movie title='Enemy Behind'>...</movie>
Guerra, Thriller
Anime, Fantascienza
Anime, Azione
Commedia
["DVD", "DVD", "DVD", "VHS"]

XSLT e Ruby

Ci sono due parser XSLT in Ruby, ecco una breve descrizione:

Ruby-Sablotron

Questo parser è stato scritto e mantenuto da Masayoshi Takahashi. È stato principalmente scritto per il sistema operativo Linux e richiede le seguenti librerie:

  • Sablot

  • Iconv

  • Expat

Puoi trovare Ruby-Sablotron Trova queste librerie.

XSLT4R

XSLT4R è stato scritto da Michael Neumann. XSLT4R è utilizzato per interazioni semplici da riga di comando e può essere utilizzato da applicazioni di terze parti per convertire documenti XML.

XSLT4R richiede l'operazione XMLScan, include l'archivio XSLT4R, che è un modulo al 100% in Ruby. Questi moduli possono essere installati utilizzando il metodo standard di installazione di Ruby (ovvero Ruby install.rb).

La sintassi di XSLT4R è la seguente:

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

Se desideri utilizzare XSLT4R nel tuo applicativo, puoi includere XSLT e fornire i parametri necessari. Ecco un esempio:

Esempio online

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 )

More Information