the simplest XPath takes a form such as

• /A/B/C

that selects C elements that are children of B elements that are children of the A element that forms the outermost element of the XML document. The XPath syntax is designed to mimic URI (Uniform Resource Identifier) and Unix-style file path syntax.

More complex expressions can be constructed by specifying an axis other than the default 'child' axis, a node test other than a simple name, or predicates, which can be written in square brackets after any step. For example, the expression

• A//B/[1]

selects the first child ('*[1]'), whatever its name, of every B element that itself is a child or other, deeper descendant ('//') of an A element that is a child of the current context node (the expression does not begin with a '/'). Note that the predicate [1] binds more tightly than the / operator. To select the first node selected by the expression A//B/*, write (A//B/*)[1]. Note also, index values in XPath predicates (technically, 'proximity positions' of XPath node sets) start from 1, not 0 as common in languages like C and Java.

Expanded syntax

In the full, unabbreviated syntax, the two examples above would be written

• /child::A/child::B/child::C
• child::A/descendant-or-self::node()/child::B/child[position()=1]

Here, in each step of the XPath, the axis (e.g. child or descendant-or-self) is explicitly specified, followed by :: and then the node test, such as A or node() in the examples above.

Axis specifiers

Axis specifiers indicate navigation direction within the tree representation of the XML document. The axes available are:

As an example of using the attribute axis in abbreviated syntax, //a/@href selects the attribute called href in a elements anywhere in the document tree.

The expression . (an abbreviation for self::node()) is most commonly used within a predicate to refer to the currently selected node.

For example, h3[.='See also'] selects an element called h3 in the current context, whose text content is See also.

Node tests

Node tests may consist of specific node names or more general expressions. In the case of an XML document in which the namespace prefix gs has been defined, //gs:enquiry will find all the enquiry elements in that namespace, and //gs* will find all elements, regardless of local name, in that namespace.

Other node test formats are:

{{mono|comment()}}

finds an XML comment node, e.g. <!-- Comment -->

{{mono|text()}}

finds a node of type text, e.g. the hello world in hello world

{{mono|processing-instruction()}}

finds XML processing instructions such as . In this case, processing-instruction('php') would match.

{{mono|node()}}

finds any node at all.

Predicates

Predicates, written as expressions in square brackets, can be used to filter a node-set according to some condition. For example, a returns a node-set (all the a elements which are children of the context node), and a[@href='help.php'] keeps only those elements having an href attribute with the value help.php.

There is no limit to the number of predicates in a step, and they need not be confined to the last step in an XPath. They can also be nested to any depth. Paths specified in predicates begin at the context of the current step (i.e. that of the immediately preceding node test) and do not alter that context. All predicates must be satisfied for a match to occur.

When the value of the predicate is numeric, it is syntactic-sugar for comparing against the node's position in the node-set (as given by the function position()). So p[1] is shorthand for p[position()=1] and selects the first p element child, while p[last()] is shorthand for p[position()=last()] and selects the last p child of the context node.

In other cases, the value of the predicate is automatically converted to a boolean. When the predicate evaluates to a node-set, the result is true when the node-set is {{clarify span|non-empty|date=December 2015}}. Thus p[@x] selects those p elements that have an attribute named x.

A more complex example: the expression a[/html/@lang='en'][@href='help.php'][1]/@target selects the value of the target attribute of the first a element among the children of the context node that has its href attribute set to help.php, provided the document's html top-level element also has a lang attribute set to en. The reference to an attribute of the top-level element in the first predicate affects neither the context of other predicates nor that of the location step itself.

Predicate order is significant if predicates test the position of a node. Each predicate takes a node-set returns a (potentially) smaller node-set. So a[1][@href='help.php'] will find a match only if the first a child of the context node satisfies the condition @href='help.php', while a[@href='help.php'][1] will find the first a child that satisfies this condition.

Functions and operators

XPath 1.0 defines four data types: node-sets (sets of nodes with no intrinsic order), strings, numbers and booleans.

The available operators are:

• The "/", "//" and "[...]" operators, used in path expressions, as described above.
• A union operator, "|", which forms the union of two node-sets.
• Boolean operators "and" and "or", and a function "not()"
• Arithmetic operators "+", "-", "", "div" (divide), and "mod"
• Comparison operators "=", "!=", "<", ">", "<=", ">="

The function library includes:

• Functions to manipulate strings: {{mono|concat(), substring(), contains(), substring-before(), substring-after(), translate(), normalize-space(), string-length()}}
• Functions to manipulate numbers: {{mono|sum(), round(), floor(), ceiling()}}
• Functions to get properties of nodes: {{mono|name(), local-name(), namespace-uri()}}
• Functions to get information about the processing context: {{mono|position(), last()}}
• Type conversion functions: {{mono|string(), number(), boolean()}}

Some of the more commonly useful functions are detailed below.^[7]

Node set functions

{{mono|position()}}

returns a number representing the position of this node in the sequence of nodes currently being processed (for example, the nodes selected by an xsl:for-each instruction in XSLT).

{{mono|count(node-set)}}

returns the number of nodes in the node-set supplied as its argument.

String functions

{{mono|string(object?)}}

converts any of the four XPath data types into a string according to built-in rules. If the value of the argument is a node-set, the function returns the string-value of the first node in document order, ignoring any further nodes.

{{mono|concat(string, string, string*)}}

concatenates two or more strings

{{mono|starts-with(s1, s2)}}

returns true if s1 starts with s2

{{mono|contains(s1, s2)}}

returns true if s1 contains s2

{{mono|substring(string, start, length?)}}

example: substring("ABCDEF",2,3) returns "BCD".

