XML/Input

From Rosetta Code
< XML
Jump to: navigation, search
Task
XML/Input
You are encouraged to solve this task according to the task description, using any language you may know.

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.

<Students>
<Student Name="April" Gender="F" DateOfBirth="1989-01-02" />
<Student Name="Bob" Gender="M" DateOfBirth="1990-03-04" />
<Student Name="Chad" Gender="M" DateOfBirth="1991-05-06" />
<Student Name="Dave" Gender="M" DateOfBirth="1992-07-08">
<Pet Type="dog" Name="Rover" />
</Student>
<Student DateOfBirth="1993-09-10" Gender="F" Name="&#x00C9;mily" />
</Students>

Expected Output

April
Bob
Chad
Dave
Émily

Contents

[edit] ActionScript

package 
{
import flash.display.Sprite;
 
public class XMLReading extends Sprite
{
public function XMLReading()
{
var xml:XML = <Students>
<Student Name="April" />
<Student Name="Bob" />
<Student Name="Chad" />
<Student Name="Dave" />
<Student Name="Emily" />
</Students>;
for each(var node:XML in xml..Student)
{
trace(node.@Name);
}
}
}
}

[edit] Ada

Works with: GNAT

Uses XML/Ada from AdaCore.

extract_students.adb:

with Sax.Readers;
with Input_Sources.Strings;
with Unicode.CES.Utf8;
with My_Reader;
 
procedure Extract_Students is
Sample_String : String :=
"<Students>" &
"<Student Name=""April"" Gender=""F"" DateOfBirth=""1989-01-02"" />" &
"<Student Name=""Bob"" Gender=""M"" DateOfBirth=""1990-03-04"" />" &
"<Student Name=""Chad"" Gender=""M"" DateOfBirth=""1991-05-06"" />" &
"<Student Name=""Dave"" Gender=""M"" DateOfBirth=""1992-07-08"">" &
"<Pet Type=""dog"" Name=""Rover"" />" &
"</Student>" &
"<Student DateOfBirth=""1993-09-10"" Gender=""F"" Name=""&#x00C9;mily"" />" &
"</Students>";
Reader : My_Reader.Reader;
Input : Input_Sources.Strings.String_Input;
begin
Input_Sources.Strings.Open (Sample_String, Unicode.CES.Utf8.Utf8_Encoding, Input);
My_Reader.Parse (Reader, Input);
Input_Sources.Strings.Close (Input);
end Extract_Students;

my_reader.ads:

