3016502

Module 2: Selecting and Navigating Nodes Using XPath Contents Overview

1

Introducing XPath

2

Accessing Node Information

9

Lab 2.1: Accessing Node Information

17

Navigating a Document Using Location Paths21 Using Operators and Functions in Location Paths 35 Lab 2.2: Selecting and Navigating Nodes Using XPath

45

Review

53

Information in this document is subject to change without notice. The names of companies, products, people, characters, and/or data mentioned herein are fictitious and are in no way intended to represent any real individual, company, product, or event, unless otherwise noted. Complying with all applicable copyright laws is the responsibility of the user. No part of this document may be reproduced or transmitted in any form or by any means, electronic or mechanical, for any purpose, without the express written permission of Microsoft Corporation. If, however, your only means of access is electronic, permission to print one copy is hereby granted. Microsoft may have patents, patent applications, trademarks, copyrights, or other intellectual property rights covering subject matter in this document. Except as expressly provided in any written license agreement from Microsoft, the furnishing of this document does not give you any license to these patents, trademarks, copyrights, or other intellectual property.  2001 Microsoft Corporation. All rights reserved. Microsoft, ActiveX, BackOffice, Jscript, MSDN, MS-DOS, PowerPoint, SQL Server, Visual Basic, Visual C++, Visual InterDev, Windows, Windows Media Player, and Windows NT are either registered trademarks or trademarks of Microsoft Corporation in the U.S.A. and/or other countries. Other product and company names mentioned herein may be the trademarks of their respective owners.

Module 2: Selecting and Navigating Nodes Using XPath

1

Overview

Introducing XPath


Navigating a Document Using Location Paths

Using Operators and Functions in Location Paths

In this module, you will learn about the XML Path Language (XPath), a language that provides a standard syntax for identifying nodes in an XML document. This module describes the XPath language, and shows you how to use XPath to access nodes in an XML document. After completing this module, you will be able to:

Describe how to use XPath in XML-based applications.

Describe the XPath data model.

Use XPath expressions within the Document Object Model (DOM) methods selectNodes() and selectSingleNode().

Write XPath location paths to select specific nodes from an XML document.

Write conditional expressions in XPath.

Use XPath operators and functions to write more sophisticated expressions.

2


Introducing XPath

What Is XPath?

Why Use XPath?

Selecting XML Nodes in the DOM Using XPath

Demonstration: Accessing XML Nodes Using XPath

XPath is a standard language for locating nodes and data in an XML document. In this section, you will learn how various technologies make use of XPath. You will also learn how to combine XPath with Document Object Model (DOM) methods to access data from an XML document.


3

What Is XPath?

XPath maps an XML document to a tree of nodes

Use XPath expressions to identify, select, and manipulate nodes in an XML hierarchy

Use location paths to select nodes

XPath operators and functions

When working with XML, you typically need to select and manipulate nodes of an XML document programmatically. To meet this need, the World Wide Web Consortium (W3C) has defined XPath as a standard language for selecting individual nodes or groups of nodes in an XML document.

Mapping XML Documents The XPath data model maps an XML document to a tree of standard node types: root, element, attribute, text, comment, processing-instruction, and namespace nodes. The mapping rules ensure that a given XML document will always map to the same XPath tree structure.

Identifying, Selecting, and Manipulating Nodes An XML document is mapped to a tree of nodes when the document is loaded into an XML parser. The individual nodes and groups of nodes in the tree can then be identified, selected, and manipulated. To accomplish this, you use XPath expressions, which recognize the standard node types defined in the XPath data mode. A location path is a special case of XPath expression used specifically to select individual nodes or groups of nodes. A location path can select a node by type, value, or position. To increase the range of use of XPath expressions, you can include operators and functions.

4


Why Use XPath? In XSLT style sheets, for pattern matching

In the DOM, to select nodes programmatically

XPath XPath XML XML

XML XML XML XML In XPointer, to link documents together

In SQL Server 2000, to address result-set nodes

You can use XPath expressions in conjunction with other key XML technologies whenever there is a need to identify, select, or manipulate nodes.

Using XPath to Select Nodes in XSLT Style Sheets Extensible Stylesheet Language Transformations (XSLT) style sheets define a series of template rules that select and transform nodes in a source XML document. Each template rule matches specific nodes in the XML document and specifies how these nodes should be transformed in the output document. When you define an XSLT template, you must: 1. Use an XSLT element to establish an XSLT template rule. 2. Specify an XPath expression as the match attribute of the element, to select matching nodes in the XML document. 3. Define how the selected nodes will be transformed. Example

In this example, an XSLT template rule uses an XPath expression to select elements in an XML document. The element gets the value of each selected element.

Using XPath in the Document Object Model (DOM) The DOM is a programming interface for XML. The Microsoft® DOM parser allows XPath expressions to be used to select nodes. You will learn how to select nodes by using DOM methods and XPath expressions later in this module.


5

Using XPath in XPointer You can use XPath in conjunction with the XML Pointer Language (XPointer) to create a link in one document to nodes in another document. These nodes are similar to hyperlinks in the Hypertext Markup Language (HTML). You can link to any part of the document by specifying the required node in an XPath expression. The XPointer approach offers two main advantages over the hyperlinks approach:

XPointer is more flexible and extensible. The author of a document doesn’t have to anticipate which bookmarks might be useful in a document.

XPointer uses XPath expressions, which make it possible to define conditional links between documents. An XML document can link to different content depending on the result of an XPath expression.

XPointer has not yet been finalized as a standard, and is subject to change before it achieves Recommendation status. Commercial XML parsers do not currently support XPointer, including any version of the Microsoft parser. This course does not further address details of the XPointer specification. For more information, see the draft specification at http://www.w3.org/XML/Linking

Using XPath in SQL Server 2000 Microsoft SQL Server™ 2000 can return query results formatted as an XML document. You can query SQL Server 2000 by creating an annotated schema that functions like an XML view on the underlying relational tables. You then use an XPath expression to select nodes from this XML view and generate a new XML document.

6


Selecting XML Nodes in the DOM Using XPath

DOM is a programmer’s interface to XML documents

Defines methods to add, remove, or reorganize content

Microsoft’s XML parsers define two methods for selecting nodes by using an XPath expression:

selectSingleNode – selects the first matching node

selectNodes – selects all matching nodes

Set Set document document == CreateObject("MSXML2.DOMDocument.3.0") CreateObject("MSXML2.DOMDocument.3.0") document.setProperty document.setProperty "SelectionLanguage", "SelectionLanguage", "XPath" "XPath" Document.async Document.async == False False document.load("MyCatalog.xml") document.load("MyCatalog.xml") Set Set catalogNode catalogNode == document.selectSingleNode("//catalog") document.selectSingleNode("//catalog") Set Set productNodes productNodes == catalog.selectNodes("product") catalog.selectNodes("product")