{{mono|substring-before(s1, s2)}}

example: substring-before("1999/04/01","/") returns 1999

{{mono|substring-after(s1, s2)}}

example: substring-after("1999/04/01","/") returns 04/01

{{mono|string-length(string?)}}

returns number of characters in string

{{mono|normalize-space(string?)}}

all leading and trailing whitespace is removed and any sequences of whitespace characters are replaced by a single space. This is very useful when the original XML may have been prettyprint formatted, which could make further string processing unreliable.

Boolean functions

{{mono|not(boolean)}}

negates any boolean expression.

{{mono|true()}}

evaluates to true.

{{mono|false()}}

evaluates to false.

Number functions

{{mono|sum(node-set)}}

converts the string values of all the nodes found by the XPath argument into numbers, according to the built-in casting rules, then returns the sum of these numbers.

Usage examples

Expressions can be created inside predicates using the operators: =, !=, <=, <, >= and >. Boolean expressions may be combined with brackets () and the boolean operators and and or as well as the not() function described above. Numeric calculations can use *, +, -, div and mod. Strings can consist of any Unicode characters.

//item[@price > 2*@discount] selects items whose price attribute is greater than twice the numeric value of their discount attribute.

Entire node-sets can be combined ('unioned') using the vertical bar character |. Node sets that meet one or more of several conditions can be found by combining the conditions inside a predicate with 'or'.

v[x or y] | w[z] will return a single node-set consisting of all the v elements that have x or y child-elements, as well as all the w elements that have z child-elements, that were found in the current context.

Syntax and semantics (XPath 2.0)

Examples

Given a sample XML document

The XPath expression

selects name attributes for all projects, and

selects all editions of all projects, and

selects addresses of all English Wikimedia projects (text of all edition elements where language attribute is equal to English). And the following

selects addresses of all Wikipedias (text of all edition elements that exist under project element with a name attribute of Wikipedia).

Implementations

Command-line tools

• XMLStarlet easy to use tool to test/execute XPath commands on the fly.
• xmllint (libxml2)
• RaptorXML Server from Altova supports XPath 1.0, 2.0, and 3.0

BASIC

• Pavuk XML Processor for QM/BASIC^[8]

C/C++

• libxml2
• Pathan
• pugixml
• Sedna XML Database
• VTD-XML
• Xalan
• XQilla

Free Pascal

• The unit XPath is included in the default libraries

Implementations for database engines

• OpenLink Virtuoso

Java

• Saxon XSLT supports XPath 1.0, XPath 2.0 and XPath 3.0 (as well as XSLT 2.0, XQuery 3.0, and XPath 3.0)
• BaseX (also supports XPath 2.0 and XQuery)
• VTD-XML
• Sedna XML Database Both XML:DB and proprietary.
• QuiXPath a streaming open source implementation by Innovimax
• Xalan
• Dom4j

The Java

package {{Javadoc:SE|package=javax.xml.xpath|javax/xml/xpath}} has been part of Java standard edition since Java 5 ^[9] via the Java API for XML Processing. Technically this is an XPath API rather than an XPath implementation, and it allows the programmer the ability to select a specific implementation that conforms to the interface.

JavaScript

• [https://github.com/ilinsky/jquery-xpath/ jQuery XPath plugin] based on [https://github.com/ilinsky/xpath.js Open-source XPath 2.0 implementation in JavaScript]
• [https://github.com/FontoXML/fontoxpath FontoXPath] Open source XPath 3.1 implementation in JavaScript. Currently under development.

.NET Framework

• In the System.Xml and System.Xml.XPath namespaces^[10]
• Sedna XML Database

Perl

• XML::LibXML (libxml2)

PHP

• Sedna XML Database

Python

• The [https://docs.python.org/2/library/xml.etree.elementtree.html ElementTree XML API] in the Python Standard Library includes [https://docs.python.org/2/library/xml.etree.elementtree.html#xpath-support limited support] for XPath expressions
• libxml2
• Amara
• Sedna XML Database
• lxml
• Scrapy^[11]

Ruby

• libxml2^[12]
• Nokogiri

Scheme

• Sedna XML Database

SQL

• MySQL supports a subset of XPath from version 5.1.5 onwards^[13]
• PostgreSQL supports XPath and XSLT from version 8.4 on^[14]

Tcl

• The [https://tdom.github.io/ tdom package] provides "a very complete, compliant and fast XPath implementation in C"

Use in schema languages

XPath is increasingly used to express constraints in schema languages for XML.

• The (now ISO standard) schema language Schematron pioneered the approach.
• A streaming subset of XPath is used in W3C XML Schema 1.0 for expressing uniqueness and key constraints. In XSD 1.1, the use of XPath is extended to support conditional type assignment based on attribute values, and to allow arbitrary boolean assertions to be evaluated against the content of elements.
• XForms uses XPath to bind types to values.
• The approach has even found use in non-XML applications, such as the source code analyzer for Java called PMD: the Java is converted to a DOM-like parse tree, then XPath rules are defined over the tree.

See also

• XPath 3
• Navigational database
• XLink
• XML database
• XSL
• XSL-FO

References

External links

• XPath 1.0 specification
• XPath 2.0 specification
• XPath 3.0 specification
• XPath 3.1 specification
• What's New in XPath 2.0
• XPath Reference (MSDN)
• XPath Expression Syntax (Saxon)
• XPath 2.0 Expression Syntax (Saxon),  
• [https://developer.mozilla.org/en/XPath XPath - MDC Docs] by [https://developer.mozilla.org Mozilla Developer Network]
• XPath introduction/tutorial
• XSLT and XPath function reference