with Sax.Attributes;
with Sax.Readers;
with Unicode.CES;
package My_Reader is
type Reader is new Sax.Readers.Reader with null record;
procedure Start_Element
(Handler  : in out Reader;
Namespace_URI : Unicode.CES.Byte_Sequence := "";
Local_Name  : Unicode.CES.Byte_Sequence := "";
Qname  : Unicode.CES.Byte_Sequence := "";
Atts  : Sax.Attributes.Attributes'Class);
end My_Reader;

my_reader.adb:

with Ada.Text_IO;
package body My_Reader is
procedure Start_Element
(Handler  : in out Reader;
Namespace_URI : Unicode.CES.Byte_Sequence := "";
Local_Name  : Unicode.CES.Byte_Sequence := "";
Qname  : Unicode.CES.Byte_Sequence := "";
Atts  : Sax.Attributes.Attributes'Class) is
begin
if Local_Name = "Student" then
Ada.Text_IO.Put_Line (Sax.Attributes.Get_Value (Atts, "Name"));
end if;
end Start_Element;
end My_Reader;

Output:

April
Bob
Chad
Dave
Émily

[edit] Alternative using a DOM document

with Ada.Text_IO;
with Sax.Readers;
with Input_Sources.Strings;
with Unicode.CES.Utf8;
with DOM.Readers;
with DOM.Core.Documents;
with DOM.Core.Nodes;
with DOM.Core.Attrs;
 
procedure Extract_Students is
Sample_String : String :=
"<Students>" &
"<Student Name=""April"" Gender=""F"" DateOfBirth=""1989-01-02"" />" &
"<Student Name=""Bob"" Gender=""M"" DateOfBirth=""1990-03-04"" />" &
"<Student Name=""Chad"" Gender=""M"" DateOfBirth=""1991-05-06"" />" &
"<Student Name=""Dave"" Gender=""M"" DateOfBirth=""1992-07-08"">" &
"<Pet Type=""dog"" Name=""Rover"" />" &
"</Student>" &
"<Student DateOfBirth=""1993-09-10"" Gender=""F"" Name=""&#x00C9;mily"" />" &
"</Students>";
Input : Input_Sources.Strings.String_Input;
Reader : DOM.Readers.Tree_Reader;
Document : DOM.Core.Document;
List : DOM.Core.Node_List;
begin
Input_Sources.Strings.Open (Sample_String, Unicode.CES.Utf8.Utf8_Encoding, Input);
DOM.Readers.Parse (Reader, Input);
Input_Sources.Strings.Close (Input);
Document := DOM.Readers.Get_Tree (Reader);
List := DOM.Core.Documents.Get_Elements_By_Tag_Name (Document, "Student");
for I in 0 .. DOM.Core.Nodes.Length (List) - 1 loop
Ada.Text_IO.Put_Line
(DOM.Core.Attrs.Value
(DOM.Core.Nodes.Get_Named_Item
(DOM.Core.Nodes.Attributes
(DOM.Core.Nodes.Item (List, I)), "Name")
)
);
end loop;
DOM.Readers.Free (Reader);
end Extract_Students;

output is the same.

[edit] Alternative version using Matreshka

Uses Matreshka's SAX API for XML.

main.adb:

with League.Application;
with XML.SAX.Input_Sources.Streams.Files;
with XML.SAX.Simple_Readers;
 
with Handlers;
 
procedure Main is
Handler : aliased Handlers.Handler;
Input  : aliased XML.SAX.Input_Sources.Streams.Files.File_Input_Source;
Reader  : aliased XML.SAX.Simple_Readers.SAX_Simple_Reader;
 
begin
Input.Open_By_File_Name (League.Application.Arguments.Element (1));
Reader.Set_Content_Handler (Handler'Unchecked_Access);
Reader.Parse (Input'Unchecked_Access);
end Main;

handlers.ads:

with League.Strings;
with XML.SAX.Attributes;
with XML.SAX.Content_Handlers;
 
package Handlers is
 
type Handler is
limited new XML.SAX.Content_Handlers.SAX_Content_Handler with null record;
 
overriding procedure Start_Element
(Self  : in out Handler;
Namespace_URI  : League.Strings.Universal_String;
Local_Name  : League.Strings.Universal_String;
Qualified_Name : League.Strings.Universal_String;
Attributes  : XML.SAX.Attributes.SAX_Attributes;
Success  : in out Boolean);
 
overriding function Error_String
(Self : Handler) return League.Strings.Universal_String;
 
end Handlers;

handlers.adb:

with Ada.Wide_Wide_Text_IO;
 
package body Handlers is
 
use type League.Strings.Universal_String;
 
function "+"
(Item : Wide_Wide_String) return League.Strings.Universal_String
renames League.Strings.To_Universal_String;
 
------------------
-- Error_String --
------------------
 
overriding function Error_String
(Self : Handler) return League.Strings.Universal_String is
begin
return League.Strings.Empty_Universal_String;
end Error_String;
 
-------------------
-- Start_Element --
-------------------
 
overriding procedure Start_Element
(Self  : in out Handler;
Namespace_URI  : League.Strings.Universal_String;
Local_Name  : League.Strings.Universal_String;
Qualified_Name : League.Strings.Universal_String;
Attributes  : XML.SAX.Attributes.SAX_Attributes;
Success  : in out Boolean) is
begin
if Qualified_Name = +"Student" then
Ada.Wide_Wide_Text_IO.Put_Line
(Attributes.Value (+"Name").To_Wide_Wide_String);
end if;
end Start_Element;
 
end Handlers;

[edit] Aikido

Put the XML in the file called t.xml

 
import xml
 
var s = openin ("t.xml")
var tree = XML.parseStream (s)
 
foreach node tree {
if (node.name == "Students") {
foreach studentnode node {
if (studentnode.name == "Student") {
println (studentnode.getAttribute ("Name"))
}
}
}
}
 
 

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

April
Bob
Chad
Dave
Émily

[edit] AutoHotkey

simply using regular expressions

students = 
(
<Students>
<Student Name="April" Gender="F" DateOfBirth="1989-01-02" />
<Student Name="Bob" Gender="M" DateOfBirth="1990-03-04" />
<Student Name="Chad" Gender="M" DateOfBirth="1991-05-06" />
<Student Name="Dave" Gender="M" DateOfBirth="1992-07-08">
<Pet Type="dog" Name="Rover" />
</Student>
<Student DateOfBirth="1993-09-10" Gender="F" Name="&#x00C9;mily" />
</Students>
)
 
quote = " ; "
pos = 1
while, pos := RegExMatch(students, "Name=.(\w+)" . quote . "\sGender"
, name, pos + 1)
names .= name1 . "`n"
 
msgbox % names

[edit] AWK

The following code extracts the value of the property "Name" from every Student tag. It does not handle the &#CODE;; 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.

function parse_buf()
{
if ( match(buffer, /<Student[ \t]+[^>]*Name[ \t]*=[ \t]*"([^"]*)"/, mt) != 0 ) {
students[mt[1]] = 1
}
buffer = "
"
}
 
BEGIN {
FS="
"
mode = 0
buffer = "
"
li = 1
}
 
mode==1 {
for(i=1; i <= NF; i++) {
buffer = buffer $i
if ( $i == "
>" ) {
mode = 0;
break;
}
}
if ( mode == 0 ) {
li = i
} else {
li = 1
}
# let us process the buffer if "
complete"
if ( mode == 0 ) {
parse_buf()
}
}
 
mode==0 {
for(i=li; i <= NF; i++) {
if ( $i == "
<" ) {
mode = 1
break;
}
}
for(j=i; i <= NF; i++) {
buffer = buffer $i
if ( $i == "
>" ) {
mode = 0
parse_buf()
}
}
li = 1
}
 
END {
for(k in students) {
print k
}
}

Using getXML.awk written by Jan Weber, one could do this:

Works with: gawk
or
Works with: nawk
awk -f getXML.awk sample.xml | awk '
$1 == "TAG" {tag = $2}
tag == "Student" && /Name=/ {print substr($0, index($0, "=") + 1)}
'

Using xmlparser.awk by Steve Coile, one can do this:

Works with: gawk
gawk -f xmlparser.awk sample.xml | awk '
$1 == "begin" {tag = $2}
$1 == "attrib" {attrib = $2}
$1 == "value" && tag == "STUDENT" && attrib == "name" {print $2}
'

Both of these produce this output

April
Bob
Chad
Dave
&#x00C9;mily
Works with: XMLgawk

Scripts in AWK are often one-liners. This one-liner implementation searches for Student tags and then displays the contents of their Name attribute. The following line is meant to be typed in on the command line of a Unix shell or an MS-DOS command window.

gawk -lxml 'XMLSTARTELEM == "Student" {print XMLATTR["Name"]}' rosetta.xml

Output:

April
Bob
Chad
Dave
Émily

[edit] BBC BASIC

      INSTALL @lib$+"XMLLIB"
xmlfile$ = "C:\students.xml"
PROC_initXML(xmlobj{}, xmlfile$)
 
level% = FN_skipTo(xmlobj{}, "Students", 0)
IF level%=0 ERROR 100, "Students not found"
 
REPEAT
IF FN_isTag(xmlobj{}) THEN
tag$ = FN_nextToken(xmlobj{})
IF LEFT$(tag$, 8) = "<Student" THEN
np% = INSTR(tag$, "Name")
IF np% THEN PRINT FN_repEnt(EVAL(MID$(tag$, np%+5)))
ENDIF
ELSE
dummy$ = FN_nextToken(xmlobj{})
ENDIF
UNTIL FN_getLevel(xmlobj{}) < level%
 
PROC_exitXML(xmlobj{})

Output:

April
Bob
Chad
Dave
Émily

[edit] Bracmat

The get function can read markup into a native datastructure, which can be analysed using pattern matching. The read datastructure is a flat list of tags and text fragments. For proper nesting of elements extra code would have to be written, but in this simple task that is not necessary. On the downside, the pattern must both handle empty tags (the (? (Name.?name) ?, pattern) and open tags (the ? (Name.?name) ? pattern). Reading input from a file:

( :?names
& ( get$("students.xml",X,ML)
 :  ?
( ( Student
. (? (Name.?name) ?,)
| ? (Name.?name) ?
)
& !names !name:?names
& ~
)
 ?
| !names
)
)

Alternative solution, reading input from memory:

( :?names
& ( get
$ ( "<Students>
<Student Name=\"April\" Gender=\"F\" DateOfBirth=\"1989-01-02\" />
<Student Name=\"Bob\" Gender=\"M\" DateOfBirth=\"1990-03-04\" />
<Student Name=\"Chad\" Gender=\"M\" DateOfBirth=\"1991-05-06\" />
<Student Name=\"Dave\" Gender=\"M\" DateOfBirth=\"1992-07-08\">
<Pet Type=\"dog\" Name=\"Rover\" />
</Student>
<Student DateOfBirth=\"1993-09-10\" Gender=\"F\" Name=\"&#x00C9;mily\" />
</Students>"
, MEM
, X
, ML
)
 :  ?
( ( Student
. (? (Name.?name) ?,)
| ? (Name.?name) ?
)
& !names !name:?names
& ~
)
 ?
| !names
)
)

Output:

April Bob Chad Dave Émily

[edit] C

Library: LibXML
Uses: C Runtime (Components:printf,)
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <libxml/parser.h>
#include <libxml/tree.h>
 
static void print_names(xmlNode *node)
{
xmlNode *cur_node = NULL;
for (cur_node = node; cur_node; cur_node = cur_node->next) {
if (cur_node->type == XML_ELEMENT_NODE) {
if ( strcmp(cur_node->name, "Student") == 0 ) {
xmlAttr *prop = NULL;
if ( (prop = xmlHasProp(cur_node, "Name")) != NULL ) {
printf("%s\n", prop->children->content);
 
}
}
}
print_names(cur_node->children);
}
}
 
const char *buffer =
"<Students>\n"
" <Student Name=\"April\" Gender=\"F\" DateOfBirth=\"1989-01-02\" />\n"
" <Student Name=\"Bob\" Gender=\"M\" DateOfBirth=\"1990-03-04\" />\n"
" <Student Name=\"Chad\" Gender=\"M\" DateOfBirth=\"1991-05-06\" />\n"
" <Student Name=\"Dave\" Gender=\"M\" DateOfBirth=\"1992-07-08\">\n"
" <Pet Type=\"dog\" Name=\"Rover\" />\n"
" </Student>\n"
" <Student DateOfBirth=\"1993-09-10\" Gender=\"F\" Name=\"&#x00C9;mily\" />\n"
"</Students>\n";
 
int main()
{
xmlDoc *doc = NULL;
xmlNode *root = NULL;
 
doc = xmlReadMemory(buffer, strlen(buffer), NULL, NULL, 0);
if ( doc != NULL ) {
root = xmlDocGetRootElement(doc);
print_names(root);
xmlFreeDoc(doc);
}
xmlCleanupParser();
return 0;
}

[edit] C++

Library: Qt
Uses: Qt (Components:QDomDocument,QObject,QDomElement,)
/*
Using the Qt library's XML parser.
*/

#include <iostream>
 
#include <QDomDocument>
#include <QObject>
 
int main() {
QDomDocument doc;
 
doc.setContent(
QObject::tr(
"<Students>\n"
"<Student Name=\"April\" Gender=\"F\" DateOfBirth=\"1989-01-02\" />\n"
"<Student Name=\"Bob\" Gender=\"M\" DateOfBirth=\"1990-03-04\" />\n"
"<Student Name=\"Chad\" Gender=\"M\" DateOfBirth=\"1991-05-06\" />\n"
"<Student Name=\"Dave\" Gender=\"M\" DateOfBirth=\"1992-07-08\">\n"
"<Pet Type=\"dog\" Name=\"Rover\" />\n"
"</Student>\n"
"<Student DateOfBirth=\"1993-09-10\" Gender=\"F\" Name=\"&#x00C9;mily\" />\n"
"</Students>"));
 
QDomElement n = doc.documentElement().firstChildElement("Student");
while(!n.isNull()) {
std::cout << qPrintable(n.attribute("Name")) << std::endl;
n = n.nextSiblingElement();
}
return 0;
}

[edit] C#

 
class Program
{
static void Main(string[] args)
{
XDocument xmlDoc = XDocument.Load("XMLFile1.xml");
var query = from p in xmlDoc.Descendants("Student")
select p.Attribute("Name");
 
foreach (var item in query)
{
Console.WriteLine(item.Value);
}
Console.ReadLine();
}
}
 

[edit] Caché ObjectScript

Class XML.Students [ Abstract ]
{
 
XData XMLData
{
<Students>
<Student Name="April" Gender="F" DateOfBirth="1989-01-02" />
<Student Name="Bob" Gender="M" DateOfBirth="1990-03-04" />
<Student Name="Chad" Gender="M" DateOfBirth="1991-05-06" />
<Student Name="Dave" Gender="M" DateOfBirth="1992-07-08">
<Pet Type="dog" Name="Rover" />
</Student>
<Student DateOfBirth="1993-09-10" Gender="F" Name="&#x00C9;mily" />
</Students>
}
 
ClassMethod Output() As %Status
{
// get xml stream from the 'XData' block contained in this class and parse
Set xdata=##class(%Dictionary.CompiledXData).%OpenId($this_"||XMLData",, .sc)
If $$$ISERR(sc) Quit sc
Set sc=##class(%XML.TextReader).ParseStream(xdata.Data, .hdlr)
If $$$ISERR(sc) Quit sc
 
// iterate through document, node by node
While hdlr.Read() {
If hdlr.Path="/Students/Student", hdlr.MoveToAttributeName("Name") {
Write hdlr.Value, !
}
}
 
// finished
Quit $$$OK
}
 
}
Examples:
USER>Do ##class(XML.Students).Output()
April
Bob
Chad
Dave
Émily

[edit] Clojure

Uses: java.io (Components:ByteArrayInputStream,)
Uses: clojure.xml (Components:parse,)

This version uses the standard Clojure function xml-seq'

 
(import '(java.io ByteArrayInputStream))
(use 'clojure.xml) ; defines 'parse
 
(def xml-text "<Students>
<Student Name='April' Gender='F' DateOfBirth='1989-01-02' />
<Student Name='Bob' Gender='M' DateOfBirth='1990-03-04' />
<Student Name='Chad' Gender='M' DateOfBirth='1991-05-06' />
<Student Name='Dave' Gender='M' DateOfBirth='1992-07-08'>
<Pet Type='dog' Name='Rover' />
</Student>
<Student DateOfBirth='1993-09-10' Gender='F' Name='&#x00C9;mily' />
</Students>"
)
 
(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. Thus the "April" element becomes {:tag :Student, :attrs {:Name "April", :Gender "F", :DateOfBirth "1989-01-02"}, :content nil}. 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))))
 

[edit] Common Lisp

Library: Closure XML
(defparameter *xml-blob*
"<Students>
<Student Name=\"April\" Gender=\"F\" DateOfBirth=\"1989-01-02\" />
<Student Name=\"Bob\" Gender=\"M\" DateOfBirth=\"1990-03-04\" />
<Student Name=\"Chad\" Gender=\"M\" DateOfBirth=\"1991-05-06\" />
<Student Name=\"Dave\" Gender=\"M\" DateOfBirth=\"1992-07-08\">
<Pet Type=\"dog\" Name=\"Rover\" />
</Student>
<Student DateOfBirth=\"1993-09-10\" Gender=\"F\" Name=\"&#x00C9;mily\" />
</Students>"
)
 
(let* ((document (cxml:parse *xml-blob* (cxml-dom:make-dom-builder)))
(students (dom:item (dom:get-elements-by-tag-name document "Students") 0))
(student-names '()))
(dom:do-node-list (child (dom:child-nodes students) (nreverse student-names))
(when (dom:element-p child)
(push (dom:get-attribute child "Name") student-names))))
produces
("April" "Bob" "Chad" "Dave" "Émily")

[edit] D

Library: KXML
import kxml.xml;
char[]xmlinput =
"<Students>
<Student Name=\"April\" Gender=\"F\" DateOfBirth=\"1989-01-02\" />
<Student Name=\"Bob\" Gender=\"M\" DateOfBirth=\"1990-03-04\" />
<Student Name=\"Chad\" Gender=\"M\" DateOfBirth=\"1991-05-06\" />
<Student Name=\"Dave\" Gender=\"M\" DateOfBirth=\"1992-07-08\">
<Pet Type=\"dog\" Name=\"Rover\" />
</Student>
<Student DateOfBirth=\"1993-09-10\" Gender=\"F\" Name=\"&#x00C9;mily\" />
</Students>"
;
 
void main() {
auto root = readDocument(xmlinput);
foreach(students;root.getChildren) if (!students.isCData && students.getName == "Students") {
// now look for student subnodes
foreach(student;students.getChildren) if (!student.isCData && student.getName == "Student") {
// we found a student!
std.stdio.writefln("%s",student.getAttribute("Name"));
}
// we only want one, so break out of the loop once we find a match
break;
}
}

[edit] Delphi

 
//You need to use these units
uses
SysUtils,
Dialogs,
XMLIntf,
XMLDoc;
 
//..............................................
 
//This function process the XML
function GetStudents(aXMLInput: string): string;
var
XMLDoc: IXMLDocument;
i: Integer;
begin
//Creating the TXMLDocument instance
XMLDoc:= TXMLDocument.Create(nil);
 
//Loading8 the XML string
XMLDoc.LoadFromXML(aXMLInput);
 
//Parsing the xml document
for i:=0 to XMLDoc.DocumentElement.ChildNodes.Count - 1 do
Result:= Result + XMLDoc.DocumentElement.ChildNodes.Get(i).GetAttributeNS('Name', '') + #13#10;
 
//Removing the trailing #13#10 characters
Result:= Trim(Result);
end;
 
//..............................................
 
//Consuming code example (fragment)
var
XMLInput: string;
begin
XMLInput:= '<Students>' +
'<Student Name="April" Gender="F" DateOfBirth="1989-01-02" />' +
'<Student Name="Bob" Gender="M" DateOfBirth="1990-03-04" />' +
'<Student Name="Chad" Gender="M" DateOfBirth="1991-05-06" />' +
'<Student Name="Dave" Gender="M" DateOfBirth="1992-07-08">' +
'<Pet Type="dog" Name="Rover" />' +
'</Student>' +
'<Student DateOfBirth="1993-09-10" Gender="F" Name="&#x00C9;mily" />'+
'</Students>';
Showmessage(GetStudents(XMLInput));
end;
 


[edit] Erlang

 
-module( xml_input ).
 
-export( [task/0] ).
 
-include_lib("xmerl/include/xmerl.hrl").
 
task() ->
{XML, []} = xmerl_scan:string( xml(), [{encoding, "iso-10646-utf-1"}] ),
Attributes = lists:flatten( [X || #xmlElement{name='Student', attributes=X} <- XML#xmlElement.content] ),
[io:fwrite("~s~n", [X]) || #xmlAttribute{name='Name', value=X} <- Attributes].
 
 
 
xml() -> "<Students>
<Student Name=\"April\" Gender=\"F\" DateOfBirth=\"1989-01-02\" />
<Student Name=\"Bob\" Gender=\"M\" DateOfBirth=\"1990-03-04\" />
<Student Name=\"Chad\" Gender=\"M\" DateOfBirth=\"1991-05-06\" />
<Student Name=\"Dave\" Gender=\"M\" DateOfBirth=\"1992-07-08\">
<Pet Type=\"dog\" Name=\"Rover\" />
</Student>
<Student DateOfBirth=\"1993-09-10\" Gender=\"F\" Name=\"&#x00C9;mily\" />
</Students>"
.
 
Output:
38> xml_input:task().
April
Bob
Chad
Dave
Émily

[edit] F#

open System.IO
open System.Xml
open System.Xml.Linq
 
let xn s = XName.Get(s)
 
let xd = XDocument.Load(new StringReader("""
<Students>
<Student Name="
April" Gender="F" DateOfBirth="1989-01-02" />
<Student Name="
Bob" Gender="M" DateOfBirth="1990-03-04" />
<Student Name="
Chad" Gender="M" DateOfBirth="1991-05-06" />
<Student Name="
Dave" Gender="M" DateOfBirth="1992-07-08">
<Pet Type="
dog" Name="Rover" />
</Student>
<Student DateOfBirth="
1993-09-10" Gender="F" Name="&#x00C9;mily" />
</Students>
""")) // "
 
 
 
[<EntryPoint>]
let main argv =
let students = xd.Descendants <| xn "Student"
let names = students.Attributes <| xn "Name"
Seq.iter ((fun (a : XAttribute) -> a.Value) >> printfn "%s") names
0

[edit] Factor

USING: io sequences xml xml.data xml.traversal ;
 
: print-student-names ( string -- )
string>xml "Student" tags-named [ "Name" attr print ] each ;
 
"""<Students>
<Student Name="April" Gender="F" DateOfBirth="1989-01-02" />
<Student Name="Bob" Gender="M" DateOfBirth="1990-03-04" />
<Student Name="Chad" Gender="M" DateOfBirth="1991-05-06" />
<Student Name="Dave" Gender="M" DateOfBirth="1992-07-08">
<Pet Type="dog" Name="Rover" />
</Student>
<Student DateOfBirth="1993-09-10" Gender="F" Name="&#x00C9;mily" />
</Students>""" print-student-names

[edit] Fantom

 
using xml
 
class XmlInput
{
public static Void main ()
{
// create the XML parser
parser := XParser(File("sample-xml.xml".toUri).in)
// parse the document, creating an XML document
XDoc doc := parser.parseDoc
// walk through each child element from the root of the document
doc.root.elems.each |elem|
{
// printing the Name attribute of all Students
if (elem.name == "Student") { echo (elem.get("Name")) }
}
}
}
 

[edit] Forth

include ffl/est.fs
include ffl/str.fs
include ffl/xis.fs
 
\ Build input string
str-create xmlstr
: x+ xmlstr str-append-string ;
 
s\" <Students>\n" x+
s\" <Student Name=\"April\" Gender=\"F\" DateOfBirth=\"1989-01-02\" />\n" x+
s\" <Student Name=\"Bob\" Gender=\"M\" DateOfBirth=\"1990-03-04\" />\n" x+
s\" <Student Name=\"Chad\" Gender=\"M\" DateOfBirth=\"1991-05-06\" />\n" x+
s\" <Student Name=\"Dave\" Gender=\"M\" DateOfBirth=\"1992-07-08\">\n" x+
s\" <Pet Type=\"dog\" Name=\"Rover\" />\n" x+
s\" </Student>\n" x+
s\" <Student DateOfBirth=\"1993-09-10\" Gender=\"F\" Name=\"&#x00C9;mily\" />\n" x+
s\" </Students>\n" x+
 
\ Setup xml parser
xis-create xmlparser
xmlstr str-get xmlparser xis-set-string
 
\ Parse the xml
: xmlparse
BEGIN
xmlparser xis-read dup xis.error <> over xis.done <> AND
WHILE
dup xis.start-tag = over xis.empty-element = OR IF
drop
s" Student" compare 0= IF
0 ?DO
2swap s" Name" compare 0= IF
type cr
ELSE
2drop
THEN
LOOP
ELSE
xis+remove-attribute-parameters
THEN
ELSE
xis+remove-read-parameters
THEN
REPEAT
drop
;
 
xmlparse

[edit] Go

Go's xml.Unmarshal uses reflection to fill in data-structures recursively.

package main
 
import (
"encoding/xml"
"fmt"
)
 
const XML_DATA = `
<Students>
<Student Name="April" Gender="F" DateOfBirth="1989-01-02" />
<Student Name="Bob" Gender="M" DateOfBirth="1990-03-04" />
<Student Name="Chad" Gender="M" DateOfBirth="1991-05-06" />
<Student Name="Dave" Gender="M" DateOfBirth="1992-07-08">
<Pet Type="dog" Name="Rover" />
</Student>
<Student DateOfBirth="1993-09-10" Gender="F" Name="&#x00C9;mily" />
</Students>
`

 
type Students struct {
Student []Student
}
 
type Student struct {
Name string `xml:",attr"`
// Gender string `xml:",attr"`
// DateOfBirth string `xml:",attr"`
// Pets []Pet `xml:"Pet"`
}
 
type Pet struct {
Type string `xml:",attr"`
Name string `xml:",attr"`
}
 
// xml.Unmarshal quietly skips well formed input with no corresponding
// member in the output data structure. With Gender, DateOfBirth, and
// Pets commented out of the Student struct, as above, Student contains
// only Name, and this is the only value extracted from the input XML_DATA.
func main() {
data := new(Students)
err := xml.Unmarshal([]byte(XML_DATA), data)
if err != nil {
fmt.Println(err)
return
}
for _, s := range data.Student {
fmt.Println(s.Name)
}
}
Output:
April
Bob
Chad
Dave
Émily

[edit] Groovy

def input = """<Students>
<Student Name="April" Gender="F" DateOfBirth="1989-01-02" />
<Student Name="Bob" Gender="M" DateOfBirth="1990-03-04" />
<Student Name="Chad" Gender="M" DateOfBirth="1991-05-06" />
<Student Name="Dave" Gender="M" DateOfBirth="1992-07-08">
<Pet Type="dog" Name="Rover" />
</Student>
<Student DateOfBirth="1993-09-10" Gender="F" Name="&#x00C9;mily" />
</Students>"""

 
def students = new XmlParser().parseText(input)
students.each { println it.'@Name' }

[edit] Haskell

import Data.Maybe
import Text.XML.Light
 
students="<Students>"++
" <Student Name=\"April\" Gender=\"F\" DateOfBirth=\"1989-01-02\" />"++
" <Student Name=\"Bob\" Gender=\"M\" DateOfBirth=\"1990-03-04\" />"++
" <Student Name=\"Chad\" Gender=\"M\" DateOfBirth=\"1991-05-06\"/>"++
" <Student Name=\"Dave\" Gender=\"M\" DateOfBirth=\"1992-07-08\">"++
" <Pet Type=\"dog\" Name=\"Rover\" /> </Student>"++
" <Student DateOfBirth=\"1993-09-10\" Gender=\"F\" Name=\"&#x00C9;mily\" />"++
"</Students>"
 
xmlRead elm name = mapM_ putStrLn
. concatMap (map (fromJust.findAttr (unqual name)).filterElementsName (== unqual elm))
. onlyElems. parseXML

Show names:

*Main> xmlRead "Student" "Name" students
April
Bob
Chad
Dave
Émily

[edit] HicEst

CHARACTER in*1000, out*100
 
READ(ClipBoard) in
EDIT(Text=in, SPR='"', Right='<Student', Right='Name=', Word=1, WordEnd, APpendTo=out, DO)
out is returned as:
April  Bob  Chad  Dave  Émily

[edit] J

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:

load'xml/sax'
 
saxclass 'Students'
startElement =: ([: smoutput 'Name' getAttribute~ [)^:('Student'-:])
cocurrent'base'
 
process_Students_ XML
April
Bob
Chad
Dave
Émily

and the definition of the variable XML:

XML=: noun define
<Students>
<Student Name="April" Gender="F" DateOfBirth="1989-01-02" />
<Student Name="Bob" Gender="M" DateOfBirth="1990-03-04" />
<Student Name="Chad" Gender="M" DateOfBirth="1991-05-06" />
<Student Name="Dave" Gender="M" DateOfBirth="1992-07-08">
<Pet Type="dog" Name="Rover" />
</Student>
<Student DateOfBirth="1993-09-10" Gender="F" Name="&#x00C9;mily" />
</Students>
)

[edit] Java

Uses: java.io (Components:IOException,StringReader,)
import java.io.IOException;
import java.io.StringReader;
import org.xml.sax.Attributes;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
import org.xml.sax.XMLReader;
import org.xml.sax.helpers.DefaultHandler;
import org.xml.sax.helpers.XMLReaderFactory;
 
public class StudentHandler extends DefaultHandler {
public static void main(String[] args)throws Exception{
String xml = "<Students>\n"+
"<Student Name=\"April\" Gender=\"F\" DateOfBirth=\"1989-01-02\" />\n"+
"<Student Name=\"Bob\" Gender=\"M\" DateOfBirth=\"1990-03-04\" />\n"+
"<Student Name=\"Chad\" Gender=\"M\" DateOfBirth=\"1991-05-06\" />\n"+
"<Student Name=\"Dave\" Gender=\"M\" DateOfBirth=\"1992-07-08\">\n"+
" <Pet Type=\"dog\" Name=\"Rover\" />\n"+
"</Student>\n"+
"<Student DateOfBirth=\"1993-09-10\" Gender=\"F\" Name=\"&#x00C9;mily\" />\n"+
"</Students>";
StudentHandler handler = new StudentHandler();
handler.parse(new InputSource(new StringReader(xml)));
}
 
public void parse(InputSource src) throws SAXException, IOException {
XMLReader parser = XMLReaderFactory.createXMLReader();
parser.setContentHandler(this);
parser.parse(src);
}
 
@Override
public void characters(char[] ch, int start, int length) throws SAXException {
//if there were text as part of the elements, we would deal with it here
//by adding it to a StringBuffer, but we don't have to for this task
super.characters(ch, start, length);
}
 
@Override
public void endElement(String uri, String localName, String qName) throws SAXException {
//this is where we would get the info from the StringBuffer if we had to,
//but all we need is attributes
super.endElement(uri, localName, qName);
}
 
@Override
public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
if(qName.equals("Student")){
System.out.println(attributes.getValue("Name"));
}
}
}

[edit] JavaScript

This version tested against Chrome 5, Firefox 3.6, and IE 8:

 
var xmlstr = '<Students>' +
'<Student Name="April" Gender="F" DateOfBirth="1989-01-02" />' +
'<Student Name="Bob" Gender="M" DateOfBirth="1990-03-04" />' +
'<Student Name="Chad" Gender="M" DateOfBirth="1991-05-06" />' +
'<Student Name="Dave" Gender="M" DateOfBirth="1992-07-08">' +
'<Pet Type="dog" Name="Rover" />' +
'</Student>' +
'<Student DateOfBirth="1993-09-10" Gender="F" Name="&#x00C9;mily" />' +
'</Students>';
 
var list = xmlstr.match(/<Student .*? \/>/g);
var output = '';
for (var i = 0; i < list.length; i++) {
if (i > 0) {
output += ', ';
}
var tmp = list[i].match(/Name="(.*?)"/);
output += tmp[1];
}
 
// Bounce it through a HTML element to handle Unicode for us
var l = document.createElement('p');
l.innerHTML = output;
alert(l.innerHTML);
 
Works with: Mozilla Firefox version 3.6

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

 
var xmlstr = '<Students>' +
'<Student Name="April" Gender="F" DateOfBirth="1989-01-02" />' +
'<Student Name="Bob" Gender="M" DateOfBirth="1990-03-04" />' +
'<Student Name="Chad" Gender="M" DateOfBirth="1991-05-06" />' +
'<Student Name="Dave" Gender="M" DateOfBirth="1992-07-08">' +
'<Pet Type="dog" Name="Rover" />' +
'</Student>' +
'<Student DateOfBirth="1993-09-10" Gender="F" Name="&#x00C9;mily" />' +
'</Students>';
var xml = XML(xmlstr);
var list = xml.Student.@Name;
var output = '';
for (var i = 0; i < list.length(); i++) {
if (i > 0) {
output += ', ';
}
output += list[i];
}
 
alert(output);
 


[edit] Lasso

Task calls for a result not using Xpaths. Thus two examples shown. First uses Xpath, second uses regular expression.

// makes extracting attribute values easier
define xml_attrmap(in::xml_namedNodeMap_attr) => {
local(out = map)
with attr in #in
do #out->insert(#attr->name = #attr->value)
return #out
}
 
local(
text = '<Students>
<Student Name="April" Gender="F" DateOfBirth="1989-01-02" />
<Student Name="Bob" Gender="M" DateOfBirth="1990-03-04" />
<Student Name="Chad" Gender="M" DateOfBirth="1991-05-06" />
<Student Name="Dave" Gender="M" DateOfBirth="1992-07-08">
<Pet Type="dog" Name="Rover" />
</Student>
<Student DateOfBirth="1993-09-10" Gender="F" Name="&#x00C9;mily" />
</Students>
',
xml = xml(#text)
)
 
local(
students = #xml -> extract('//Student'),
names = array
)
with student in #students do {
#names -> insert(xml_attrmap(#student -> attributes) -> find('Name'))
}
#names -> join('<br />')
 
// not using XML or Xpath
'<hr />'
local(
regexp = regexp(-find = `<Student.*?Name="(.*?)"`, -input = #text, -ignoreCase),
names = array
)
 
while( #regexp -> find) => {
#names -> insert(#regexp -> matchstring(1))
}
#names -> join('<br />')

Output:

April
Bob
Chad
Dave
Émily
-----------
April
Bob
Chad
Dave
Émily

[edit] Lua

Requires LuaExpat

 
require 'lxp'
data = [[<Students>
<Student Name="April" Gender="F" DateOfBirth="1989-01-02" />
<Student Name="Bob" Gender="M" DateOfBirth="1990-03-04" />
<Student Name="Chad" Gender="M" DateOfBirth="1991-05-06" />
<Student Name="Dave" Gender="M" DateOfBirth="1992-07-08">
<Pet Type="dog" Name="Rover" />
</Student>
<Student DateOfBirth="1993-09-10" Gender="F" Name="&#x00C9;mily" />
</Students>]]
 
p = lxp.new({StartElement = function (parser, name, attr)
if name == 'Student' and attr.Name then
print(attr.Name)
end
end})
 
p:parse(data)
p:close()
 

Output:

April 
Bob 
Chad 
Dave 
Émily

[edit] Mathematica

Column[Cases[Import["test.xml","XML"],Rule["Name", n_ ] -> n,Infinity]]

Output:

April 
Bob 
Chad 
Dave 
Émily

[edit] newLISP

 
(set 'xml-input "<Students>
<Student Name=\"April\" Gender=\"F\" DateOfBirth=\"1989-01-02\" />
<Student Name=\"Bob\" Gender=\"M\" DateOfBirth=\"1990-03-04\" />
<Student Name=\"Chad\" Gender=\"M\" DateOfBirth=\"1991-05-06\" />
<Student Name=\"Dave\" Gender=\"M\" DateOfBirth=\"1992-07-08\">
<Pet Type=\"dog\" Name=\"Rover\" />
</Student>
<Student DateOfBirth=\"1993-09-10\" Gender=\"F\" Name=\"&#x00C9;mily\" />
</Students>"
)
 
(set 'sexp (xml-parse xml-input))
 
(dolist (x (ref-all "Name" sexp))
(if (= (length x) 6)
(println (last (sexp (chop x))))))
 

Output:

April 
Bob 
Chad 
Dave 
Émily

[edit] Nimrod

import xmlparser, xmltree, streams
 
let doc = newStringStream """<Students>
<Student Name="April" Gender="F" DateOfBirth="1989-01-02" />
<Student Name="Bob" Gender="M" DateOfBirth="1990-03-04" />
<Student Name="Chad" Gender="M" DateOfBirth="1991-05-06" />
<Student Name="Dave" Gender="M" DateOfBirth="1992-07-08">
<Pet Type="dog" Name="Rover" />
</Student>
<Student DateOfBirth="1993-09-10" Gender="F" Name="&#x00C9;mily" />
</Students>"""
 
for i in doc.parseXml.findAll "Student":
echo i.attr "Name"

Output:

April
Bob
Chad
Dave
Émily

[edit] Objeck

 
use XML;
 
bundle Default {
class Test {
function : Main(args : String[]) ~ Nil {
in := String->New();
in->Append("<Students>");
in->Append("<Student Name=\"April\" Gender=\"F\" DateOfBirth=\"1989-01-02\" />");
in->Append("<Student Name=\"Bob\" Gender=\"M\" DateOfBirth=\"1990-03-04\" />");
in->Append("<Student Name=\"Chad\" Gender=\"M\" DateOfBirth=\"1991-05-06\" />");
in->Append("<Student Name=\"Dave\" Gender=\"M\" DateOfBirth=\"1992-07-08\">");
in->Append("<Pet Type=\"dog\" Name=\"Rover\" />");
in->Append("</Student>");
in->Append("<Student DateOfBirth=\"1993-09-10\" Gender=\"F\" Name=\"&#x00C9;mily\" /></Students>");
 
parser := XmlParser->New(in);
if(parser->Parse()) {
root := parser->GetRoot();
children := root->GetChildren("Student");
each(i : children) {
child : XMLElement := children->Get(i)->As(XMLElement);
XMLElement->DecodeString(child->GetAttribute("Name"))->PrintLine();
};
};
}
}
}
 

[edit] OCaml

from the toplevel using the library xml-light:

# #directory "+xml-light" (* or maybe "+site-lib/xml-light" *) ;;
# #load "xml-light.cma" ;;
 
# let x = Xml.parse_string "
<Students>
<Student Name='April' Gender='F' DateOfBirth='1989-01-02' />
<Student Name='Bob' Gender='M' DateOfBirth='1990-03-04' />
<Student Name='Chad' Gender='M' DateOfBirth='1991-05-06' />
<Student Name='Dave' Gender='M' DateOfBirth='1992-07-08'>
<Pet Type='dog' Name='Rover' />
</Student>
<Student DateOfBirth='1993-09-10' Gender='F' Name='&#x00C9;mily' />
</Students>"

in
Xml.iter (function
Xml.Element ("Student", attrs, _) ->
List.iter (function ("Name", name) -> print_endline name | _ -> ()) attrs
| _ -> ()) x
;;
April
Bob
Chad
Dave
&#x00C9;mily
- : unit = ()

Another solution using the library xmlm:

#directory "+xmlm"
#load "xmlm.cmo"
open Xmlm
 
let str = "
<Students>
<Student Name='April' Gender='F' DateOfBirth='1989-01-02' />
<Student Name='Bob' Gender='M' DateOfBirth='1990-03-04' />
<Student Name='Chad' Gender='M' DateOfBirth='1991-05-06' />
<Student Name='Dave' Gender='M' DateOfBirth='1992-07-08'>
<Pet Type='dog' Name='Rover' />
</Student>
<Student DateOfBirth='1993-09-10' Gender='F' Name='&#x00C9;mily' />
</Students>"

 
 
let xi = make_input(`String(0, str))
 
let () =
while not(eoi xi) do
match Xmlm.input xi with
| `El_start ((_, "Student"), attrs) ->
List.iter (function ((_, "Name"), name) -> print_endline name | _ -> ()) attrs
| _ -> ()
done

using the ocaml expat wrapper:

open Expat
 
let xml_str = "
<Students>
<Student Name='April' Gender='F' DateOfBirth='1989-01-02' />
<Student Name='Bob' Gender='M' DateOfBirth='1990-03-04' />
<Student Name='Chad' Gender='M' DateOfBirth='1991-05-06' />
<Student Name='Dave' Gender='M' DateOfBirth='1992-07-08'>
<Pet Type='dog' Name='Rover' />
</Student>
<Student DateOfBirth='1993-09-10' Gender='F' Name='&#x00C9;mily' />
</Students>"

 
let () =
let p = parser_create None in
set_start_element_handler p
(fun tag attrs ->
if tag = "Student" then
List.iter (function ("Name", name) -> print_endline name | _ -> ()) attrs
);
parse p xml_str;
final p;

[edit] OpenEdge/Progress

The following example uses the X-DOCUMENT DOM parser. For larger documents the SAX parser is recommended.

 
DEF VAR lcc AS LONGCHAR.
DEF VAR hxdoc AS HANDLE.
DEF VAR hxstudents AS HANDLE.
DEF VAR hxstudent AS HANDLE.
DEF VAR hxname AS HANDLE.
DEF VAR ii AS INTEGER EXTENT 2.
DEF VAR cstudents AS CHARACTER.
 
lcc = '<Students>'
+ '<Student Name="April" Gender="F" DateOfBirth="1989-01-02" />'
+ '<Student Name="Bob" Gender="M" DateOfBirth="1990-03-04" />'
+ '<Student Name="Chad" Gender="M" DateOfBirth="1991-05-06" />'
+ '<Student Name="Dave" Gender="M" DateOfBirth="1992-07-08">'
+ '<Pet Type="dog" Name="Rover" />'
+ '</Student>'
+ '<Student DateOfBirth="1993-09-10" Gender="F" Name="&#x00C9;mily" />'
+ '</Students>'.
 
CREATE X-DOCUMENT hxdoc.
hxdoc:LOAD( 'LONGCHAR', lcc, FALSE ).
 
DO ii[1] = 1 TO hxdoc:NUM-CHILDREN:
CREATE X-NODEREF hxstudents.
hxdoc:GET-CHILD( hxstudents, ii[1] ).
IF hxstudents:NAME = 'Students' THEN DO ii[2] = 1 TO hxstudents:NUM-CHILDREN:
CREATE X-NODEREF hxstudent.
hxstudents:GET-CHILD( hxstudent, ii[2] ).
IF hxstudent:NAME = 'Student' THEN
cstudents = cstudents + hxstudent:GET-ATTRIBUTE( 'Name' ) + '~n'.
DELETE OBJECT hxstudent.
END.
DELETE OBJECT hxstudents.
END.
DELETE OBJECT hxdoc.
 
MESSAGE cstudents VIEW-AS ALERT-BOX.

Output:

---------------------------
Message
---------------------------
April
Bob
Chad
Dave
Émily
---------------------------
OK   
---------------------------

[edit] Oz

declare
[XMLParser] = {Module.link ['x-oz://system/xml/Parser.ozf']}
Parser = {New XMLParser.parser init}
 
Data =
"<Students>"
#" <Student Name=\"April\" Gender=\"F\" DateOfBirth=\"1989-01-02\" />"
#" <Student Name=\"Bob\" Gender=\"M\" DateOfBirth=\"1990-03-04\" />"
#" <Student Name=\"Chad\" Gender=\"M\" DateOfBirth=\"1991-05-06\" />"
#" <Student Name=\"Dave\" Gender=\"M\" DateOfBirth=\"1992-07-08\">"
#" <Pet Type=\"dog\" Name=\"Rover\" />"
#" </Student>"
#" <Student DateOfBirth=\"1993-09-10\" Gender=\"F\" Name=\"&#x00C9;mily\" />"
#"</Students>"
 
fun {IsStudentElement X}
case X of element(name:'Student' ...) then true
else false
end
end
 
fun {GetStudentName element(attributes:As ...)}
[NameAttr] = {Filter As fun {$ attribute(name:N ...)} N == 'Name' end}
in
NameAttr.value
end
 
[StudentsDoc] = {Parser parseVS(Data $)}
Students = {Filter StudentsDoc.children IsStudentElement}
StudentNames = {Map Students GetStudentName}
in
{ForAll StudentNames System.showInfo}

[edit] Perl

use XML::Simple;
 
my $ref = XMLin('<Students>
<Student Name="April" Gender="F" DateOfBirth="1989-01-02" />
<Student Name="Bob" Gender="M" DateOfBirth="1990-03-04" />
<Student Name="Chad" Gender="M" DateOfBirth="1991-05-06" />
<Student Name="Dave" Gender="M" DateOfBirth="1992-07-08">
<Pet Type="dog" Name="Rover" />
</Student>
<Student DateOfBirth="1993-09-10" Gender="F" Name="&#x00C9;mily" />
</Students>'
);
 
print join( "\n", map { $_->{'Name'} } @{$ref->{'Student'}});

[edit] Perl 6

Library: XML
use v6;
use XML;
 
my $xml = from-xml '<Students>
<Student Name="April" Gender="F" DateOfBirth="1989-01-02" />
<Student Name="Bob" Gender="M" DateOfBirth="1990-03-04" />
<Student Name="Chad" Gender="M" DateOfBirth="1991-05-06" />
<Student Name="Dave" Gender="M" DateOfBirth="1992-07-08">
<Pet Type="dog" Name="Rover" />
</Student>
<Student DateOfBirth="1993-09-10" Gender="F" Name="&#x00C9;mily" />
</Students>'
;
 
say .<Name> for $xml.nodes.grep(*.name eq 'Student')

[edit] PHP

<?php
$data = '<Students>
<Student Name="April" Gender="F" DateOfBirth="1989-01-02" />
<Student Name="Bob" Gender="M" DateOfBirth="1990-03-04" />
<Student Name="Chad" Gender="M" DateOfBirth="1991-05-06" />
<Student Name="Dave" Gender="M" DateOfBirth="1992-07-08">
<Pet Type="dog" Name="Rover" />
</Student>
<Student DateOfBirth="1993-09-10" Gender="F" Name="&#x00C9;mily" />
</Students>'
;
$xml = new XMLReader();
$xml->xml( $data );
while ( $xml->read() )
if ( XMLREADER::ELEMENT == $xml->nodeType && $xml->localName == 'Student' )
echo $xml->getAttribute('Name') . "\n";
?>

[edit] PicoLisp

(load "@lib/xm.l")
 
(mapcar
'((L) (attr L 'Name))
(body (in "file.xml" (xml))) )

Output:

-> ("April" "Bob" "Chad" "Dave" "Émily")

[edit] Pike

 
string in = "<Students>\n"
" <Student Name=\"April\" Gender=\"F\" DateOfBirth=\"1989-01-02\" />\n"
" <Student Name=\"Bob\" Gender=\"M\" DateOfBirth=\"1990-03-04\" />\n"
" <Student Name=\"Chad\" Gender=\"M\" DateOfBirth=\"1991-05-06\" />\n"
" <Student Name=\"Dave\" Gender=\"M\" DateOfBirth=\"1992-07-08\">\n"
" <Pet Type=\"dog\" Name=\"Rover\" />\n"
" </Student>\n"
" <Student DateOfBirth=\"1993-09-10\" Gender=\"F\" Name=\"&#x00C9;mily\" />\n"
"</Students>\n";
 
object s = Parser.XML.Tree.simple_parse_input(in);
 
array collect = ({});
s->walk_inorder(lambda(object node)
{
if (node->get_tag_name() == "Student")
collect += ({ node->get_attributes()->Name });
});
write("%{%s\n%}", collect);

Output:

April
Bob
Chad
Dave
Émily

[edit] PowerShell

 
[xml]$xml = @'
<Students>
<Student Name="April" Gender="F" DateOfBirth="1989-01-02" />
<Student Name="Bob" Gender="M" DateOfBirth="1990-03-04" />
<Student Name="Chad" Gender="M" DateOfBirth="1991-05-06" />
<Student Name="Dave" Gender="M" DateOfBirth="1992-07-08">
<Pet Type="dog" Name="Rover" />
</Student>
<Student DateOfBirth="1993-09-10" Gender="F" Name="&#x00C9;mily" />
</Students>
'
@
 
foreach ($node in $xml.DocumentElement.ChildNodes) {$node.Name}
 
 
 
 

[edit] OpenEdge ABL/Progress 4GL

 
/** ==== Definitions ===== **/
DEFINE VARIABLE chXMLString AS LONGCHAR NO-UNDO.
DEFINE TEMP-TABLE ttStudent NO-UNDO XML-NODE-NAME 'Student'
FIELD StudentName AS CHARACTER XML-NODE-TYPE 'attribute' XML-NODE-NAME 'Name' LABEL 'Name'
FIELD Gender AS CHARACTER XML-NODE-TYPE 'attribute' XML-NODE-NAME 'Gender' LABEL 'Gender'
FIELD DateOfBirth AS CHARACTER XML-NODE-TYPE 'attribute' XML-NODE-NAME 'DateOfBirth' LABEL 'Date Of Birth'.
DEFINE DATASET dsStudents XML-NODE-NAME 'Students' FOR ttStudent.
 
/** ==== Main block ====**/
 
/** ASSIGN the XML string with the XML data.. **/
chXMLString = '<Students>~
<Student Name="April" Gender="F" DateOfBirth="1989-01-02" />~
<Student Name="Bob" Gender="M" DateOfBirth="1990-03-04" />~
<Student Name="Chad" Gender="M" DateOfBirth="1991-05-06" />~
<Student Name="Dave" Gender="M" DateOfBirth="1992-07-08">~
<Pet Type="dog" Name="Rover" />~
</Student>~
<Student DateOfBirth="1993-09-10" Gender="F" Name="&#x00C9;mily" />~
</Students>'.
 
/** Read the string into the dataset...**/
DATASET dsStudents:READ-XML('LONGCHAR', chXMLString, 'EMPTY',?,?).
 
/** Loop thought each temp-table record to produce the results...**/
FOR EACH ttStudent:
DISPLAY ttStudent.StudentName.
END.
 
 

[edit] PureBasic

Uses a PureBasic XML library (which is linked automatically) that is based on the library expat XML parser licensed under the MIT license.

Define studentNames.String, src$
 
src$ = "<Students>"
src$ + "<Student Name='April' Gender='F' DateOfBirth='1989-01-02' />"
src$ + "<Student Name='Bob' Gender='M' DateOfBirth='1990-03-04' />"
src$ + "<Student Name='Chad' Gender='M' DateOfBirth='1991-05-06' />"
src$ + "<Student Name='Dave' Gender='M' DateOfBirth='1992-07-08'>"
src$ + "<Pet Type='dog' Name='Rover' />"
src$ + "</Student>"
src$ + "<Student DateOfBirth='1993-09-10' Gender='F' Name='&#x00C9;mily' />"
src$ + "</Students>"
 
;This procedure is generalized to match any attribute of any normal element's node name
;i.e. get_values(MainXMLNode(0),"Pet","Type",@petName.String) and displaying petName\s
;would display "dog".
Procedure get_values(*cur_node, nodeName$, attribute$, *valueResults.String)
;If nodeName$ and attribute$ are matched then the value
;will be added to the string structure pointed to by *valueResults .
Protected result$
 
While *cur_node
If XMLNodeType(*cur_node) = #PB_XML_Normal
 
result$ = GetXMLNodeName(*cur_node)
If result$ = nodeName$
If ExamineXMLAttributes(*cur_node)
While NextXMLAttribute(*cur_node)
If XMLAttributeName(*cur_node) = attribute$
If *valueResults <> #Null
*valueResults\s + XMLAttributeValue(*cur_node) + Chr(13) ;value + carriage-return
EndIf
EndIf
Wend
EndIf
EndIf
 
EndIf
 
get_values(ChildXMLNode(*cur_node), nodeName$, attribute$, *valueResults)
*cur_node = NextXMLNode(*cur_node)
Wend
EndProcedure
 
CatchXML(0,@src$,Len(src$))
 
If IsXML(0)
get_values(MainXMLNode(0), "Student", "Name",@studentNames)
MessageRequester("Student Names", studentNames\s)
FreeXML(0)
EndIf

Sample output:

April
Bob
Chad
Dave
Émily

[edit] Python

import xml.dom.minidom
 
doc = """<Students>
<Student Name="April" Gender="F" DateOfBirth="1989-01-02" />
<Student Name="Bob" Gender="M" DateOfBirth="1990-03-04" />
<Student Name="Chad" Gender="M" DateOfBirth="1991-05-06" />
<Student Name="Dave" Gender="M" DateOfBirth="1992-07-08">
<Pet Type="dog" Name="Rover" />
</Student>
<Student DateOfBirth="1993-09-10" Gender="F" Name="&#x00C9;mily" />
</Students>"""

 
doc = xml.dom.minidom.parseString(doc)
 
for i in doc.getElementsByTagName("Student"):
print i.getAttribute("Name")

[edit] R

Library: XML
library(XML)
#Read in XML string
str <- readLines(tc <- textConnection('<Students>
<Student Name="April" Gender="F" DateOfBirth="1989-01-02" />
<Student Name="Bob" Gender="M" DateOfBirth="1990-03-04" />
<Student Name="Chad" Gender="M" DateOfBirth="1991-05-06" />
<Student Name="Dave" Gender="M" DateOfBirth="1992-07-08">
<Pet Type="dog" Name="Rover" />
</Student>
<Student DateOfBirth="1993-09-10" Gender="F" Name="&#x00C9;mily" />
</Students>'))
close(tc)
str
[1] "<Students>"                                                                 
[2] "  <Student Name=\"April\" Gender=\"F\" DateOfBirth=\"1989-01-02\" />"       
[3] "  <Student Name=\"Bob\" Gender=\"M\"  DateOfBirth=\"1990-03-04\" />"        
[4] "  <Student Name=\"Chad\" Gender=\"M\"  DateOfBirth=\"1991-05-06\" />"       
[5] "  <Student Name=\"Dave\" Gender=\"M\"  DateOfBirth=\"1992-07-08\">"         
[6] "    <Pet Type=\"dog\" Name=\"Rover\" />"                                    
[7] "  </Student>"                                                               
[8] "  <Student DateOfBirth=\"1993-09-10\" Gender=\"F\" Name=\"Émily\" />"
[9] "</Students>"
#Convert to an XML tree
xmltree <- xmlTreeParse(str)
 
#Retrieve the students, and how many there are
students <- xmltree$doc$children$Students
nstudents <- length(students)
 
#Get each of their names
studentsnames <- character(nstudents)
for(i in 1:nstudents)
{
this.student <- students$children[i]$Student
studentsnames[i] <- this.student$attributes["Name"]
}
 
#Change the encoding so that Emily displays correctly
Encoding(studentsnames) <- "UTF-8"
studentsnames
[1] "April" "Bob"   "Chad"  "Dave"  "Émily"i

[edit] Racket

 
#lang racket
(require xml xml/path)
 
(define input
#<<END
<Students>
<Student Name="April" Gender="F" DateOfBirth="1989-01-02" />
<Student Name="Bob" Gender="M" DateOfBirth="1990-03-04" />
<Student Name="Chad" Gender="M" DateOfBirth="1991-05-06" />
<Student Name="Dave" Gender="M" DateOfBirth="1992-07-08">
<Pet Type="dog" Name="Rover" />
</Student>
<Student DateOfBirth="1993-09-10" Gender="F" Name="&#x00C9;mily" />
</Students>
END
)
 
(define students
(xml->xexpr
(document-element
(read-xml (open-input-string input)))))
 
(se-path*/list '(Student #:Name) students)
 

[edit] Rascal

import lang::xml::DOM;
 
public void getNames(loc a){
D = parseXMLDOM(readFile(a));
visit(D){
case element(_,"Student",[_*,attribute(_,"Name", x),_*]): println(x);
};
}

Output:

rascal>getNames(|file:///Users/.../Desktop/xmlinput.xml|)
April
Bob
Chad
Dave
Émily
ok

[edit] REBOL

rebol [
Title: "XML Reading"
Author: oofoe
Date: 2009-12-08
URL: http://rosettacode.org/wiki/XML_Reading
]

 
xml: {
<Students>
<Student Name="April" Gender="F" DateOfBirth="1989-01-02" />
<Student Name="Bob" Gender="M" DateOfBirth="1990-03-04" />
<Student Name="Chad" Gender="M" DateOfBirth="1991-05-06" />
<Student Name="Dave" Gender="M" DateOfBirth="1992-07-08">
<Pet Type="dog" Name="Rover" />
</Student>
<Student DateOfBirth="1993-09-10" Gender="F" Name="&#x00C9;mily" />
</Students>
}
 
; REBOL has a simple built-in XML parser. It's not terribly fancy, but
; it's easy to use. It converts the XML into a nested list of blocks
; which can be accessed using standard REBOL path operators. The only
; annoying part (in this case) is that it does try to preserve
; whitespace, so some of the parsed elements are just things like line
; endings and whatnot, which I need to ignore.
 
; Once I have drilled down to the individual student records, I can
; just use the standard REBOL 'select' to locate the requested
; property.
 
data: parse-xml xml
students: data/3/1/3 ; Drill down to student records.
foreach student students [
if block! = type? student [ ; Ignore whitespace elements.
print select student/2 "Name"
]
]

Output:

April
Bob
Chad
Dave
Émily

[edit] REXX

[edit] version 1

/*REXX program to extract student names from an  XML string(s).         */
g.=
g.1='<Students> '
g.2=' <Student Name="April" Gender="F" DateOfBirth="1989-01-02" /> '
g.3=' <Student Name="Bob" Gender="M" DateOfBirth="1990-03-04" /> '
g.4=' <Student Name="Chad" Gender="M" DateOfBirth="1991-05-06" /> '
g.5=' <Student Name="Dave" Gender="M" DateOfBirth="1992-07-08"> '
g.6=' <Pet Type="dog" Name="Rover" /> '
g.7=' </Student> '
g.8=' <Student DateOfBirth="1993-09-10" Gender="F" Name="&#x00C9;mily" /> '
g.9='</Students> '
 
do j=1 while g.j\==''
g.j=space(g.j)
parse var g.j 'Name="' studname '"'
if studname\=='' then say studname
end /*j*/
/*stick a fork in it, we're done.*/

output

April
Bob
Chad
Dave
Rover
&#x00C9;mily

[edit] version 2

This REXX version hangles more HTML tags for output.

/*REXX program to extract student names from an  XML string(s).         */
g.=
g.1='<Students> '
g.2=' <Student Name="April" Gender="F" DateOfBirth="1989-01-02" /> '
g.3=' <Student Name="Bob" Gender="M" DateOfBirth="1990-03-04" /> '
g.4=' <Student Name="Chad" Gender="M" DateOfBirth="1991-05-06" /> '
g.5=' <Student Name="Dave" Gender="M" DateOfBirth="1992-07-08"> '
g.6=' <Pet Type="dog" Name="Rover" / > '
g.7=' </Student> '
g.8=' <Student DateOfBirth="1993-09-10" Gender="F" Name="&#x00C9;mily" /> '
g.9='</Students> '
 
do j=1 while g.j\==''
g.j=space(g.j)
parse var g.j 'Name="' studname '"'
if studname=='' then iterate
if pos('&',studname)\==0 then studname=xmlTranE(studname)
say studname
end /*j*/
exit /*stick a fork in it, we're done.*/
/*──────────────────────────────────XML_ subroutine─────────────────────*/
xml_: parse arg ,_ /*tran an XML entity (&xxxx;) */
xmlEntity! = '&'_";"
if pos(xmlEntity!,x)\==0 then x=changestr(xmlEntity!,x,arg(1))
if left(_,2)=='#x' then do
xmlEntity!='&'left(_,3)translate(substr(_,4))";"
x=changestr(xmlEntity!,x,arg(1))
end
return x
/*──────────────────────────────────XMLTRANE subroutine─────────────────*/
xmlTranE: procedure; parse arg x /*Following are most of the chars in*/
/*the DOS (under Windows) codepage. */
x=XML_('♥',"hearts")  ; x=XML_('â',"ETH")  ; x=XML_('ƒ',"fnof")  ; x=XML_('═',"boxH")
x=XML_('♦',"diams")  ; x=XML_('â','#x00e2') ; x=XML_('á',"aacute"); x=XML_('╬',"boxVH")
x=XML_('♣',"clubs")  ; x=XML_('â','#x00e9') ; x=XML_('á','#x00e1'); x=XML_('╧',"boxHu")
x=XML_('♠',"spades")  ; x=XML_('ä',"auml")  ; x=XML_('í',"iacute"); x=XML_('╨',"boxhU")
x=XML_('♂',"male")  ; x=XML_('ä','#x00e4') ; x=XML_('í','#x00ed'); x=XML_('╤',"boxHd")
x=XML_('♀',"female")  ; x=XML_('à',"agrave") ; x=XML_('ó',"oacute"); x=XML_('╥',"boxhD")
x=XML_('☼',"#x263c")  ; x=XML_('à','#x00e0') ; x=XML_('ó','#x00f3'); x=XML_('╙',"boxUr")
x=XML_('↕',"UpDownArrow")  ; x=XML_('å',"aring")  ; x=XML_('ú',"uacute"); x=XML_('╘',"boxuR")
x=XML_('¶',"para")  ; x=XML_('å','#x00e5') ; x=XML_('ú','#x00fa'); x=XML_('╒',"boxdR")
x=XML_('§',"sect")  ; x=XML_('ç',"ccedil") ; x=XML_('ñ',"ntilde"); x=XML_('╓',"boxDr")
x=XML_('↑',"uarr")  ; x=XML_('ç','#x00e7') ; x=XML_('ñ','#x00f1'); x=XML_('╫',"boxVh")
x=XML_('↑',"uparrow")  ; x=XML_('ê',"ecirc")  ; x=XML_('Ñ',"Ntilde"); x=XML_('╪',"boxvH")
x=XML_('↑',"ShortUpArrow")  ; x=XML_('ê','#x00ea') ; x=XML_('Ñ','#x00d1'); x=XML_('┘',"boxul")
x=XML_('↓',"darr")  ; x=XML_('ë',"euml")  ; x=XML_('¿',"iquest"); x=XML_('┌',"boxdr")
x=XML_('↓',"downarrow")  ; x=XML_('ë','#x00eb') ; x=XML_('⌐',"bnot")  ; x=XML_('█',"block")
x=XML_('↓',"ShortDownArrow")  ; x=XML_('è',"egrave") ; x=XML_('¬',"not")  ; x=XML_('▄',"lhblk")
x=XML_('←',"larr")  ; x=XML_('è','#x00e8') ; x=XML_('½',"frac12"); x=XML_('▀',"uhblk")
x=XML_('←',"leftarrow")  ; x=XML_('ï',"iuml")  ; x=XML_('½',"half")  ; x=XML_('α',"alpha")
x=XML_('←',"ShortLeftArrow")  ; x=XML_('ï','#x00ef') ; x=XML_('¼',"frac14"); x=XML_('ß',"beta")
x=XML_('1c'x,"rarr")  ; x=XML_('î',"icirc")  ; x=XML_('¡',"iexcl") ; x=XML_('ß',"szlig")
x=XML_('1c'x,"rightarrow")  ; x=XML_('î','#x00ee') ; x=XML_('«',"laqru") ; x=XML_('ß','#x00df')
x=XML_('1c'x,"ShortRightArrow"); x=XML_('ì',"igrave") ; x=XML_('»',"raqru") ; x=XML_('Γ',"Gamma")
x=XML_('!',"excl")  ; x=XML_('ì','#x00ec') ; x=XML_('░',"blk12") ; x=XML_('π',"pi")
x=XML_('"',"apos")  ; x=XML_('Ä',"Auml")  ; x=XML_('▒',"blk14") ; x=XML_('Σ',"Sigma")
x=XML_('$',"dollar")  ; x=XML_('Ä','#x00c4') ; x=XML_('▓',"blk34") ; x=XML_('σ',"sigma")
x=XML_("'","quot")  ; x=XML_('Å',"Aring")  ; x=XML_('│',"boxv")  ; x=XML_('µ',"mu")
x=XML_('*',"ast")  ; x=XML_('Å','#x00c5') ; x=XML_('┤',"boxvl") ; x=XML_('τ',"tau")
x=XML_('/',"sol")  ; x=XML_('É',"Eacute") ; x=XML_('╡',"boxvL") ; x=XML_('Φ',"phi")
x=XML_(':',"colon")  ; x=XML_('É','#x00c9') ; x=XML_('╢',"boxVl") ; x=XML_('Θ',"Theta")
x=XML_('<',"lt")  ; x=XML_('æ',"aelig")  ; x=XML_('╖',"boxDl") ; x=XML_('δ',"delta")
x=XML_('=',"equals")  ; x=XML_('æ','#x00e6') ; x=XML_('╕',"boxdL") ; x=XML_('∞',"infin")
x=XML_('>',"gt")  ; x=XML_('Æ',"AElig")  ; x=XML_('╣',"boxVL") ; x=XML_('φ',"Phi")
x=XML_('?',"quest")  ; x=XML_('Æ','#x00c6') ; x=XML_('║',"boxV")  ; x=XML_('ε',"epsilon")
x=XML_('@',"commat")  ; x=XML_('ô',"ocirc")  ; x=XML_('╗',"boxDL") ; x=XML_('∩',"cap")
x=XML_('[',"lbrack")  ; x=XML_('ô','#x00f4') ; x=XML_('╝',"boxUL") ; x=XML_('≡',"equiv")
x=XML_('\',"bsol")  ; x=XML_('ö',"ouml")  ; x=XML_('╜',"boxUl") ; x=XML_('±',"plusmn")
x=XML_(']',"rbrack")  ; x=XML_('ö','#x00f6') ; x=XML_('╛',"boxuL") ; x=XML_('±',"pm")
x=XML_('^',"Hat")  ; x=XML_('ò',"ograve") ; x=XML_('┐',"boxdl") ; x=XML_('±',"PlusMinus")
x=XML_('`',"grave")  ; x=XML_('ò','#x00f2') ; x=XML_('└',"boxur") ; x=XML_('≥',"ge")
x=XML_('{',"lbrace")  ; x=XML_('û',"ucirc")  ; x=XML_('┴',"bottom"); x=XML_('≤',"le")
x=XML_('{',"lcub")  ; x=XML_('û','#x00fb') ; x=XML_('┴',"boxhu") ; x=XML_('÷',"div")
x=XML_('|',"vert")  ; x=XML_('ù',"ugrave") ; x=XML_('┬',"boxhd") ; x=XML_('÷',"divide")
x=XML_('|',"verbar")  ; x=XML_('ù','#x00f9') ; x=XML_('├',"boxvr") ; x=XML_('≈',"approx")
x=XML_('}',"rbrace")  ; x=XML_('ÿ',"yuml")  ; x=XML_('─',"boxh")  ; x=XML_('∙',"bull")
x=XML_('}',"rcub")  ; x=XML_('ÿ','#x00ff') ; x=XML_('┼',"boxvh") ; x=XML_('°',"deg")
x=XML_('Ç',"Ccedil")  ; x=XML_('Ö',"Ouml")  ; x=XML_('╞',"boxvR") ; x=XML_('·',"middot")
x=XML_('Ç','#x00c7')  ; x=XML_('Ö','#x00d6') ; x=XML_('╟',"boxVr") ; x=XML_('·',"middledot")
x=XML_('ü',"uuml")  ; x=XML_('Ü',"Uuml")  ; x=XML_('╚',"boxUR") ; x=XML_('·',"centerdot")
x=XML_('ü','#x00fc')  ; x=XML_('Ü','#x00dc') ; x=XML_('╔',"boxDR") ; x=XML_('·',"CenterDot")
x=XML_('é',"eacute")  ; x=XML_('¢',"cent")  ; x=XML_('╩',"boxHU") ; x=XML_('√',"radic")
x=XML_('é','#x00e9')  ; x=XML_('£',"pound")  ; x=XML_('╦',"boxHD") ; x=XML_('²',"sup2")
x=XML_('â',"acirc")  ; x=XML_('¥',"yen")  ; x=XML_('╠',"boxVR") ; x=XML_('■',"squart ")
return x

Some older REXXes don't have a changestr bif, so one is included here ──► CHANGESTR.REX.

output

April
Bob
Chad
Dave
Rover
Émily

[edit] Ruby

Library: REXML
require 'rexml/document'
include REXML
 
doc = Document.new(File.new("sample.xml"))
# or
# doc = Document.new(xml_string)
 
# without using xpath
doc.each_recursive do |node|
puts node.attributes["Name"] if node.name == "Student"
end
 
# using xpath
doc.each_element("*/Student") {|node| puts node.attributes["Name"]}

[edit] Run BASIC

' ------------------------------------------------------------------------
'XMLPARSER methods
 
'#handle ELEMENTCOUNT() - Return the number of child XML elements
'#handle KEY$() - Return the key as a string from an XML expression like <key>value</key>
'#handle VALUE$() - Return the value as a string from an XML expression like <key>value</key>
'#handle VALUEFORKEY$(keyExpr$) - Return the value for the specified tag key in keyExpr$
'#handle #ELEMENT(n) - Return the nth child-element XML element
'#handle #ELEMENT(nameExpr$) - Return the child-element XML element named by nameExpr$
'#handle ATTRIBCOUNT() - Return a count of attribute pairs; <a attrA="abc" attrB="def"> has two pairs
'#handle ATTRIBKEY$(n) - Return the key string of the nth attribute
'#handle ATTRIBVALUE$(n) - Return the value string of the nth attribute
'#handle ATTRIBVALUE$(n$) - Return the value string of the attribute with the key n$, or an empty string if it doesn't exist.
'#handle ISNULL() - Returns zero (or false)
'#handle DEBUG$() - Returns the string "Xmlparser"
' ------------------------------------------------------------------------
 
' The xml string
xml$ = "
<Students>
<Student Name=""April"" Gender=""F"" DateOfBirth=""1989-01-02"" />
<Student Name=""Bob"" Gender=""M"" DateOfBirth=""1990-03-04"" />
<Student Name=""Chad"" Gender=""M"" DateOfBirth=""1991-05-06"" />
<Student Name=""Dave"" Gender=""M"" DateOfBirth=""1992-07-08"">
<Pet Type=""dog"" Name=""Rover"" />
</Student>
<Student DateOfBirth=""1993-09-10"" Gender=""F"" Name=""&#x00C9;mily"" />
</Students>"
 
 
' Creates the xml handler, using the string
xmlparser #spies, xml$
 
' Uses elementCount() to know how many elements are in betweeb <spies>...</spies>
for count = 1 to #spies elementCount()
 
' Uses "count" to work through the elements, and assigns the element to the
' handle "#spy"
#spy = #spies #element(count)
 
' Prints the value, or inner text, of "#spy": Sam, Clover, & Alex
print count;" ";#spy value$();" ->";#spy ATTRIBVALUE$(1)
 
next count

[edit] Scala

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

val students =
<Students>
<Student Name="April" Gender="F" DateOfBirth="1989-01-02" />
<Student Name="Bob" Gender="M" DateOfBirth="1990-03-04" />
<Student Name="Chad" Gender="M" DateOfBirth="1991-05-06" />
<Student Name="Dave" Gender="M" DateOfBirth="1992-07-08">
<Pet Type="dog" Name="Rover" />
</Student>
<Student DateOfBirth="1993-09-10" Gender="F" Name="&#x00C9;mily" />
</Students>
 
students \ "Student" \\ "@Name" foreach println

[edit] Slate

Some lines in this example are too long (more than 80 characters). Please fix the code if it's possible and remove this message.

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

slate[1]> [ |tree|
 
tree: (Xml SimpleParser newOn: '<Students>
<Student Name="April" Gender="F" DateOfBirth="1989-01-02" />
<Student Name="Bob" Gender="M" DateOfBirth="1990-03-04" />
<Student Name="Chad" Gender="M" DateOfBirth="1991-05-06" />
<Student Name="Dave" Gender="M" DateOfBirth="1992-07-08">
<Pet Type="dog" Name="Rover" />
</Student>
<Student DateOfBirth="1993-09-10" Gender="F" Name="&#x00C9;mily" />
</Students>') parse.
tree name = 'Students' ifTrue: [(tree children select: #is: `er <- Xml Element)
do: [|:child| child name = 'Student' ifTrue: [inform: (child attributes at: 'Name' ifAbsent: ['Noname'])]]].
 
] do.
April
Bob
Chad
Dave
&#x00C9;mily
Nil

[edit] Tcl

Using
Library: tDOM
package require 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
Library: TclXML
package require xml
set parser [xml::parser -elementstartcommand elem]
proc elem {name attlist args} {
if {$name eq "Student"} {
puts [dict get $attlist Name]
}
}
$parser parse $xml

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

proc xml2list xml {
regsub -all {>\s*<} [string trim $xml " \n\t<>"] "\} \{" xml
set xml [string map {> "\} \{#text \{" < "\}\} \{"} $xml]
set res "" ;# string to collect the result
set stack {} ;# track open tags
set rest {}
foreach item "{$xml}" {
switch -regexp -- $item {
^# {append res "{[lrange $item 0 end]} " ; #text item}
^/ {
regexp {/(.+)} $item -> tagname ;# end tag
set expected [lindex $stack end]
set stack [lrange $stack 0 end-1]
append res "\}\} "
}
/$ { # singleton - start and end in one <> group
regexp {([^ ]+)( (.+))?/$} $item -> tagname - rest
set rest [lrange [string map {= " "} $rest] 0 end]
append res "{$tagname [list $rest] {}} "
}
default {
set tagname [lindex $item 0] ;# start tag
set rest [lrange [string map {= " "} $item] 1 end]
lappend stack $tagname
append res "\{$tagname [list $rest] \{"
}
}
}
string map {"\} \}" "\}\}"} [lindex $res 0] ;#"
}
proc deent str {
regsub -all {&\#x(.+?);} $str {\\u\1} str
subst -nocommands -novar $str
}
#----------------------- Testing the whole thing:
set xml {<Students>
<Student Name="April" Gender="F" DateOfBirth="1989-01-02" />
<Student Name="Bob" Gender="M" DateOfBirth="1990-03-04" />
<Student Name="Chad" Gender="M" DateOfBirth="1991-05-06" />
<Student Name="Dave" Gender="M" DateOfBirth="1992-07-08">
<Pet Type="dog" Name="Rover" />
</Student>
<Student DateOfBirth="1993-09-10" Gender="F" Name="&#x00C9;mily" /></Students>
}
foreach i [lindex [xml2list $xml] 2] {
if {[lindex $i 0] eq "Student"} {
foreach {att val} [lindex $i 1] {
if {$att eq "Name"} {puts [deent $val]}
}
}
}

[edit] TUSCRIPT

 
$$ MODE TUSCRIPT
MODE DATA
$$ SET xmldata =*
<Students>
<Student Name="April" Gender="F" DateOfBirth="1989-01-02" />
<Student Name="Bob" Gender="M" DateOfBirth="1990-03-04" />
<Student Name="Chad" Gender="M" DateOfBirth="1991-05-06" />
<Student Name="Dave" Gender="M" DateOfBirth="1992-07-08">
<Pet Type="dog" Name="Rover" />
</Student>
<Student DateOfBirth="1993-09-10" Gender="F" Name="Emily" />
</Students>
$$ MODE TUSCRIPT
COMPILE
LOOP x = xmldata
SET name=GET_TAG_NAME (x)
IF (name!="student") CYCLE
studentname=GET_ATTRIBUTE (x,"Name")
IF (studentname!="") PRINT studentname
ENDLOOP
ENDCOMPILE
 

Output:

April
Bob
Chad
Dave
Emily

[edit] TXR

This program shows how most of the information in the XML can be extracted with very little code, which doesn't actually understand XML. The name Émily is properly converted from the HTML/XML escape syntax.

<Students>
@(collect :vars (NAME GENDER YEAR MONTH DAY (PET_TYPE "none") (PET_NAME "")))
@ (cases)
<Student Name="@NAME" Gender="@GENDER" DateOfBirth="@YEAR-@MONTH-@DAY"@(skip)
@ (or)
<Student DateOfBirth="@YEAR-@MONTH-@DAY" Gender="@GENDER" Name="@NAME"@(skip)
@ (end)
@ (maybe)
<Pet Type="@PET_TYPE" Name="@PET_NAME" />
@ (end)
@(until)
</Students>
@(end)
@(output :filter :from_html)
NAME G DOB PET
@ (repeat)
@{NAME 12} @GENDER @YEAR-@MONTH-@DAY @PET_TYPE @PET_NAME
@ (end)
@(end)

Sample run:

$ txr students.txr students.xml
NAME         G DOB        PET
April        F 1989-01-02 none 
Bob          M 1990-03-04 none 
Chad         M 1991-05-06 none 
Dave         M 1992-07-08 dog Rover
Émily        F 1993-09-10 none

To obtain the output specified in this task, we can simply reduce the @(output) block to this:

@(output :filter :from_html)
@NAME
@(end)
April
Bob
Chad
Dave
Émily

[edit] Vedit macro language

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

Repeat(ALL) {
Search("<Student|X", ERRBREAK)
#1 = Cur_Pos
Match_Paren()
if (Search_Block(/Name=|{",'}/, #1, Cur_Pos, BEGIN+ADVANCE+NOERR+NORESTORE)==0) { Continue }
#2 = Cur_Pos
Search(/|{"
,'}/)
Type_Block(#2, Cur_Pos)
Type_Newline
}

Output:

April
Bob
Chad
Dave
Émily

[edit] Visual Basic .NET

Dim xml = <Students>
<Student Name="April"/>
<Student Name="Bob"/>
<Student Name="Chad"/>
<Student Name="Dave"/>
<Student Name="Emily"/>
</Students>
 
Dim names = (From node In xml...<Student> Select node.@Name).ToArray
 
For Each name In names
Console.WriteLine(name)
Next

[edit] XPL0

code ChOut=8, CrLf=9;   \intrinsic routines
string 0; \use zero-terminated strings
 
func StrLen(A); \Return number of characters in an ASCIIZ string
char A;
int I;
for I:= 0 to -1>>1-1 do
if A(I) = 0 then return I;
 
func StrFind(A, B); \Search for ASCIIZ string A in string B
\Returns address of first occurrence of string A in B, or zero if A is not found
char A, B; \strings to be compared
int LA, LB, I, J;
[LA:= StrLen(A);
LB:= StrLen(B);
for I:= 0 to LB-LA do
[for J:= 0 to LA-1 do
if A(J) # B(J+I) then J:= LA+1;
if J = LA then return B+I; \found
];
return 0;
];
 
char XML, P;
[XML:= "<Students>
<Student Name=^"April^" Gender=^"F^" DateOfBirth=^"1989-01-02^" />
<Student Name=^"Bob^" Gender=^"M^" DateOfBirth=^"1990-03-04^" />
<Student Name=^"Chad^" Gender=^"M^" DateOfBirth=^"1991-05-06^" />
<Student Name=^"Dave^" Gender=^"M^" DateOfBirth=^"1992-07-08^">
<Pet Type=^"dog^" Name=^"Rover^" />
</Student>
<Student DateOfBirth=^"1993-09-10^" Gender=^"F^" Name=^"&#x00C9;mily^" />
</Students>";
P:= XML;
loop [P:= StrFind("<Student ", P);
if P=0 then quit;
P:= StrFind("Name=", P);
if P=0 then quit;
P:= P + StrLen("Name=x");
repeat ChOut(0, P(0));
P:= P+1;
until P(0) = ^";
CrLf(0);
];
]
Output:
April
Bob
Chad
Dave
Émily
Personal tools
Namespaces

Variants
Actions
Community
Explore
Misc
Toolbox