XML/XPath: Difference between revisions

 

Perform the following three XPath queries on the XML Document below:

 

XML Document:

</section>

</inventory>

 

 

 

 

 

 

=={{header|AppleScript}}==

''AppleScript has no-built in support for XPath, but it could be used via a 'do shell script' command. Here's a solution using Apple System Events.

 

<section name=\"health\">

<item upc=\"123456789\" stock=\"12\">

return my getElementValuesByName(xmlData's contents, "price") -- Solution to part 3 of problem.

<name>Invisibility Cream</name>

<price>14.50</price>

{"Invisibility Cream", "Levitation Salve", "Blork and Freen Instameal", "Grob winglets"}

 

 

=={{header|Bracmat}}==

( nestML$(get$("doc.xml",X,ML))

: ?

?

| out$!anArray {Not truly an array, but a list.}

 

=={{header|C sharp}}==

// Either read the xml from a string ...

// Convert the generic list to an array and output the count of items.

 

=={{header|C++}}==

#include <iostream>

 

 

=={{header|Caché ObjectScript}}==

 

{

 

}

 

{{out|Examples}}

<pre>

=={{header|CoffeeScript}}==

<div class='mw-collapsible mw-collapsed'>

doc = new DOMParser().parseFromString '

<inventory title="OmniCorp Store #45x10^3">

</inventory>

', 'text/xml'

</div>

<nowiki>#</nowiki> "doc" is the XML as a Document object. Click expand to see parsing code ⇒

 

# Retrieve the first "item" element

doc.evaluate('//item', doc, {}, 7, {}).snapshotItem 0

names = for i in [0...names.snapshotLength] by 1

names.snapshotItem i

 

=={{header|ColdFusion}}==

<inventory

...

<cfset names = xmlSearch(xml, "//name")>

<!--- visualize the results --->

 

=={{header|Common Lisp}}==

{{libheader|cxml-stp}}

 

(asdf:oos 'asdf:load-op system))

 

 

(node-array

 

=={{header|D}}==

It is important to note that the KXML library currently only supports XPath minimally.

{{libheader|KXML}}

char[]xmlinput =

"<inventory title=\"OmniCorp Store #45x10^3\">

}

auto namearray = root.parseXPath("inventory/section/item/name");

 

=={{header|Delphi}}==

 

{$APPTYPE CONSOLE}

for s in lItemNames do

Writeln('Item name = ' + s);

 

Output:

<item upc="123456789" stock="12">

<name>Invisibility Cream</name>

Item name = Levitation Salve

Item name = Blork and Freen Instameal

 

=={{header|E}}==

{{libheader|E-XML}} (currently a very early work in progress/draft library; design comments welcome)

 

> def xpath__quasiParser := xml__quasiParser.xPathQuasiParser()

> null

# xml`<name>Blork and Freen Instameal</name>`,

# xml`<name>Grob winglets</name>`]

 

=={{header|Erlang}}==

{{libheader|xmerl}}

 

-module(xml_xpath).

-include_lib("xmerl/include/xmerl.hrl").

[ Content#xmlText.value

|| #xmlElement{content = [Content|_]} <- xmerl_xpath:string("//name", Document)].

 

Output:<pre>First item:

"Blork and Freen Instameal","Grob winglets"]

</pre>

 

=={{header|F_Sharp|F#}}==

open System.IO

open System.Xml.XPath

 

// array of all name elements

 

=={{header|Factor}}==

{{libheader|xml.traversal}}

 

 

! Get first item element

</section>

</inventory>""" string>xml "name" deep-tags-named

 

=={{header|Gastona}}==

The example uses the command XMELON which parses a XML file of any schema and stores its

contents into db tables. This parser is described in the article [http://web3.codeproject.com/Articles/680642/XMeLon-Schema XMeLon-Schema]

 

<frames> oSal, XML Path sample, 300, 400

,, VAR+, tabnames, @<value>

DUMP, data,, tabnames

 

{{out|Output}}

//Grob winglets

</pre>

=={{header|Go}}==

Using the standard <code>encoding/xml</code> package:

 

import (

}

fmt.Printf("names: %q\n", names)

{{out}}

<pre>

 

{{libheader|xmlpath}}

 

import (

fmt.Println("no names")

}

{{out}}

<pre>

 

=={{header|Groovy}}==

def firstItem = inventory.section.item[0] //1. first item

inventory.section.item.price.each { println it } //2. print each price

 

=={{header|Haskell}}==

import Control.Arrow

import Control.Monad

putStrLn "\n== Names ==\n"

Using the Haskell XML Toolkit (HXT):

import Text.XML.HXT.Arrow

{- For HXT version >= 9.0, use instead:

[(item, names)] <- runX (readDocument [] "xmlpath.xml" >>> process)

print item

 

=={{header|HicEst}}==

READ(ClipBoard) xml

 

 

EDIT(Text=xml, SPR='<>', R='<name>', W=1, WordEnd=$CR, APpendTo=output, DO=999)

<name>Invisibility Cream</name>

<price>14.50</price>

Blork and Freen Instameal

Grob winglets

 

=={{header|Java}}==

import javax.xml.parsers.DocumentBuilderFactory;

import javax.xml.xpath.XPath;

}

}

=={{header|JavaScript}}==

{{works with|Firefox|2.0}}

var xhr = new XMLHttpRequest();

xhr.open('GET', 'file.xml', false);

namesArray.push( name );

}

 

Although some browsers support XPath, working with XML is much easier with E4X.

 

var xhr = new XMLHttpRequest();

xhr.open('GET', 'file.xml', false);

names.push( name );

}

 

=={{header|Kotlin}}==

 

import javax.xml.parsers.DocumentBuilderFactory

println("\nThe names of each item are as follows :")

println(" ${names.joinToString("\n ")}")

 

{{out}}

Grob winglets

</pre>

 

=={{header|Lasso}}==

Lasso has built in support for both XML handling and Xpaths

define xml_attrmap(in::xml_namedNodeMap_attr) => {

local(out = map)

'<br /><br />'

'<strong>Array with all names:</strong><br />'

Output:

<pre>First item:

=={{header|LiveCode}}==

Copy the xml in this task into a text field called "FieldXML"

 

// task 1

filter namenodes without empty

split namenodes using cr

 

=={{header|Lua}}==

Requires LuaExpat

data = [[<inventory title="OmniCorp Store #45x10^3">

<section name="health">

 

print('Name: ', table.concat(names, ', '))

Output:<pre>

<item upc="123456789" stock="12">

</pre>

 

Cases[example, XMLElement["item", _ , _] , Infinity] // First

Cases[example, XMLElement["price", _, List[n_]] -> n, Infinity] // Column

{XMLElement[name,{},{Invisibility Cream}],XMLElement[price,{},{14.50}],XMLElement[description,{},{Makes you invisible}]}]

14.50

23.99

4.95

3.56

Invisibility Cream

Levitation Salve

Blork and Freen Instameal

 

=={{header|NetRexx}}==

{{trans|Java}}

 

import javax.xml.parsers.

import javax.xml.xpath.

import org.w3c.dom.

import org.xml.sax.

 

 

return

'''Output:'''

<pre>

 

=={{header|Nim}}==

 

 

 

 

 

=={{header|Objeck}}==

XPath is used to fetch element tags.

use XML;

 

}

}

 

=={{header|Oz}}==

We implement a small subset of XPath for this task:

[XMLParser] = {Module.link ['x-oz://system/xml/Parser.ozf']}

 

#"</inventory>"

in

 

=={{header|Perl}}==

{{libheader|XML::XPath}}

 

my $x = XML::XPath->new('<inventory ... </inventory>');

[$x->findnodes('//item[1]')->get_nodelist]->[0];

print $x->findnodes_as_string('//price');

 

=={{header|PHP}}==

//PHP5 only example due to changes in XML extensions between version 4 and 5 (Tested on PHP5.2.0)

$doc = DOMDocument::loadXML('<inventory title="OmniCorp Store #45x10^3">...</inventory>');

{

$result[] = $node;

 

=={{header|PicoLisp}}==

 

(let Sections (body (in "file.xml" (xml)))

(for S Sections

(for L (body S)

Output:

<pre>(item

=={{header|PowerShell}}==

Cast the <code>$document</code> string as <code>[xml]</code> and you have access to .NET methods affecting XML.

$document = [xml]@'

<inventory title="OmniCorp Store #45x10^3">

$query = "/inventory/section/item"

$items = $document.SelectNodes($query)

The first item:

$items[0]

{{Out}}

<pre>

</pre>

Get some useful information:

$namesAndPrices = $items | Select-Object -Property name, price

$namesAndPrices

{{Out}}

<pre>

</pre>

Here are the prices:

$items.price

{{Out}}

<pre>

</pre>

Here are the names:

$items.name

{{Out}}

<pre>

 

=={{header|Python}}==

 

from xml.dom import minidom

 

# 3rd Task: Get an array of all the "name" elements

In Python 2.5+ you can use ElementTree's limited XPath support

import xml.etree.ElementTree as ET

 

 

# list of names

Or, you can install the <tt>lxml</tt> package and get full XPath support

from lxml import etree

 

print "{0:0.2f}".format(float(p.text)) # could raise exception on missing text or invalid float() conversion

 

 

=={{header|R}}==

{{libheader|XML (R)}}

library("XML")

doc <- xmlInternalTreeParse("test3.xml")

 

=={{header|Racket}}==

#lang at-exp racket

 

(se-path*/list '(item name) data)

;; => '("Invisibility Cream" "Levitation Salve" "Blork and Freen Instameal" "Grob winglets")

 

=={{header|Rascal}}==

import Prelude;

 

L += n;

return L;

Example output:

<?xml version="1.0" encoding="UTF-8"?>

<item stock="12" upc="123456789">

 

rascal>get_names(|file:///Users/.../Desktop/xmlpath.xml|)

 

=={{header|REXX}}==

===hard coded parsing===

iFID='XPATH.XML' /*name of the input XML file (doc). */

$= /*string will contain the file's text. */

say names.k /*display a name from the NAMES list.*/

end /*k*/

'''output'''

<pre>

 

===generic parsing===

iFID='XPATH.XML' /*name of the input XML file (doc). */

$= /*string will contain the file's text. */

end /*#*/

#=#-1 /*adjust # of thing found.*/

'''output''' &nbsp; is the same as the 1^st version.

 

=={{header|Ruby}}==

{{libheader|REXML}}

require "rexml/document"

include REXML

XPath.each( doc, "//price") { |element| puts element.text }

# Gets an array of all of the "name" elements in the document.

 

=={{header|Scala}}==

 

better show the results.

 

| <section name="health">

| <item upc="123456789" stock="12">

| </section>

| </inventory>

 

 

14.50

23.99

3.56

 

 

 

=={{header|Sidef}}==

{{trans|Perl}}

 

var x = %s'XML::XPath'.new(ARGF.slurp);

[x.findnodes('//item[1]')][0];

say [x.findnodes('//price')].map{x.getNodeText(_)};

 

{{out}}

=={{header|Tcl}}==

{{libheader|tDOM}}

package require tdom

set doc [dom parse $xml]

foreach node [$root selectNodes //price] {

puts [$node text]

=={{header|TUSCRIPT}}==

$$ MODE TUSCRIPT,{}

MODE DATA

names=SPLIT(names)

TRACE *firstitem,names

Output:

<pre style='height:30ex;overflow:scroll'>

 

=={{header|VBScript}}==

Set objXMLDoc = CreateObject("msxml2.domdocument")

 

WScript.StdOut.Write list_name

WScript.StdOut.WriteBlankLines(2)

{{out}}

<pre>

=={{header|Visual Basic .NET}}==

 

Console.WriteLine(first_item)

Next

 

 

=={{header|XProc}}==

name="one-two-three"

version="1.0">

</p:input>

</p:insert>

=={{header|XQuery}}==

1. Retrieve the first "item" element

Notice the braces around //item. This evaluates first all item elements and then retrieving the first one.

<prices>{$price}</prices>

<names>{$names}</names>

 

Performing this XQuery on the given input document results in

<result>

<firstItem>

<name>Grob winglets</name>

</names>

 

=={{header|XSLT}}==

<xsl:output method="text" />

<xsl:template match="/">

<xsl:copy-of select="//name" />

</xsl:template>

 

{{omit from|Batch File|No way of XML parsing or processing.}}