XML/Input: Difference between revisions

Given the following XML fragment, extract the list of ''student names'' using whatever means desired. If the only viable method is to use XPath, refer the reader to the task [[XML and XPath]].

 

<Student Name="April" Gender="F" DateOfBirth="1989-01-02" />

<Student Name="Bob" Gender="M" DateOfBirth="1990-03-04" />

</Student>

<Student DateOfBirth="1993-09-10" Gender="F" Name="&#x00C9;mily" />

 

Expected Output

Dave

Émily

 

=={{header|ActionScript}}==

{

import flash.display.Sprite;

}

}

=={{header|Ada}}==

{{works with|GNAT}}

 

extract_students.adb:

with Input_Sources.Strings;

with Unicode.CES.Utf8;

My_Reader.Parse (Reader, Input);

Input_Sources.Strings.Close (Input);

 

my_reader.ads:

with Sax.Readers;

with Unicode.CES;

Qname : Unicode.CES.Byte_Sequence := "";

Atts : Sax.Attributes.Attributes'Class);

 

my_reader.adb:

package body My_Reader is

procedure Start_Element

end if;

end Start_Element;

 

Output:

 

===Alternative using a DOM document===

with Sax.Readers;

with Input_Sources.Strings;

end loop;

DOM.Readers.Free (Reader);

 

output is the same.

 

=={{header|Aikido}}==

Put the XML in the file called t.xml

import xml

 

}

 