The DOM makes an XML document available as a tree of nodes. One of the common uses of the DOM is to locate specific nodes or collections of nodes in an XML document.

Using XPath Expressions and the DOM to Select Nodes The Microsoft XML Parser (MSXML3) defines two useful DOM methods for taking an XPath expression and selecting matching nodes in the document:

selectSingleNode returns the first matching node.

selectNodes returns all matching nodes.

Selecting Nodes When you select nodes by using the selectSingleNode or selectNodes methods, you must: 1. Establish a reference to the DOM by using the MSXML2.DOMDocument.3.0 version of the parser. 2. Use the setProperty function to tell the parser to use XPath expressions to select nodes in the XML document. If you do not set this property, the parser uses a non-standard pattern-matching syntax from an earlier version of the parser. 3. Set the document’s async property to False. This ensures that the document is loaded synchronously. 4. Specify an XPath expression or location path as a parameter of the selectSingleNode or selectNodes method.


Example

In this example, DOM methods use XPath expressions to pull a specific set of nodes from an XML document. The code selects the first element in the document, and then selects all of its child elements. Set document = CreateObject("MSXML2.DOMDocument.3.0") document.setProperty "SelectionLanguage", "XPath" document.async = False document.load("MyCatalog.xml") Set catalogNode = document.selectSingleNode("//catalog") Set productNodes = catalog.selectNodes("product")

7

8


Demonstration: Accessing XML Nodes Using XPath

In this demonstration, you will see how XPath expressions can be used to identify nodes in an XML document. The demonstration uses an HTML form that loads an XML document into an MSXML parser at startup. The HTML document has the following visual components:

A
section, where the XML document is displayed.

A drop-down list box, where the user can choose an XPath expression.

A button that calls selectSingleNode against the XML document, using the XPath expression chosen by the user.

A button that calls selectNodes against the XML document, using the XPath expression chosen by the user.

The following XPath expressions may be used. XPath Expression

Description

/catalog/product

Returns the product child elements of catalog.

/catalog/product/price

Returns the price child elements of product elements, which themselves are children of catalog.

/catalog/product/@code

Returns the code attribute of product elements, which themselves are children of catalog.

/catalog/product[1]

Returns the first product in the catalog.

/catalog/product[last()]

Returns the last product in the catalog.

The results of the selectSingleNode and selectNodes methods are displayed in message boxes for clarity.



XPath Tree Structure and Node Types

Obtaining Information About Each Node

Using Nodes in the DOM

In this section, you will learn how XML documents are modeled as a tree in XPath. You will also learn about the properties contained in each node, and see how to access this information by using the DOM.

9

10


XPath Tree Structure and Node Types

XML documents map to an XPath tree

An XPath tree contains nodes arranged in a hierarchy Root Root

xmlns="urn:litwareinc"> instr?> code="123"> Blue Blue jeans jeans

"urn:litware" "urn:litware" "proc-instr" "proc-instr" "comment "comment ""

"urn:litwareinc" "urn:litwareinc"

"123" "123"

"Blue "Blue jeans" jeans"

XPath treats an XML document as a tree of nodes. The ordering of nodes corresponds to the ordering of content in the XML document. There are seven node types in XPath:

Root nodes

Element nodes

Attribute nodes

Text nodes

Namespace nodes

Processing instruction nodes

Comment nodes

Root Nodes Every XML document has a single root node, which lies at the top of the XPath tree. The root node in XPath has the same role as the document node in the DOM.

Element Nodes A separate element node in the XPath tree represents every element in an XML document. A well-formed XML document has a single document element, and any number of child elements and descendant elements.


11

Attribute Nodes Elements can have zero or more attributes. Note the following points about attribute nodes:

Every attribute is represented by a separate attribute node. If multiple elements have the same attribute name and value, each attribute is represented by a different attribute node.

Attribute nodes are not considered to be children of the elements in which they are defined.

If an attribute is not explicitly defined but has a default value specified in a Document Type Definition (DTD), it still appears in the XPath tree.

Namespace declarations look like attributes, but they are represented by namespace nodes in the XPath tree.

Text Nodes A text node is a sequence of consecutive characters defined in an element’s content. Any adjacent text is normalized to form a single text node. A text node always contains at least one character.

Namespace Nodes Each element has a set of namespace nodes that describe all of the namespace definitions within scope for that element. This includes namespaces defined in ancestor elements, plus the default namespace (if one has been defined). Namespace nodes are not shared. If an element defines a namespace that also applies to its child elements, then each child element will have a distinct namespace node.

Processing Instruction Nodes Processing instructions provide information to help the parser process the XML document. Processing instructions use the syntax. XML declarations also use the syntax . However, XML declarations are not considered to be processing instructions. XML declarations are not represented in an XPath tree.

Comment Nodes Comment nodes contain the comment text enclosed between the delimiters .

12


Obtaining Information About Each Node

Each node has properties that describe the node

Node types

Properties

Root

Value

Element

Name

Attribute

Parent node

Text

Child nodes

Namespace

Processing instruction

Comment

Each node in an XPath tree has four properties. These properties describe the value, name, and location of the node. The properties are as follows:

The value of the node. This property is a Unicode string.

The name of the node. This property gives the node’s name, plus its namespace Uniform Resource Identifier (URI) if defined.

The parent node. All XPath nodes have a single parent node, except for the root node, which does not have a parent node.

The list of child nodes. This property returns a node-set specifying the direct children of a node.

Root Node Properties This table describes the relevant properties for the root node. Property

Contains

Value

Concatenated string values for all text nodes in the document.

Child nodes

Contains the document element, and any processing instructions and comments before the start or after the end of the document element.


13

Element Node Properties This table describes the relevant properties for element nodes. Property

Contains

Value

Concatenated string values for all descendant text nodes.

Name

The name of the element. If the element is in a namespace, the namespace URI is included in the element’s name.

Parent node

A reference to the element’s parent node. This will be another element node, except in the case of the document element. The parent of the document element is the root node.

Child nodes

Elements, text nodes, processing instructions, and comments defined as children of the element.

Attribute Node Properties This table describes the relevant properties for attribute nodes. Property

Contains

Value

The value of the attribute.

Name

The name of the attribute. If a namespace prefix appears explicitly on the attribute, the namespace URI is included in the attribute’s name. Otherwise, the namespace URI is not included in the attribute’s name.

Parent node

The containing element node. Note that although attributes have elements as parents, attributes are not considered children of elements.

Text Node Properties This table describes the relevant properties for text nodes. Property

Contains

Value

The character data itself. The text node always contains at least one character.

Parent node

The containing element of the text node.

Namespace Node Properties Consider the namespace xmlns:lit="urn:litwareinc". The following table describes the relevant properties for namespace nodes. Property

Contains

Value

The namespace URI, urn:litwareinc

Name

The namespace prefix, lit

Parent node

The containing element of the namespace node

