XPath Tutorial for Beginners

With the prevalence of XML as the markup language for platform-independent data exchanges, there is an increasing need for a standard that enables non-XML-based applications to submit complex queries to XML documents.

The relevant standards for program-controlled access to XML documents was developed by the W3 Consortium along with XQuery and XSLT. These have program interfaces available that can access applications on XML documents, query content or transform XML documents. They require a standard that enables elements in XML documents to be addressed: the XPath path description language.

We’ll get you started with the XPath Data Model (XDM) and introduce to you to the syntax that underlines the XPath expressions used to localize XML elements.

XML Path Language (XPath) is a path description language for XML documents developed by the W3 Consortium. XPath provides users with non-XML-based syntax that makes it possible to specifically address the elements of an XML document.

XPath is normally used in an embedded host language that enables the addressed XML elements to be processed. XQuery, for example, is used to query the XML elements addressed by XPath. XSLT uses the query language when transforming XML documents.

• XPath: Navigation in XML documents
• XQuery: Queries for XML documents
• XSLT: Transformation of XML documents

3.1, the current XPath version, is specified in the W3C recommendation from March 21, 2017.

A data model underlies XPath and this interprets XML documents as a sequence of elements that are arranged in a tree structure. The tree structure of the XPath data model is comparable to the Document Object Model (DOM). This also acts as an interface between HTML and dynamic JavaScript in the web browser.

In the form of paths, the localization of XML elements occurs based on the unix directory system. The basic elements of this localization path are nodes, axes, node tests and predicates.

The individual elements of an XPath tree structure are referred to as nodes. Ordering the nodes occurs both through the document sequence and through nesting the XML elements.

The XPath data model distinguishes seven node types with different functions:

• Element node
• Document node (from XPath 2.0 onwards—previously they were known as root nodes)
• Attribute node
• Text node
• Namespace node
• Processing instruction node
• Comment node

The following example illustrates the XPath data model node types. The XML document below, used to exchange data for a book order, contains all seven node types.

In the XPath data model tree structure, each XML document element corresponds to an element node. Some exceptions are the XML declaration and the document definition at the beginning of the document.

XML declaration:

Document Type Definition (DTD):

Element nodes begin with a start tag, finish with an end tag and are usually nested into each other.

The first element nodes in the document sequence are referred to as root elements.

The XML document pictured above, for example, contains the element node order as a root element. This acts as a parent element for the subordinated element nodes address, comment and items that again contain additional element nodes as child elements.

The roots of the tree structure are referred to as document nodes. In the XML document itself, this is neither demonstrated visually nor represented by text. It is a conceptual node that contains all the other elements of a node. Child elements of the document node are root elements as well as (where applicable) processing instruction nodes and comment nodes.

The attributes of an XML element are represented in the XPath data model as attribute nodes. Each attribute node consists of an identifier and a value assigned to the attribute.

In the code example, the first element node contains book and the attribute node isbn with the value 9781408845660.

Attribute nodes are considered part of the element node, but not a child element of the element.

Character data within the start and end tags of an element node are referred to as text nodes.

In the code example, the element node contains title and the text node contains Harry Potter and the Prisoner of Azkaban.

In the case of well-formed XML documents, the element and attribute names being used are assigned a namespace. The assignment usually occurs through the Document Type Definition right at the beginning of the document.

If different namespaces are used in an XML document element or attribute, the respective namespaces will be explicitly defined with the xmlns attribute or xmlns prefix in the start tag of the element in question. The attribute xmlns presumes a Uniform Resource Identifier (URI) as a value that specifies which namespace is to be assigned to the corresponding element. The option of assigning a namespace to an xmlns prefix is possible for the element or child element. Each namespace corresponds to a namespace node in the tree structure.

In the code example, two namespaces were defined for the XML element address: xmlns:shipping and xmlns:billing. The child elements of the address element bear the respective assignment as a prefix.

The xmlns prefix makes it possible to clearly assign elements of the same name from different namespaces. The element street with the prefix shipping, for example, contains the street specified in the delivery address. The element street with the prefix billing, in contrast, contains the street specified in billing address.

Processing instructions in XML documents are located outside the document tree structure and are referred to in XPath terminology as a processing instruction node. A process instruction node begins with <? and ends with ?>.

In the code example presented above you find the following processing instruction:

The XML declaration at the beginning of the XML file is syntactically constructed like a process instruction. However, it is not valid as a process instruction node as defined by the XPath data model.

