Ruby XML-, XSLT- und XPath-Tutorial

Was ist XML?

XML steht für eXtensible Markup Language.

Extensible Markup Language, eine Teilmenge der Standard Generalized Markup Language, ist eine Auszeichnungssprache, die verwendet wird, um elektronische Dokumente auszuzeichnen, um ihnen Struktur zu geben.

Sie kann verwendet werden, um Daten auszuzeichnen und Datentypen zu definieren. Sie ist eine Quellsprache, die es Benutzern ermöglicht, ihre eigene Auszeichnungssprache zu definieren. Sie eignet sich sehr gut für die Übertragung über das World Wide Web und bietet eine einheitliche Methode, um strukturierte Daten zu beschreiben und auszutauschen, die unabhängig von Anwendungen oder Anbietern sind.

Weitere Inhalte finden Sie in unseremXML-Tutorial

XML-Parser-Struktur und API

Es gibt hauptsächlich zwei Arten von XML-Parsern: DOM und SAX.

  • Der SAX-Parser basiert auf Ereignisverarbeitung. Er scannt das XML-Dokument von Anfang bis Ende. Während des Scanvorgangs wird jedes Mal, wenn eine syntaktische Struktur angetroffen wird, der Ereignishandler für diese spezifische syntaktische Struktur aufgerufen, um ein Ereignis an die Anwendung zu senden.
  • DOM ist das Parsen des Document Object Model. Es erstellt eine hierarchische syntaktische Struktur des Dokuments und erzeugt einen DOM-Baum im Speicher. Die Knoten des DOM-Baums werden in Form von Objekten identifiziert. Nach dem Parsen des Dokuments wird der gesamte DOM-Baum des Dokuments im Speicher abgelegt.

XML in Ruby parsen und erstellen

In Ruby kann die REXML-Bibliothek zum Parsen von XML-Dokumenten verwendet werden.

Die REXML-Bibliothek ist ein XML-Toolkit für Ruby. Sie ist in reinem Ruby geschrieben und entspricht der XML 1.0-Spezifikation.

In Ruby 1.8 und später ist REXML in der Ruby-Standardbibliothek enthalten.

Der Pfad der REXML-Bibliothek ist: rexml/document

Alle Methoden und Klassen sind in einem REXML-Modul gekapselt.

Der REXML-Parser hat die folgenden Vorteile gegenüber anderen Parsern:

  • 100% in Ruby geschrieben.
  • Anwendbar auf SAX- und DOM-Parser.
  • Es ist leichtgewichtig, mit weniger als 2000 Codezeilen.
  • Leicht verständliche Methoden und Klassen.
  • Basiert auf der SAX2-API und vollständiger XPath-Unterstützung.
  • Mit Ruby installiert, keine separate Installation erforderlich.

Das Folgende ist der XML-Code für das Beispiel, gespeichert als movies.xml:

<collection shelf="Neuheiten"> <movie title="Enemy Behind"> <type>Krieg, Thriller</type> <format>DVD</format> <year>2003</year> <rating>PG</rating> <stars>10</stars> <description>Sprechen wir über einen US-Japan-Krieg</description> </movie> <movie title="Transformers"> <type>Anime, Science-Fiction</type> <format>DVD</format> <year>1989</year> <rating>R</rating> <stars>8</stars> <description>Eine wissenschaftliche Fiktion</description> </movie> <movie title="Trigun"> <type>Anime, Action</type> <format>DVD</Format> <Episoden>4</Episoden> <rating>PG</rating> <stars>10</Sterne> <Beschreibung>Vash the Stampede!</Beschreibung> </Film> <Film Titel="Ishtar"> <Typ>Komödie</Typ> <Format>VHS</Format> <Bewertung>PG</Bewertung> <Sterne>2</Sterne> <Beschreibung>Ansehbare Langeweile</Beschreibung> </Film> </Collection>

DOM-Parser