14


Processing Instruction Node Properties This table describes the relevant properties for processing instruction nodes. Property

Contains

Value

The part of the processing instruction following the target, including any whitespace.

Name

The target of the processing instruction. For example, in , the name is xml-stylesheet.

Parent node

The containing element of the processing instruction node, or the root node if declared outside the document element.

Comment Node Properties This table describes the relevant properties for comment nodes. Property

Contains

Value

The contents of the comment

Parent node

The containing element of the comment node, or the root node if declared outside the document element


Using Nodes in the DOM

You can access node information using DOM properties

Set Set node node == document.selectSingleNode("//product") document.selectSingleNode("//product") MsgBox MsgBox MsgBox MsgBox MsgBox MsgBox MsgBox MsgBox

"Text && node.text "Text value: value: "" node.text "Node base-name: " & node.baseName "Node base-name: " & node.baseName "Namespace "Namespace prefix: prefix: "" && node.prefix node.prefix "Namespace && node.namespaceURI "Namespace URI: URI: "" node.namespaceURI

Set Set parent parent == node.parentNode node.parentNode MsgBox MsgBox "Name "Name of of parent: parent: "" && parent.baseName parent.baseName Set Set For For

children children == Each Each child child

node.childNodes node.childNodes In In children children ……

The DOM allows you to specify an XPath expression in the selectSingleNode and selectNodes methods, to select nodes in an XML document. Once you have a node, you can use DOM properties to find out more information about the node. The following table describes the commonly used DOM properties for retrieving node information. DOM property

Description

text

Gets the text value of the node. For example, the text property for an attribute is the value of the attribute.

baseName

Gets the name of the node, without any namespace information.

prefix

Gets the namespace prefix for an element or attribute.

namespaceURI

Gets the namespace URI for an element or attribute.

parentNode

Gets the parent node.

childNodes

Gets a NodeList containing all of the children of the node.

15

16

Example


In this example, the DOM selectSingleNode method uses an XPath expression to return the first element in an XML document. Message boxes use the DOM to display useful information about the element. Set document = CreateObject("MSXML2.DOMDocument.3.0") document.setProperty "SelectionLanguage", "XPath" document.async = False document.load("MyCatalog.xml") Set node = document.selectSingleNode("//product") MsgBox MsgBox MsgBox MsgBox

"Text value: " & "Base name: " & "Namespace prefix: " & "Namespace URI: " &

node.text node.baseName node.prefix node.namespaceURI

Set parent = node.parentNode MsgBox "Name of parent: " & parent.baseName Set children = node.childNodes For Each child In Children MsgBox "Child node name: " & child.baseName MsgBox "Child node value: " & child.text Next


17

Lab 2.1: Accessing Node Information

Objectives After completing this lab, you will be able to:

Use XPath expressions in the XML Document Object Model (DOM) to locate content in an XML document.

Obtain detailed information about the nodes in an XML document.

Prerequisites Before working on this lab, you must have:

Familiarity with Microsoft® Visual Basic® Scripting Edition (VBScript).

A working knowledge of the DOM.

Scenario In this lab, you will add VBScript to an HTML page in order to load an XML document and navigate its contents by using XPath expressions. You will use the DOM methods SelectSingleNode() and SelectNodes() to display the results.

Starter and Solution Files There are starter files and solution files for this lab. Starter files are in the folder \Labs\Lab02.1\Starter. Solution files are in the folder \Labs\Lab02.1\Solution.

Estimated time to complete this lab: 45 minutes

18


Exercise 1 Selecting Single Nodes Using XPath and the DOM In this exercise, you will load an XML document into a Microsoft XML (MSXML) parser. You will use the selectSingleNode() method to select a single node from the document. You will then obtain the name, value, and parent information for this node.

To load an XML document into an MSXML parser 1. Open NodeProperties.htm with Microsoft Notepad from the folder \Labs\Lab02.1\Starter. Locate the script function Window_OnLoad(). 2. Use the CreateObject() function to create an instance of the MSXML2.DOMDocument.3.0 object. Store a reference to this variable in the global variable named document. 3. Use the setProperty() method of the document to set the SelectionLanguage property to XPath. 4. Set the async property of the document object equal to False. 5. Load the XML document Catalog.xml into the document object. 6. Display the XML by assigning divXMLDisplay.innerText = document.xml. 7. Open http://localhost/1913/Labs/Lab02.1/Starter/NodeProperties.htm with Microsoft Internet Explorer. Examine the structure and content of the XML document.

To obtain the name and value of a node 1. Open NodeProperties.htm with Notepad and find the script function btn1_OnClick(). This function is called when the btn1 button is clicked in the HTML document. 2. Use the selectSingleNode() method of the document object to get the first element node. 3. Use the baseName and text DOM properties to get the name and value of this node. 4. Use the MsgBox function to display these details. 5. Open http://localhost/1913/Labs/Lab02.1/Starter/NodeProperties.htm with Internet Explorer. Click button 1. The message box displays the name and value of the element: product Blue Jeans 35.99


19

To obtain information about the parent node 1. Open NodeProperties.htm with Notepad and find the script function btn2_OnClick(). This function is called when the btn2 button is clicked in the HTML document. 2. Use the selectSingleNode() method of the document object to get the first element node. 3. Use the parentNode DOM property to get the parent node. 4. Use the MsgBox function to display the name and value of the parent node. 5. Open http://localhost/1913/Labs/Lab02.1/Starter/NodeProperties.htm with Internet Explorer. Click button 2. The message box displays the name and value of the parent node: catalog Blue Jeans 35.99 Plaid shirt 22.95 Leather Jacket 185.00

20


Exercise 2 Selecting Multiple Nodes Using XPath and DOM In this exercise, you will display details for all of the child nodes of the first element. You will then use the selectNodes() method to obtain details for all elements in the XML document.

To obtain information about child nodes 1. In NodeProperties.htm, locate the script function btn3_OnClick(). 2. Use the selectSingleNode() method of the document object to get the first element node. 3. Use the childNodes DOM property to get a list of its child nodes. 4. Create a loop to step through the list of child nodes. Use the MsgBox function to display the name and value of each child node. 5. Open http://localhost/1913/Labs/Lab02.1/Starter/NodeProperties.htm with Internet Explorer. Click button 3. Message boxes display the following information: Child node name: description Child node value: Blue Jeans Child node name: price Child node value: 35.99

To obtain information about all elements 1. In NodeProperties.htm, locate the script function btn4_OnClick(). 2. Use the selectNodes() method of the document object to select all of the elements in the document. 3. Create a loop to step through the list of elements. Use the MsgBox function to display the name and value of each element. 4. Open http://localhost/1913/Labs/Lab02.1/Starter/NodeProperties.htm with Internet Explorer. Click button 4. Three message boxes appear, one after the other, displaying the following information: product Blue Jeans 35.99 product Plaid shirt 22.95 product Leather jacket 185.00



