Ruby-XML, XSLT und XPath Tutorial

Next: Ruby - Web - Services - Anwendungen - SOAP4R

Was ist XML?

Er bezieht sich auf Extensible Markup Language XML (eXtensible Markup Language).

Extensible Markup Language, eine Teilmenge des Standard Generalized Markup Language, ein Verfahren zur Markierung eines elektronischen Dokuments einen strukturierten Auszeichnungssprache zu haben.

Es können Daten verwendet werden, zu markieren, Datentypen zu definieren, ist eine Technologie, die Benutzer ihre eigenen Auszeichnungssprache Quellsprache zu definieren. Es ist ideal für Web-Übertragung, einen einheitlichen Ansatz für die Beschreibung und den Austausch unabhängig von Anwendungen oder Anbieter von strukturierten Daten.

Weitere Informationen finden Sie in unserer XML - Tutorial

XML-Parser und API-Struktur

XML-Parser SAX und DOM sind hauptsächlich zwei Arten.

SAX-Parser ist ereignisbasierte Verarbeitung, das XML-Dokument-Scanning muss von Anfang an wieder zu beenden, in dem Scan-Vorgang, jedes Mal eine grammatische Struktur zu erleben, wird es die Event-Handler-spezifische grammatische Struktur aufrufen, senden Sie die Anwendung ein Ereignis.
DOM Document Object Model Analyse, hierarchische Konstrukt grammatische Struktur des Dokuments, DOM-Baum im Speicher DOM-Baum-Knoten als ein Objekt etablieren zu identifizieren, Dokument Parsen Wencheng, die gesamte DOM-Baum im Speicher dokumentieren.

Rubin zu analysieren und XML erstellen

RUBY Parsen von XML-Dokumenten können diese Bibliothek REXML Bibliothek verwenden.

REXML Bibliothek ist ein XML-Toolkit Rubin ist reine Ruby-Sprache zu verwenden, XML1.0 Normen folgen.

In ruby1.8 und späteren Versionen, enthält die Bibliothek RUBY REXML.

Pfad REXML Bibliothek ist: reXML / document

Alle Methoden und Klassen werden in ein REXML Modul verpackt.

REXML Parser hat folgende Vorteile gegenüber anderen Parsern:

100% von Ruby geschrieben.
Anwendbar auf SAX und DOM-Parser.
Es ist leicht, weniger als 2000 Zeilen Code.
Einfache Methoden und Klassen zu verstehen.
Basierend SAX2 API und vollständige Unterstützung von XPath.
Verwenden Sie Ruby-Installation, ohne separate Installationen erfordern.

Im Folgenden ist ein Beispiel für XML-Code, es als movies.xml sparen:

<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>

DOM-Parser

Lassen Sie uns beginnen XML-Daten zu analysieren Zuerst haben wir reXML / Dokumentbibliothek eingeführt, können wir in der Regel in der Top-Level-Namespace REXML sein eingeführt:

#!/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 
}

Das obige Beispiel Ausgabe lautet:

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:

SAX-Parser

Die Verarbeitung der gleichen Datendatei: movies.xml wird SAX-Parsing nicht als kleine Datei empfohlen, Folgendes ist ein einfaches Beispiel:

#!/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)

Oben Ausgabe ist:

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 und Ruby

Wir können XPath verwenden XML anzuzeigen, XPath zu finden Informationen , die ein Dokument im XML - Sprache ist (Siehe: XPath Tutorial ).

XPath ist der XML Path Language, ist es ein Verfahren verwendet wird, ist die XML (eine Teilmenge der Standard Generalized Markup Language) Sprache ein Teil der Position zu bestimmen. XPath-basierten XML-Struktur und bietet die Möglichkeit, in den Baum in der Datenstruktur Knoten zu suchen.

Ruby XPath-Unterstützung XPath von REXML-Klasse, die auf der Analyse (Document Object Model) Baum basiert.

#!/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 names

Das obige Beispiel Ausgabe lautet:

<movie title='Enemy Behind'> ... </>
War, Thriller
Anime, Science Fiction
Anime, Action
Comedy
["DVD", "DVD", "DVD", "VHS"]

XSLT und Ruby

Ruby hat zwei XSLT-Parser, eine kurze Beschreibung unten gegeben:

Rubin-Sablotron

Dieser Parser wird von der Gerechtigkeit Masayoshi Takahash geschrieben und gepflegt. Dies ist vor allem für das Linux-Betriebssystem geschrieben, müssen Sie die folgenden Bibliotheken:

sablot
iconv
Expat

Sie können Ruby Sablotron diese Bibliotheken finden.

XSLT4R

XSLT4R von Michael Neumann geschrieben. XSLT4R für einfache Kommandozeilen-Interaktion, können Anwendungen von Drittanbietern verwendet werden, XML-Dokumente zu transformieren.

XSLT4R müssen XMLScan Betrieb, einschließlich XSLT4R Archiv, das eine 100% Ruby-Modul ist. Diese Module können verwenden die Standard-Ruby-Installationsmethode (zB Ruby-install.rb) Installation.

XSLT4R Syntax lautet wie folgt:

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

Wenn Sie XSLT4R in Ihrer Anwendung verwenden möchten, können Sie XSLT und Eingabeparameter einführen Sie benötigen. Beispiele sind wie folgt:

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 )

Mehr Informationen

Komplette REXML Parser finden Sie in der Dokumentation REXML Dokumentenparser .
Sie können beginnen mit RAA Wissen in Download XSLT4R.

Zurück: Ruby - Socket - Programmierung