The output is (Aikido doesn't support unicode rendering):

April

Dave

&#x00C9;mily

 

=={{header|AutoHotkey}}==

simply using regular expressions

(

<Students>

names .= name1 . "`n"

 

=={{header|AWK}}==

The following code extracts the value of the property "Name" from every Student tag. It does not handle the <tt>&amp;#CODE;</tt>; this can be left to others: a way to cope with it fastly, is to output a very simple HTML structure, so that the interpretation is left to an HTML reader/browser.

 

{

if ( match(buffer, /<Student[ \t]+[^>]*Name[ \t]*=[ \t]*"([^"]*)"/, mt) != 0 ) {

print k

}

Using [http://awk.info/?getxml getXML.awk] written by Jan Weber, one could do this:

 

{{works with|gawk}} or {{works with|nawk}}

$1 == "TAG" {tag = $2}

tag == "Student" && /Name=/ {print substr($0, index($0, "=") + 1)}

Using [http://home.vrweb.de/~juergen.kahrs/gawk/XML/xmlgawk.html#Steve-Coile_0027s-xmlparse_002eawk-script xmlparser.awk] by Steve Coile, one can do this:

 

{{works with|gawk}}

$1 == "begin" {tag = $2}

$1 == "attrib" {attrib = $2}

$1 == "value" && tag == "STUDENT" && attrib == "name" {print $2}

 

Both of these produce this output

Dave

Émily

=={{header|C}}==

 

{{uses from|Library|libxml|component1=xmlDoc|component2=xmlNode|component3=xmlReadMemory|component4=xmlDocGetRootElement|component5=xmlFreeDoc|component6=xmlCleanupParser|component7=xmlNode|component8=XML_ELEMENT_NODE|component9=xmlAttr|component10=xmlHasProp}}

{{uses from|Library|C Runtime|component1=printf}}

#include <stdlib.h>

#include <string.h>

xmlCleanupParser();

return 0;

 

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

{{uses from|Library|Qt|component1=QDomDocument|component2=QObject|component3=QDomElement}}

 

Using the Qt library's XML parser.

*/

}

return 0;

 

{

 

}

 

=={{header|Clojure}}==

{{uses from|Library|clojure.xml|component1=parse}}

This version uses the standard Clojure function ''xml-seq'

(import '(java.io ByteArrayInputStream))

(use 'clojure.xml) ; defines 'parse

 

(def students (parse (-> xml-text .getBytes ByteArrayInputStream.)))

 

The parse produces a data structure where each element is represented as a map with '':tag'', '':attrs'', and '':content'' keys.

''xml-seq'' produces a sequence of such nodes by walking the resulting tree.

 

(doseq [{:keys [tag attrs]} (xml-seq students)]

(if (= :Student tag)

(println (:Name attrs))))

 

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

{{libheader|Closure XML}}

 

"<Students>

<Student Name=\"April\" Gender=\"F\" DateOfBirth=\"1989-01-02\" />

(dom:do-node-list (child (dom:child-nodes students) (nreverse student-names))

(when (dom:element-p child)

 

 

=={{header|D}}==

{{libheader|KXML}}

char[]xmlinput =

"<Students>

break;

}

 

=={{header|Factor}}==

 

: print-student-names ( string -- )

string>xml "Student" tags-named [ "Name" attr print ] each ;

 

<Student Name="April" Gender="F" DateOfBirth="1989-01-02" />

<Student Name="Bob" Gender="M" DateOfBirth="1990-03-04" />

</Student>

<Student DateOfBirth="1993-09-10" Gender="F" Name="&#x00C9;mily" />

 

=={{header|Forth}}==

{{libheader|Forth Foundation Library}}

 

include ffl/str.fs

include ffl/xis.fs

;

 

 

 

 

 

 

 

 

<Students>

<Student Name="April" Gender="F" DateOfBirth="1989-01-02" />

`

 

 

 

<pre>

April

 

=={{header|Groovy}}==

<Student Name="April" Gender="F" DateOfBirth="1989-01-02" />

<Student Name="Bob" Gender="M" DateOfBirth="1990-03-04" />

 

def students = new XmlParser().parseText(input)

 

=={{header|Haskell}}==

import Text.XML.Light

 

xmlRead elm name = mapM_ putStrLn

. concatMap (map (fromJust.findAttr (unqual name)).filterElementsName (== unqual elm))

Show names:

April

Bob

Chad

Dave

 

=={{header|HicEst}}==

 

READ(ClipBoard) in

<pre>out is returned as:

April Bob Chad Dave &#x00C9;mily

J's system includes several XML processing libraries. This task is probably best addressed using XPath (this is the type of problem XPath was designed to solve), but the task description implicitly discourages that method. So we can use the SAX library instead:

 

saxclass 'Students'

cocurrent'base'

April

Bob

Émily

 

<Students>

<Student Name="April" Gender="F" DateOfBirth="1989-01-02" />

<Student DateOfBirth="1993-09-10" Gender="F" Name="&#x00C9;mily" />

</Students>

=={{header|Java}}==

{{uses from|Library|java.io|component1=IOException|component2=StringReader}}

{{uses from|Library|org.xml.sax|component1=Attributes|component2=InputSource|component3=SAXException|component4=XMLReader|component5=helpers.DefaultHandler|component6=helpers.XMLReaderFactory}}

import java.io.StringReader;

import org.xml.sax.Attributes;

}

}

 

=={{header|JavaScript}}==

var xmlstr = '<Students>' +

'<Student Name="April" Gender="F" DateOfBirth="1989-01-02" />' +

'</Students>';

 

}

}

 

 

Alternatively, use the E4X featureset (currently only in Firefox):

var xmlstr = '<Students>' +

'<Student Name="April" Gender="F" DateOfBirth="1989-01-02" />' +

 

alert(output);

 

=={{header|Objeck}}==

use XML;

 

}

}

 

=={{header|OCaml}}==

from the toplevel using the library [http://tech.motion-twin.com/xmllight.html xml-light]:

# #load "xml-light.cma" ;;

 

Dave

&#x00C9;mily

 

Another solution using the library [http://erratique.ch/software/xmlm xmlm]:

#load "xmlm.cmo"

open Xmlm

List.iter (function ((_, "Name"), name) -> print_endline name | _ -> ()) attrs

| _ -> ()

 

using the [http://www.xs4all.nl/~mmzeeman/ocaml/ ocaml expat wrapper]:

 

 

let xml_str = "

);

parse p xml_str;

 

=={{header|Oz}}==

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

Parser = {New XMLParser.parser init}

StudentNames = {Map Students GetStudentName}

in

 

=={{header|Perl}}==

{{libheader|XML::Simple}}

 

my $ref = XMLin('<Students>

</Students>');

 

 

=={{header|PHP}}==

$data = '<Students>

<Student Name="April" Gender="F" DateOfBirth="1989-01-02" />

if ( XMLREADER::ELEMENT == $xml->nodeType && $xml->localName == 'Student' )

echo $xml->getAttribute('Name') . "\n";

 

=={{header|PicoLisp}}==

 

(mapcar

'((L) (attr L 'Name))

Output:

<pre>-> ("April" "Bob" "Chad" "Dave" "Émily")</pre>

 

 

[xml]$xml = @'

<Students>

 

 

 

=={{header|PureBasic}}==

Uses a PureBasic XML library (which is linked automatically) that is based on the library [http://expat.sourceforge.net/ expat XML parser] licensed under the MIT license.

 

src$ = "<Students>"

MessageRequester("Student Names", studentNames\s)

FreeXML(0)

Sample output:

<pre>

 

=={{header|Python}}==

 

doc = """<Students>

 

for i in doc.getElementsByTagName("Student"):

 

=={{header|R}}==

{{libheader|XML}}

#Read in XML string

str <- readLines(tc <- textConnection('<Students>

</Students>'))

close(tc)

[1] "<Students>"

[2] " <Student Name=\"April\" Gender=\"F\" DateOfBirth=\"1989-01-02\" />"

[8] " <Student DateOfBirth=\"1993-09-10\" Gender=\"F\" Name=\"&#x00C9;mily\" />"

[9] "</Students>"

xmltree <- xmlTreeParse(str)

 

#Change the encoding so that Emily displays correctly

Encoding(studentsnames) <- "UTF-8"

 

=={{header|REBOL}}==

Title: "XML Reading"

URL: http://rosettacode.org/wiki/XML_Reading

]

print select student/2 "Name"

]

 

Output:

=={{header|REXX}}==

===version 1===

 

g.j=space(g.j)

April

Bob

Rover

&#x00C9;mily

 

===version 2===

 

 

April

Bob

Rover

Émily

 

=={{header|Ruby}}==

{{libheader|REXML}}

include REXML

 

 

# using xpath

 

=={{header|Scala}}==

Scala has native XML support, with query constructs similar to XPath and XQuery.

 

<Students>

<Student Name="April" Gender="F" DateOfBirth="1989-01-02" />

</Students>

 

 

=={{header|Slate}}==

Slate's XML Reader is still being developed at the time of this writing.

 

tree: (Xml SimpleParser newOn: '<Students>

Dave

&#x00C9;mily

 

=={{header|Tcl}}==

Using {{libheader|tDOM}}

set tree [dom parse $xml]

set studentNodes [$tree getElementsByTagName Student] ;# or: set studentNodes [[$tree documentElement] childNodes]

foreach node $studentNodes {

puts [$node getAttribute Name]

Using {{libheader|TclXML}}

set parser [xml::parser -elementstartcommand elem]

proc elem {name attlist args} {

}

}

 

Using just pure-Tcl (originally on http://wiki.tcl.tk/3919):

regsub -all {>\s*<} [string trim $xml " \n\t<>"] "\} \{" xml

set xml [string map {> "\} \{#text \{" < "\}\} \{"} $xml]

}

}

 

=={{header|TUSCRIPT}}==

$$ MODE TUSCRIPT

MODE DATA

</Students>

$$ MODE TUSCRIPT

LOOP x = xmldata

ENDLOOP

=={{header|Vedit macro language}}==

This implementation finds all ''Student'' tags and then displays the contents of their ''Name'' parameter.

Search("<Student|X", ERRBREAK)

#1 = Cur_Pos

Type_Block(#2, Cur_Pos)

Type_Newline

 

Output:

 

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

<Student Name="April"/>

<Student Name="Bob"/>

For Each name In names

Console.WriteLine(name)

 

{{omit from|PARI/GP|No real capacity for string manipulation}}