What Is a Location Path?

Constructing Location Paths

Understanding Axes

Using Axes in XPath

Using Node Tests

Using Predicates to Filter Nodes

Demonstration: Navigating a Document Using Location Paths

In this section, you will learn how to use a special type of XPath expression known as a location path, which is used to select specific nodes in an XML document. Location paths can be used to select any type of node in an XML document, at any relative or absolute position.

21

22


What Is a Location Path?

A location path is an XPath expression for locating nodes in an XML document

Locates nodes conveniently and efficiently

Location paths may be relative or absolute

Relative location paths

Define a location relative to the current node

Absolute location paths

Begin with a “/” character

Define a location relative to the root node

A location path is an XPath expression that contains a sequence of teststhat locate specific nodes in an XML document. A location path selects nodes in a hierarchical XML document, similarly to the way a file path selects files in a hierarchical file system. There are two types of location paths:

Relative location paths

Absolute location paths

Defining a Relative Location Path A relative location path defines a path through an XML document, relative to the current node in the document. Relative location paths are useful when you have already located a particular node in an XML document, and you want to find a nearby node such as a child element or the parent node. Example

This relative location path selects child elements named , relative to the current position in the XML document. The location path then selects the child elements of these elements: product/description

Defining an Absolute Location Path An absolute location path defines a path through an XML document, starting at the root node in the document. Absolute location paths begin with a forward slash character (“ / ”). Absolute location paths are useful when your current location in the document is not important, and you want to perform a fresh search from the root of the document.


Example

23

This example shows an absolute location path. Note that the location path starts with a forward slash character. The location path selects the element, relative to the root node. The child elements are then retrieved: /catalog/product

24


Constructing Location Paths

A location path is made up of location steps

Relative path

product/price product/price

Absolute path

/catalog/product/price /catalog/product/price

Location steps are evaluated from left to right

Specify a path through the XML document

Each location step is made up of three parts axis::node-test[predicate]… axis::node-test[predicate]…

Example location step child::product[price child::product[price >> 35.95][3] 35.95][3]

A location path is an expression that selects nodes in an XML document. The result of a location path is called a node-set. A node-set may contain many nodes, a single node, or no nodes at all. A location path defines a search path through an XML document. A relative location path starts at the context node. An absolute location path starts at the root node.

Analyzing Location Paths A location path is composed of one or more location steps, each separated by a forward slash character. Each location step yields a node-set. Location steps are strung together from left to right, with each location step feeding its node-set into the next location step to yield a more specific or refined node-set. A relative location path may be defined as follows: location-step/location-step/location-step

… etc.

To define an absolute location path, place a forward slash character at the beginning of the location path, as follows: /location-step/location-step/location-step

… etc.


Examples

25

In this example, a relative location path is made up of two location steps. Starting at the context node, the first location step returns a node-set composed of elements. The second location step selects any child elements. product/price

In the next example, an absolute location path is constructed of three location steps. Starting at the document root, the first location step selects the document element. The next location step selects child elements of the element. The last location step selects the child elements of the elements. /catalog/product/price

Specifying Search Criteria in a Location Step Each location step specifies an axis, a node test, and one or more optional predicates, as described in this section. The syntax follows this pattern: axis::node-test[predicate]

Axis The axis defines what type of search you wish to perform. For example, the child axis selects child elements, and the attribute axis selects attributes. The full set of axes is described in the following section.

Node test The node test specifies the names of the nodes or the type of nodes you wish to select. Typically, this is the name of an element or attribute.

Predicate A predicate is a Boolean expression that filters the node-set obtained in the node test. A location step can have zero or more predicates. Each predicate expression is enclosed in brackets ([]) and filters nodes that match the specified criterion.

Example

In this example, a relative location path applies a product node test to a search through the child axis. Two predicates filter the node-set. The first predicate keeps only those elements with a greater than 35.95. The next predicate keeps only the third such element. child::product[price > 35.95][3]

26


Understanding Axes 35.99 22.95 25 185.00

self child

following following-sibling

parent attribute descendant descendant-or-self

preceding preceding-sibling

ancestor ancestor-or-self Root node

code=123

code=456

35.99

22.95

code=789

185.00

25

XPath defines 13 different axes described in the following table. These axes enable you to search an XML document in any way you wish. XPath axis

Description

self

Contains only the context node.

child

Contains the child nodes of the context node.

parent

Contains the parent node of the context node.

attribute

Contains attributes of the context node.

descendant

Contains the child nodes of the context node, plus their child nodes, and so on.

descendant-or-self

Contains the descendants of the context node, plus the context node itself.

ancestor

Contains the parent of the context node, plus its parent, and so on, up to (and including) the root node.

ancestor-or-self

Contains the ancestors of the context node, plus the context node itself.

following

Contains all nodes (except descendant nodes, attribute nodes, and namespace nodes) that appear after the closing tag of the context node.

following-sibling

Contains all of the following siblings of the context node. If the context node is an attribute node or a namespace node, the node-set is empty.

preceding

Contains all nodes (except ancestor nodes, attribute nodes, and namespace nodes) that appear before the opening tag of the context node.

preceding-sibling

Contains all of the preceding siblings of the context node. If the context node is an attribute node or a namespace node, the node-set is empty.

namespace

Contains the namespace nodes of the context node.


27

Using Axes in XPath

Commonly used XPath axes may have unabbreviated or abbreviated syntax Axis

Example – unabbreviated

Example – abbreviated

child

child::price

price

attribute::code

@code

self::node()

.

parent::node()

..

attribute self parent

descendant-or-self /descendant-or-self()/price

//price

The remaining axes only have unabbreviated syntax

Example – ancestor::node()

The first part of any location step is the axis, which determines the type of node your search will target. XPath defines 13 different types of axes. The following are the most commonly used axes:

The child axis

The attribute axis

The self axis

The parent axis

The descendant-or-self axis

Using the Child Axis A location step that uses the child axis returns the child nodes of the context node. The child axis is the default axis if none is specified in a location step. Example

In this example, the child axis is used in two successive location steps. child::catalog/child::product

From left to right, these location steps are evaluated as follows:

child::catalog retrieves all children named catalog from the current context.

child::product takes the node-set returned from the first location step and retrieves its child nodes named product.

You could also write the preceding example by using an abbreviated syntax to achieve the same result: catalog/product

28


Using the Attribute Axis A location step that uses the attribute axis returns the attributes of the context node. This axis is empty unless the context node is an element. An “ @ ” symbol may be used as an abbreviated syntax for the attribute axis. Example

In this example, a location path is made up of two location steps that use unabbreviated syntax. In the first location step, the child::product location path retrieves a node-set of child nodes named product. These are fed into the second location step, attribute::code, which retrieves the code attribute for each product. child::product/attribute::code

This example can be written by using an abbreviated syntax, as follows: product/@code

