Latest web development tutorials

Ruby XML, XSLT i XPath Tutorial

Czym jest XML?

Odnosi się ono do Extensible Markup Language (XML Extensible Markup Language).

Extensible Markup Language, podzbiorem SGML, sposobu oznakowania dokumentu elektronicznego mieć uporządkowany język znaczników.

Może być stosowany do skuwki danych, definiowanie typów danych, to technologia, która pozwala użytkownikom na zdefiniowanie własnego języka źródłowego język znaczników. Jest to idealne rozwiązanie do transmisji internetowej, zapewniając jednolite podejście do opisywania i wymiany niezależny od aplikacji lub dostawców danych strukturyzowanych.

Aby uzyskać więcej informacji, proszę zapoznać się z naszą samouczek XML

parser XML i struktura API

XML parser SAX i DOM są głównie dwa rodzaje.

  • SAX Parser jest przetwarzanie zdarzeń opartych na skanowanie dokumentu XML musi od początku do końca jeszcze w procesie skanowania, za każdym razem przeżywa strukturę gramatyczną, to zadzwoni na specyficzną strukturę gramatyczną obsługi zdarzeń, wyślij aplikację zdarzenie.
  • DOM Document Object Model analizy, hierarchiczna konstrukcja gramatyczna struktura dokumentu, ustalenia DOM drzewo w pamięci węzła drzewa DOM jako obiekt identyfikacji, dokument parsowania WenCheng, całe drzewo DOM udokumentuje w pamięci.

Ruby do analizowania i tworzenia XML

RUBY parsowanie dokumentów XML mogą korzystać z tej biblioteki REXML bibliotekę.

Biblioteka REXML jest Ruby XML Toolkit jest użycie czystego języka Ruby, wykonaj następujące normy XML1.0.

W wersjach ruby1.8 i późniejszych, biblioteka będzie zawierać RUBY REXML.

Biblioteka Ścieżka REXML jest: rexml / dokument

Wszystkie metody i klasy są pakowane do modułu REXML.

REXML parser ma następujące zalety w stosunku do innych parserów:

  • 100% napisany przez Ruby.
  • Stosuje się do parsera SAX i DOM.
  • Jest lekki, mniej niż 2000 linii kodu.
  • Łatwe do zrozumienia metod i klas.
  • W oparciu SAX2 API i pełne wsparcie XPath.
  • Użyj instalacji Ruby, bez konieczności stosowania oddzielnych instalacji.

Poniżej znajduje się przykład kodu XML, zapisać go jako 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>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

Zacznijmy do analizowania danych XML Po pierwsze wprowadziliśmy bibliotekę rexml / dokument, możemy zazwyczaj w przestrzeni nazw REXML najwyższego poziomu wprowadzonego: 

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

Powyższy przykład wyjście jest: 

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:

parser SAX

Przetwarzanie tego samego pliku danych: movies.xml SAX parsowanie nie jest zalecana jako mały plik, poniżej znajduje się prosty przykład: 

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

Przede wyjściowy: 

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

Możemy użyć XPath aby zobaczyć XML, XPath znalezienie informacji jest dokumentem w języku XML (Patrz: XPath Tutorial ).

XPath jest XML Path Language, jest to metoda stosowana do określenia XML (podzbiór SGML) języka dokumentu częścią lokalizacji. XPath oparte drzewo XML oraz zapewnia możliwość szukania w węzłach struktury danych w drzewie.

Ruby XPath wsparcie XPath według klasy REXML, która opiera się na analizie (Document Object Model) drzewa. 

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

Powyższy przykład wyjście jest: 

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

XSLT i Ruby

Ruby ma dwa parser XSLT, krótki opis znajduje się poniżej:

Ruby-Sablotron

Parser ten został napisany i utrzymywany przez sprawiedliwości Masayoshi Takahash. To jest napisane głównie na systemie operacyjnym Linux, potrzebne są następujące biblioteki:

  • Sablot
  • iconv
  • Expat

Można Ruby-Sablotron znaleźć tych bibliotek.

XSLT4R

XSLT4R napisany przez Michaela Neumanna. XSLT4R dla prostych interakcji z wiersza poleceń, aplikacje innych producentów mogą być używane do przekształcania dokumentów XML.

XSLT4R muszą XMLScan operacji, w tym archiwum XSLT4R, który jest w 100% moduł Ruby. Moduły te mogą wykorzystywać standardową metodę instalacji Ruby (tj install.rb Ruby) instalacji.

Składnia XSLT4R jest następujący: 

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

Jeśli chcesz użyć XSLT4R w aplikacji, można wprowadzić parametry wejściowe i XSLT potrzebne. Przykłady są następujące: 

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 )

więcej informacji