Lassen Sie uns zuerst die XML-Daten parsen. Zuerst importieren wir die Bibliothek rexml/document. Normalerweise können wir REXML in den Top-Level-Namensraum importieren:

Beispiel

#!/usr/bin/ruby -w require 'rexml/document' include REXML xmlfile = File.new("movies.xml") xmldoc = Document.new(xmlfile) #Das Root-Element abrufen root = xmldoc.root puts "Wurzelelement : " + root.attributes["shelf"] #Das Folgende gibt Filmtitel aus xmldoc.elements.each("collection/movie"){ |e| puts "Filmtitel : " + e.attributes["title"] } #Das Folgende gibt alle Filmtypen aus xmldoc.elements.each("collection/movie/type") { |e| puts "Filmtyp : " + e.text } #Das Folgende gibt alle Filmbeschreibungen aus xmldoc.elements.each("collection/movie/description") { |e| puts "Filmbeschreibung : " + e.text }

Das Ausgabeergebnis des obigen Beispiels ist:

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

Um dieselbe Datendatei zu verarbeiten: movies.xml, SAX-Parsing wird für eine kleine Datei nicht empfohlen. Das Folgende ist ein einfaches Beispiel:

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*$/ # nur Leerraum 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, Liste)

Das Ausgabeergebnis des Obigen 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, um XML anzuzeigen. XPath ist eine Sprache zum Auffinden von Informationen in XML-Dokumenten (siehe:XPath-Tutorial).

XPath ist die XML Path Language. Sie ist eine Sprache, mit der die Position eines Teils in einem XML-Dokument (einer Teilmenge der Standard Generalized Markup Language) bestimmt wird. XPath basiert auf der Baumstruktur von XML und bietet die Möglichkeit, Knoten im Datenstrukturbaum zu finden.

Ruby unterstützt XPath über die XPath-Klasse von REXML, die auf der Baumanalyse (Document Object Model) basiert.

Beispiel

#!/usr/bin/ruby -w require 'rexml/document' include REXML xmlfile = File.new("movies.xml") xmldoc = Document.new(xmlfile) #Die Informationen des ersten Films movie = XPath.first(xmldoc, "//movie") p movie #Alle Filmtypen ausgeben XPath.each(xmldoc, "//type") { |e| puts e.text } #Alle Filmformattypen abrufen und ein Array zurückgeben names = XPath.match(xmldoc, "//format").map {|x| x.text } p names

Das Ausgabeergebnis des obigen Beispiels ist:

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

XSLT und Ruby

In Ruby gibt es zwei XSLT-Parser. Eine kurze Beschreibung folgt unten:

Ruby-Sablotron

Dieser Parser wurde von Masayoshi Takahash geschrieben und gepflegt. Er wurde hauptsächlich für das Linux-Betriebssystem geschrieben und erfordert die folgenden Bibliotheken:

  • Sablot
  • Iconv
  • Expat

Sie können diese Bibliotheken beiRuby-Sablotronfinden.

XSLT4R

XSLT4R wurde von Michael Neumann geschrieben. XSLT4R wird für einfache Kommandozeilen-Interaktion verwendet und kann von Anwendungen von Drittanbietern zum Transformieren von XML-Dokumenten genutzt werden.

XSLT4R benötigt XMLScan zum Betrieb; XMLScan ist im XSLT4R-Archiv enthalten. Es ist ein 100%iges Ruby-Modul. Diese Module können mit der standardmäßigen Ruby-Installationsmethode installiert werden (d. h. ruby install.rb).

Das Syntaxformat von XSLT4R ist wie folgt:

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

Wenn Sie XSLT4R in Ihrer Anwendung verwenden möchten, können Sie XSLT einbinden und die benötigten Parameter eingeben. Das Beispiel sieht wie folgt aus:

Beispiel

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 ) # Ausgabe nach StdOut sheet.apply( xml_doc ) # Ausgabe nach 'str' str = "" sheet.output = [ str ] sheet.apply( xml_doc )

Weitere Ressourcen

Andere Erweiterungen