Using the Self Axis The self axis contains only the context node. The location step “ . ” is short for self::node(). You will see situations later in the course where self is used to pass the current node as a parameter into a template rule.

Using the Parent Axis A location step that uses the parent axis returns the parent of the context node, if there is one. All nodes except the root node have a single parent. The root node has no parent. Example

This example selects the grandparent of the current node, and returns its child elements. parent::node()/parent::node()/child::product

The location steps are evaluated from left to right as follows:

The first parent::node() retrieves the parent node; node() is a function that matches any node type.

The second parent::node() retrieves the grandparent node.

child::product retrieves its child elements named product.

As is the case with the child axis specifier, the parent axis specifier can be written by using an abbreviated syntax. You can use “ .. ” to abbreviate the syntax for parent::node(). Again, the example can be rewritten by using an abbreviated syntax, as follows: ../../product


Using the Descendant-or-Self Axis You use the descendant-or-self axis to return any descendants of the context node, plus the context node itself. The abbreviated syntax “ // ” is short for /descendant-or-self::node()/. Example

This example returns all nodes named product that are descendants of the root. //product

The next example returns all nodes named product that are descendants of a child node named catalog. catalog//product

Using Other Axes The remaining axes in XPath use only unabbreviated syntax. The following table shows how to use these axes in XPath. Axis

XPath axis syntax

descendant

descendant::node()

ancestor

ancestor::node()

ancestor-or-self

ancestor-or-self::node()

following

following::node()

following-sibling

following-sibling::node()

preceding

preceding::node()

preceding-sibling

preceding-sibling::node()

namespace

namespace::node()

29

30


Using Node Tests

Selecting nodes by name

Child examples

Attribute examples

Specific name

price price

@code @code

All nodes

**

@* @*

Name and namespace

aprefix:price aprefix:price

@aprefix:code @aprefix:code

All nodes in namespace

aprefix:* aprefix:*

@aprefix:* @aprefix:*

Selecting nodes by type

axis::node-type-function()

For example, using the child axis text() text()

processing-instruction() processing-instruction()

node() node()

comment() comment()

A node test appears after the axis specifier in a location step, and enables you to:

Locate nodes by name.

Locate nodes by type.

Locating Nodes by Name You can search an axis for the specific name of a node. Use the following syntax to specify the name of the node you wish to select: axis::name-of-node[predicate]

XPath will interpret the name differently, depending on the type of node called by the axis.

If the axis is attribute, the name is treated as an attribute name. If you want to select all attribute nodes, use “ * ” instead of a specific name.

If the axis is namespace, the name is treated as a namespace prefix. If you want to select all namespace nodes, use “ * ” instead of a specific namespace prefix.

For all other axes, the name is treated as an element name. XPath will locate elements matching that name in the chosen axis. If you want to select all element nodes, use “ * ” instead of a specific name.


31

If you want to locate named elements or attributes in a particular namespace, specify the namespace prefix as follows: axis::aprefix:name-of-node[predicate]

If you want to locate all elements or attributes in a particular namespace, use “ * ” rather than a particular element name or attribute name: axis::aprefix:*[predicate]

Examples

Example

Explanation

price

Select elements.

@code

Select code attributes.

*

Select all elements.

@*

Select all attributes.

aprefix:price

Select elements defined in a namespace whose prefix is aprefix.

@aprefix:code

Select code attributes defined in a namespace whose prefix is aprefix.

aprefix:*

Select all elements defined in a namespace whose prefix is aprefix.

@aprefix:*

Select all attributes defined in a namespace whose prefix is aprefix.

Locating Nodes by Type It is sometimes useful to be able to select nodes by type, rather than by name. Use the following syntax to create a location path that searches along an axis for a particular type of node: axis::node-type()[predicate]

Use one of the following XPath functions in the place of node-type(). Function

Selects

node()

All nodes on the specified axis.

text()

All text nodes on the specified axis. For example, child::text() selects all text nodes that are children of the context node, and descendant::text() selects all text nodes that are descendants of the context node.

comment()

All comment nodes on the specified axis.

processing-instruction()

All processing-instruction nodes on the specified axis. Optionally, you can pass a parameter to select processing-instructions with a specific name.

32


Using Predicates to Filter Nodes

A location step may include zero or more predicates axis::node-test[predicate]… axis::node-test[predicate]…

Filtering a node-set by using predicates

Filter nodes by position

product[last()] product[last()]

Filter nodes by content

product[@code="123"] product[@code="123"]

Filter nodes by presence product[@code] product[@code]

Multiple predicates may be defined

Evaluated left to right

product[3][@discount] product[3][@discount]

A location step may include zero or more predicates. A predicate is a test condition enclosed in [brackets], and refines the set of nodes obtained by a node test. You can use predicates to filter nodes by position, content, or whether they contain specific nodes. The predicate is evaluated successively for each node in the node-set, to determine whether the node passes or fails the predicate test condition.

Filtering Nodes by Position When filtering nodes by position, consider the following facts and guidelines:

Most XPath axes number nodes in a forward document order. For example, if you are using the child axis, elements near the beginning of the document have a lower position than those closer to the end.

You can filter nodes by using either a reverse axis or a forward axis. The reverse axes are ancestor, ancestor-or-self, preceding, and preceding-sibling. All other axes are forward axes.

Each node in a node-set has a proximity position, indicating the position of the node in the node-set. The first position is 1.

If a reverse axis is specified, nodes are numbered in reverse document order.

If a forward axis is specified, nodes are numbered in forward document order.


Example

33

Example

Explanation

product[1]

Selects the first child of the context node.

product[last()]

Selects the last child of the context node.

/catalog/product[2]

Selects the second child of the element.

Filtering Nodes by Value You can specify a predicate to filter nodes by value. The following example selects the children of the context node that have a code attribute whose string-value is "123": product[@code="123"]

Filtering Nodes by Presence You can specify a predicate to filter nodes by presence, as detailed in the following table. Example

Explanation

product[@code]

Selects the children of the context node that have a code attribute.

product[@code and @discount]

Selects the children of the context node that have a code attribute and a discount attribute.

Defining Multiple Predicates Multiple predicates may be defined, each in its own set of square brackets, to apply multiple filters to a node-set, as shown in the following table. Predicates are evaluated from left to right. Example

Explanation

product[3][@discount]

Selects the third child if it has a discount attribute.

product[@discount][3]

Selects the third child of the context node that has a discount attribute.

34


Demonstration: Selecting Nodes with Location Paths

In this demonstration, you will see how to use XPath location paths to locate nodes in an XML document. The demonstration makes use of the following XML document: Blue jeans 35.99 Plaid shirt 22.95 Leather jacket 185.00 Silk tie 32.50 Wool sweater 27.99 Patent shoes 87.00


Using Operators and Functions in Location Paths

Using Node-Set Expressions and Functions