XML document content marked as a comment will be processed by XPath as a comment node. In this situation, the node comprises only the marked character content, not the markup.

In the code example presented above, you find the following comment node:

Addressing nodes occurs with the help of a localization path. With localization paths, it is a matter of using an XPath expression to navigate through the tree structure and to choose a desired node set. The node set is the outcome of an XPath expression.

Localization paths are evaluated from left to right. One distinguishes between absolute and relative localization paths. An absolute localization path begins at the document node. In this case, you prefix the XPath expression with a slash (/). Relative localization paths begin at an arbitrary node within the tree structure. This starting point is called the context node.

A localization path consists of individual localization steps that, as is the case when addressing files in the directory system, are separated by a slash (/).

Each localization step consists of up to three parts: the axis, the node test and an arbitrary number of predicates.

• Axis: When choosing the axis, you determine the navigation direction in the tree structure starting from the context or document node.
• Node test: The node test corresponds to a filter with which you limit the notes lying on the axis to the desired node set.
• Predicates: Predicates enable you to again filter the nodes selected through the axis and node test.

The localization path for an XPath expression is notated in accordance with the following syntax:

The XPath syntax enables a navigation by means of the following axes.

For example, all child:: elements choose D from the context node. The node set comprises the nodes E, H and I.

With the node test you define a filter for the node set selected via the axis. According to the XPath specification there are two possible filter criteria.

• Node name: Specify a node name as a node test in order to choose all nodes with the corresponding name on the chosen axis.
• Node type: Specify a node type as a node test in order to choose all nodes on the chosen axis with the corresponding type.

With the following localization path, for example, you could choose—based on the code example presented above—all descendants with the name book starting from the document node.

If, however, you would like to filter out the attribute isbn for all element nodes with the name book, you’ll need a localization path with two localization steps.

If you’d like to define a node type as a filter criterion for selecting the node set, use one of the following functions as a node test:

If you use the place holder * (asterisk) instead of the node test, all nodes will be chosen on the selected axis that correspond to the axis’ main node type. So, if an axis contains element nodes, then this node type is the axis’ main node type. This applies to all axes with the exception of attribute and namespace. In this case, attribute nodes or namespace nodes qualify as main node types.

The following localization path, for example, displays all the attributes of the current context node:

For the frequently-used axes and localization steps, short cuts were defined that can be used in the XPath expression as an alternative to the English designations.

With predicates you define further filter criteria for the node sets selected through the axis and node test.

Predicates form the optional third part of a localisation step and are notated in brackets. The filter criteria within the brackets is formulated as expressions, that, among other things, can contain path expressions, functions, operators and strings.

The XPath syntax supports universal predicates and numerical predicates.

Expressions in universal predicates filter the node set that has been selected through the axis and node test by issuing a Boolean value (true or false) for each node in the selection. All nodes with the value true are part of the result set.

The formulation of expressions for universal predicates occurs with the help of operators. These are used in order to specifically select specific nodes with specific content or properties—for example, all nodes that include a character string, an attribute value or a specific child element (perhaps at a specific position).

The following tables give you an overview of the operators that are available. There is a distinction between arithmetic operators, logical operators and relational operators.

In the following example the predicate isolates [title="Harry Potter and the Prisoner of Azkaban"] the result set on an element node called book, which contains the child element title and the string Harry Potter and the Prisoner of Azkaban.

We have now chosen the element node book, which contains the data for the Harry Potter book.

Another child element of this element node is the comment element. If we would like to select its content, the localization path must only be expanded by two localization steps.

We navigate with the comment localization step (abbreviate form of child::comment) to the book element’s child element of the same name and select its text node with the text() function. This corresponds to the following string:

Should only a path expression be used in a predicate, then it’s called an existence test. With the following localization path, for example, it can be tested if the XML document presented above contains one or several nodes with the name comment.

Shortened notation:

Standard notation:

The localization path //book[comment] selects all nodes with the name book that have a child element with the name comment.

Numerical predicates enable you to address nodes using your position. The following localization path, for example, selects the second node in accordance with the document sequence with the name book:

Strictly speaking, predicate [2] is the abbreviated form of [position()=2]. XPath thus initially selects all nodes with the name “book” and then filters out the node for which the position()=2 function yields the true Boolean value.

On the W3C website you will find an overview of the current development status of XML Path language as well as all released standards and designs.

Free information and tools for using XPath for web applications are available to you at MDN Web Docs as well as in the Microsoft Developer Network.