Using Boolean Expressions and Functions

Using Number Expressions and Functions

Using String Expressions and Functions

When writing XPath expressions, you can make them more selective and flexible by including any of a variety of XPath operators and functions. Many operators and functions defined by XPath are similar to those defined in other programming languages. In addition to the standard data types—Boolean, numeric, and string—XPath provides a node-set data type, which is the result of a location path. XPath provides functions and operators to work with nodesets as well as Boolean, numeric, and string data. In this section, you will learn how to write XPath expressions that make use of the operators and functions defined in the XPath specification.

35

36


Using Node-Set Expressions and Functions

Location paths return node-sets

Merge node-sets within a location path by using the union operator (“ | ”) cd cd || dvd dvd /*/(cd /*/(cd || dvd) dvd) (cd (cd || dvd)/@capacity dvd)/@capacity

Node-set functions can also be used cd[position() cd[position() == last()] last()] count(cd[@capacity count(cd[@capacity >> 5.8]) 5.8])

The node-set data type is unique to XPath. A node-set contains all of the nodes that match the location path’s selection criteria. You can merge node-sets within a location path by using either the union operator or the node-set functions.

Merging Node-Sets with the Union Operator Node-sets may be merged together by using the “ | ” union operator. Examples

Example

Explanation

cd | dvd

This location path returns a node-set containing all of the or child elements.

(cd | dvd) / @capacity

This location path returns a node-set containing the capacity attribute of all or elements.

/*/(cd | dvd)

This location path returns a node-set containing all of the or elements that are grandchildren of the root node.

//* | //@*

This location path returns a node-set containing all of the element and attribute nodes in the document.


37

Node-Set Functions Node-set functions either accept a node-set parameter, return a node-set, or return information about a particular node within a node-set, as described in the following table.

Examples

Function

Description

position()

Returns the position of a node in a nodeset (starting at 1).

last()

Returns true if the node is the last node in the node-set.

count()

Returns the number of nodes in a nodeset.

id()

Selects nodes with a specific ID.

local-name()

Returns the local part of a node name, stripped of any namespace information. This is useful if you want to find all elements or attributes with the same name, regardless of their namespace.

namespace-uri()

Returns the namespace URI of a node name.

name()

Returns the namespace prefix of a node name.

Example

Description

cd[(last)]

The position() function is used here to return the final child element of the context node.

count(cd[@capacity = 250])

The count() function returns the number of elements that have a capacity attribute value equal to 250.

id("myID")

The id() function selects the element with a unique ID of myID.

*[local-name()="cd"]

The local-name() function selects all child elements whose local-name is "cd".

*[namespaceuri()="www.nwtraders.msft"]

The namespace-uri() function selects all child elements that inhabit the "www.nwtraders.msft " namespace.

*[name()="abc:cd"]

The name() function selects all child elements with an expanded name of “abc:cd”

Tip Avoid using name() to select all child elements within a certain namespace. Instead, use namespace-uri() and test the namespace URI rather than using name() to test its prefix.

38


Using Boolean Expressions and Functions

Boolean operators = != > >= < <=

product[(price product[(price >> 25 25 and and price price << 35) 35) or or price price >> 50] 50]

Boolean functions

true() true()

false() false()

boolean() boolean()

not() not()

lang() lang()

Example

product[not(@code) product[not(@code) and and not(discount-policy)] not(discount-policy)]

XPath supports a Boolean data type for values that can be true or false.

Boolean Operators

Examples

Operator

Description

= and !=

Used to apply equality and inequality when evaluating expressions.

> and >= and < and <=

Used to apply greater-than, greater-than-or-equal, lessthan, less-than-or-equal operators when evaluating expressions.

and

Returns true if both operands are true, false otherwise. The second operand is not evaluated if the first operand is false.

or

Returns true if either (or both) operands are true, false otherwise. The second operand is not evaluated if the first operand is true.

Example

Explanation

product[price != 25]

Selects elements with child elements with a value not equal to 25.

product[price < 25]

Selects elements with child elements with a value less than 25.

product[price < 10 or price > 100]

Selects elements with child elements with a value less than 10 or greater than 100.


39

Boolean Functions Function

Description

true()

Return the values true and false, respectively. One of the few uses of this function is to pass a Boolean parameter into an XSLT template rule. This is discussed in Module 5, “Programming with XSLT.”

false()

Examples

boolean()

Converts an XPath data type into a Boolean value. A node-set is converted to false if it is empty, true otherwise. A number is converted to false if it is zero, true otherwise. A string is converted to false if it has zero characters, true otherwise.

not()

Returns the values true or false. If the parameter is a node-set, a number, or a string, it is converted to a Boolean first according to the boolean() function.

lang()

Takes a string parameter representing a language encoding (such as "en"), and returns true if the context node (or one of its ancestors) defines an xml:lang attribute starting with the same language name.

Example

Explanation

boolean(//product[@code="123"])

Returns false if there are no product elements with a code attribute of "123" in the document, true otherwise.

boolean(3.14)

Returns true always

boolean("Welcome")

Returns true always.

not(@*)

Returns true if the context node has no attributes.

not(node())

Returns true if the context node has no child nodes.

*[not(self::description)]

Selects all child nodes except nodes.

Precedence Order This table shows the precedence order, from highest to lowest, for comparison operators and Boolean operators. Operator

Operator name

()

Grouping

[]

Filters

/ //

Path operations

< <= > >=

Comparisons

= !=

Comparisons

|

Union

not()

Boolean not

and

Boolean and

or

Boolean or

40


Using Number Expressions and Functions

Unary negation operator

account[balance account[balance >= >= -- overdraft-limit] overdraft-limit]

Binary number operators, + - * div mod

account[(balance account[(balance mod mod 100) 100) >> 0] 0]

Number functions

number() number()

floor() floor()

ceiling() ceiling()

round() round()

sum() sum()

Example

account[sum(transaction-amount) account[sum(transaction-amount) >> 0] 0]

XPath provides support for a floating-point number type. Numbers are 64-bit quantities in XPath, and follow the Institute of Electrical and Electronics Engineers, Inc. (IEEE) 754 standard. This standard defines special values for negative infinity, positive infinity, negative zero, positive zero, and “not-anumber” (NaN).

Number Operators Operator

Explanation

-

Unary negation operator. Inverts the sign of a number.

+

Addition operator.

-

Subtraction operator. Use white space around the subtraction operator to avoid confusion with node names that contain a hyphen.

*

Multiplication operator.

div

Division operator.

mod

Modulus operator. Returns the remainder from a truncating division.


Examples

41

Example

Explanation

account[balance >= - overdraft-limit]

Selects elements whose is greater than the negated value of the .

account[balance - overdraft-limit > 100]

Returns elements whose exceeds the value by 100 or more.

account[balance-overdraft-limit > 100]

Returns elements whose is greater than 100.

-7 mod 3

Returns –1.

Number Functions Functions

Description

number()

Converts an XPath data type into a number value. number() is most often used in a predicate, to ensure that the predicate is treated as a number rather than a Boolean. A string is converted to the nearest number, or NaN if it doesn’t correspond to a numeric value. A node-set is first converted to a string, and then is converted to a number as previously described. A Boolean is converted to 1 if true, 0 if false.

floor()

Takes a parameter and returns the largest integer that is less than or equal to the numeric value of the parameter.

ceiling()

Takes a parameter and returns the smallest integer that is greater than or equal to the numeric value of the parameter.

round()

Takes a parameter and returns the nearest integer to the numeric value of the parameter. (The fraction .5 is rounded up.)

sum()

Takes a node-set parameter, converts the string-value of each node to a number, and then sums all the numbers.

42


Examples

Example

Explanation

account[number(/branch/@oldest-account)]

Retrieves the number value of the oldestaccount attribute in the element. This value is then used in the predicate to select the element at that position in the document.

string(number(@password)) = "NaN"

Tests whether a value is numeric. If the value isn’t numeric, number() returns “NaN”.

floor(7.5)

Returns 7.

floor(-7.5)

Returns –8.

ceiling(7.5)

Returns 8.

ceiling(-7.5)

Returns -7.

round(7.5)

Returns 8.

round(-7.5)

Returns -7.

sum(catalog/product/price) div count(catalog/product/price)

Calculates the average price of all products in a catalog. This example is not as efficient as it might be, because the element’s node-set is built twice. XSLT variables could be used here to avoid duplicate processing. XSLT variables are discussed in Module 5, “Programming with XSLT.”


43

Using String Expressions and Functions

String query functions

string-length(customer/@last-name) string-length(customer/@last-name) customer[ customer[ starts-with(@last-name, starts-with(@last-name, "Mac") "Mac") ]] customer[ customer[ contains(@last-name, contains(@last-name, "Mac") "Mac") ]]

String extraction and modification functions

concat(@last-name, concat(@last-name, "[", "[", @first-name, @first-name, "]") "]") substring(@middle-name, substring(@middle-name, 1, 1, 1) 1) substring-before("12/3/1964", substring-before("12/3/1964", "/") "/") or or substring-after substring-after normalize-space(" normalize-space("

To To

be be or or not not to to

be be

") ")

translate(str, translate(str, "aeiou", "aeiou", "AEIOU") "AEIOU")

The string data type represents a sequence of zero or more XPath characters. XPath provides a reasonable set of functions for manipulating string values.

String Functions Function

Description

string()

Takes a single parameter and converts it into a string. If the parameter is a node-set, the function returns the string-value of the first node (in document order). If the node-set is empty, an empty string is returned. If the parameter is a number, the function returns an appropriate string representation. If the parameter is a Boolean, the function returns the string "true" or "false" accordingly.

string-length()

Returns the length of the string.

concat()

Takes two or more strings and returns the concatenation of these strings.

starts-with()

Returns true if the first string parameter starts with the second string parameter.

contains()

Returns true if the first string parameter contains the second string parameter at any position.

substring()

Takes a source string, a numeric start position (starting at 1), and optionally a numeric length. Returns the substring starting at the specified start position and having the specified length. If no length is defined, the substring extends to the end of the source string

44


Examples

Function

Description

substringbefore()

Takes two string parameters. The first parameter specifies the source string, and the second parameter specifies the substring to search for. Returns the part of the source string before the first occurrence of the substring.

substringafter()

Takes two string parameters. The first parameter specifies the source string, and the second parameter specifies the substring to search for. Returns the part of the source string after the first occurrence of the substring.

normalizespace()

Removes leading and trailing white space from a string, and replaces multiple adjacent white spaces with a single space.

translate()

Takes three parameters: a source string, a comparison string, and a replacement string. In the source string, any characters that are specified in the comparison string are replaced by the corresponding characters in the replacement string.

Several common XML string handling tasks are illustrated here. Example

Explanation

string-length("Hello")

Returns 5.

string-length("")

Returns 7.

concat( @last-name, "[", @firstname, "]" )

Concatenates a person’s last-name and first-name attributes into a string of the form last-name [firstname].

customer[ starts-with(@last-name, "Mac") ]

Selects customers whose last-name attribute starts with "Mac".

customer[ contains(@last-name, "Mac") ]

Selects customers that have "Mac" anywhere in their last-name attribute.

substring(@middle-name, 1, 1)

Returns the first letter of a middle-name attribute.

substring-before("12/3/1964", "/")

Returns "12".

substring-after("12/3/1964", "/")

Returns "3/1964".

translate(str, ":/\", "")

Removes colons, forward slashes, and backward slashes from a string.

normalize-space(" To be or not to be ")

Returns the string "To be or not to be".


45

Lab 2.2: Selecting and Navigating Nodes Using XPath

Objectives After completing this lab, you will be able to:

Use XPath location paths to locate content in an XML document.

Construct a complex XPath location path to filter the content of the XML document.

Use XPath expressions to analyze the content and structure of the XML data.

Prerequisites Before working on this lab, you must have:

Familiarity with VBScript.

A working knowledge of the XML Document Object Model (DOM).

Scenario In this lab, you will add VBScript to an HTML page in order to navigate an XML document by using XPath location paths. The location paths will contain multiple location steps, to define a path through the document. Each location step will define an axis, a node test, and zero or more predicates.

Starter and Solution Files There are starter and solution files for this lab. Starter files are in the folder \Labs\Lab02.2\Starter. Solution files are in the folder \Labs\Lab02.2\Solution.

Estimated time to complete this lab: 60 minutes

46


Exercise 1 Selecting Attributes and Named Elements In this exercise, you will use the selectSingleNode() method to select an element at a particular index position in an XML document. You will then obtain information about its attributes and child elements.

To select an element at a particular index position 1. Open NavigateNodes.htm with Notepad and find the script function btn1_OnClick(). This function is called when the btn1 button is clicked in the HTML document. 2. Use the selectSingleNode() method of the Document object to select the fourth element. 3. Use the MsgBox function to display the text property of this text node. 4. Open NavigateNodes.htm with Microsoft Internet Explorer. Click button 1. The message box displays the following text: Silk tie 32.50 3 25

To select an attribute 1. In NavigateNodes.htm, locate the script function btn2_OnClick(). 2. Use the selectSingleNode() method to get the code attribute of the fourth element. 3. Display the text property of this attribute node. 4. Open NavigateNodes.htm with Internet Explorer. Click button 2. The message box displays the following text: 321

To select a specific child element 1. In NavigateNodes.htm, locate the script function btn3_OnClick(). 2. Use the selectSingleNode() method to get the element of the fourth element. 3. Display the text property of this element node. 4. Open NavigateNodes.htm with Internet Explorer. Click button 3. The message box displays the following text: Silk Tie


Exercise 2 Selecting Multiple Child and Descendant Elements In this exercise, you will use the selectNodes() method to select node-sets containing multiple nodes. First, you will select child elements, and then you will select descendant elements. In each case, you will use a loop to examine the details for each node in the node-set.

To select all child elements of a 1. In NavigateNodes.htm, find the script function btn4_OnClick(). 2. Use the selectNodes() method of the Document object to select all child elements of the fourth element. 3. Use a loop to display the baseName and text property for each element. Display a separate message box in each iteration of the loop. 4. Open NavigateNodes.htm with Internet Explorer. Click button 4. Three message boxes display the following text: Element name: description Element value: Silk tie Element name: price Element value: 32.50 Element name: discount-policy Element value: 3 25

To select all descendant elements of a element 1. In NavigateNodes.htm, find the script function btn5_OnClick(). 2. Use the selectNodes() method of the Document object to select all descendant elements of the fourth element. 3. Use a loop to display the baseName and text property for each element. Display a separate message box in each iteration of the loop. 4. Open NavigateNodes.htm with Internet Explorer. Click button 5. Five message boxes display the following text: Element name: description Element value: Silk tie Element name: price Element value: 32.50 Element name: discount-policy Element value: 3 25 Element name: items Element value: 3 Element name: discount Element value: 25

47

48


Exercise 3 Filtering Nodes and Merging Node-sets In this exercise, you will use XPath predicates to selectively filter nodes according to various criteria. You will also use the node-set union operator (“|”) to merge node-sets together.

To filter nodes using a simple predicate 1. In NavigateNodes.htm, locate the script function btn6_OnClick(). 2. Use the selectNodes() method of the Document object to get the code attribute for all elements whose child element is greater than 30.00. 3. Use a loop to display the text property for each attribute. 4. Open NavigateNodes.htm with Internet Explorer. Click button 6. Four message boxes display the following text: 123 789 321 987

To filter nodes using a complex predicate 1. In NavigateNodes.htm, locate the script function btn7_OnClick(). 2. Use the selectNodes() method to get the code attribute for all elements whose child element is greater than 30.00 and less than 50.00. 3. Use a loop to display the text property for each attribute. 4. Open NavigateNodes.htm with Internet Explorer. Click button 7. Two message boxes display the following text: 123 321

To filter nodes by the presence of child elements 1. Examine the XML document to see which elements have a child element. This product’s price is reduced if the child element is present and if the customer buys a certain number of items. 2. In NavigateNodes.htm, locate the script function btn8_OnClick(). 3. Use the SelectNodes() method of the Document object to get the code attribute for all elements that have a child element. 4. Use a loop to display the text property for each code attribute. 5. Open NavigateNodes.htm with Internet Explorer. Click button 8. Two message boxes display the following text: 321 654


49

To merge node-sets 1. In NavigateNodes.htm, locate the script function btn9_OnClick(). 2. Use the selectNodes() method of the Document object to get the code attribute and the element for all elements that have a child element. 3. Use a loop to display the text property for each code attribute and element. Display a separate message box for each item of information. 4. Open NavigateNodes.htm with Internet Explorer. Click button 9. Four message boxes display the code attribute and element for the two products that have a discount policy, as follows: 321 25 654 15

50


If Time Permits Using the XPath Core Function Library In this exercise, you will use the XPath core function library to define predicates that filter nodes by value.

To select nodes based on the absence of content 1. In NavigateNodes.htm, locate the script function btn10_OnClick(). 2. Use the selectNodes() method to get the code attribute for all elements that do not have a child element. 3. Use a loop to display the text property for each attribute. 4. Open NavigateNodes.htm with Internet Explorer. Click button 10. Four message boxes display the following text: 123 456 789 987

To select nodes based on string value 1. In NavigateNodes.htm, locate the script function btn11_OnClick(). 2. Use the SelectNodes() method to get the element for all elements that have the substring “sh” in the description. 3. Use a loop to display the text property for each element. 4. Open NavigateNodes.htm with Internet Explorer. Click button 11. Two message boxes display the following text: Plaid shirt Patent shoes

To select nodes based on numeric value 1. In NavigateNodes.htm, locate the script function btn12_OnClick(). 2. Use the selectNodes() method to get the element for all elements that have an odd code attribute (as opposed to an even code attribute). 3. Use a loop to display the text property for each element. 4. Open NavigateNodes.htm with Internet Explorer. Click button 12. Four message boxes display the following text: Blue jeans Leather jacket Silk tie Patent shoes


51

Best Practices

Use abbreviated syntax for axes

Avoid expensive selections such as //

Use an explicit path instead; for example, /*/product

Do not use count() to see if a node-set is empty

Easier to understand and maintain

Use last() instead

Do not use name() to test a node’s name

Use namespace-URI() and local-name() instead

Follow these best practices when using XPath.

Use Abbreviated Syntax Of the 13 axes that XPath defines for use in location steps, 5 of the most commonly used axes can use an abbreviated syntax. Use the abbreviated syntax rather than the unabbreviated syntax to improve the readability of your code and to make it easier to write. Consider the following facts and guidelines when writing syntactically abbreviated location paths:

The child axis is the default axis, so you should not need to use child:: explicitly.

The @ abbreviated syntax should be used instead of the unabbreviated attribute:: syntax.

The . abbreviated syntax should be used instead of the unabbreviated self::node() syntax.

The .. abbreviated syntax should be used instead of the unabbreviated parent::node() syntax.

The // abbreviated syntax should be used instead of the unabbreviated /descendant-or-self::node()/ syntax.

52


Avoid Expensive Selections Always consider how much work an XPath processor will have to do to build a node-set. Location paths such as //product can be extremely expensive, because the processor has to search the entire document for elements at any location. Where possible, use your knowledge of the tree structure to ease the load. For example, if elements are always direct children of the document element, then the following location path is much better than simply //product: /*/product

Do Not Use count() Unnecessarily The count() function requires an XPath processor to iterate a node-set in order to count the number of nodes it contains. Using the count() function is particularly inefficient in many XSLT constructs, such as in an loop. The last() function is more efficient than count() because the node-set is not recounted each time the loop increments.

Do Not Use name() to Test a Node’s Name The name() function returns a node’s namespace prefix and its local name. It is not a good idea to rely on the namespace prefix, because you can specify any prefix in an XML document. It is the namespace URI that matters, and this can be tested by using the namespace-uri() function.


Review

Introducing XPath



Using Expressions and Functions in Location Paths

1. How can XPath be used in the DOM to retrieve specific nodes from an XML document?

2. How does the XPath data model differ from the DOM data model, with respect to the properties available in each node?

3. How do you use location paths to select nodes in an XML document?

53

54


4. What is the difference between the child axis, the descendant axis, and the following axis?

5. Write an XPath expression that selects the first and last elements at any position in an XML document.

3016502

Recommend Documents