XPath is a pattern expression used to select a set of XML nodes.
You can select:
In the XPath specification, the document model defines seven kinds of nodes. See XSLT/XPath - (Data|Document) Model
This is a pipeline syntax that should read from left to right with the command being separated by a / or //
For instance:
//h1[1]/following-sibling::*
should be read:
The namespace is mandatory.
If your client does not support the detection of the namespace and don't set it as default, you need to use the fully qualified name
/ns:rootNodeName/ns:childNodeName
or use a query on the local name
/*[local-name()='rootNodeName']/*[local-name()='childNodeName']
If the document is an xhtml document, we can get all anchor node with:
//a
where:'
The same as full qualified expression working for all namespace would be:
//*[local-name()='whateever']
where:
The below expression will select:
//*[@id="myid"]//a[1]
//*[namespace-uri()='http://mynamespaceUri']
where:
With a prefix (not in XPath, an unprefixed name is always considered to be in namespace with blank URI)
Example in a stylesheet:
<xsl:stylesheet ... xmlns:my="http://mynamespaceUri">
<xsl:template match="/my:MyRoot"> ... </xsl:template>
</xsl:stylesheet>
https://www.w3.org/TR/1999/REC-xpath-19991116/#path-abbrev
There is two syntax:
Example: select all para in the tree
An XML document is a tree-structured (hierarchical) collection of nodes. As with a hierarchical directory structure, it is useful to specify a path that points to a particular node in the hierarchy (hence the name of the specification: XPath).
In fact, much of the notation of directory paths is carried over intact:
| Character | Designation | Signification | Tip |
|---|---|---|---|
| / | The forward slash | Path separator | An absolute path from the root of the document starts with a /. A relative path from a given location starts with anything else. |
| .. | A double period | The parent of the current node | And its content for the functions |
| . | A single period | The current node | And its content for the functions |
For example, in an Extensible HTML (XHTML) document, the path /h1/h2/ would indicate an h2 element under an h1. (Recall that in XML, element names are case-sensitive, so this kind of specification works much better in XHTML than it would in plain HTML, because HTML is case-insensitive).
A name specified in an XPath expression refers to an element. For example, h1 in /h1/h2 refers to an h1 element.
In a pattern-matching specification such as XPath, the specification /h1/h2 selects all h2 elements that lie under an h1 element.
See XPATH - (Node) Attribute (@)
The full range of XPath expressions takes advantage of the wild cards, operators, and functions that XPath defines.
The square-bracket notation ([]) is normally associated with indexing.
To select a specific h2 element, you use square brackets [] for indexing. The path /h1[4]/h2[5] would therefore select the fifth h2 element under the fourth h1 element.
The function position() gives you the element index. Then /h1[4] is the same that /h1[position()=4]
The expression @type=“unordered” specifies an attribute named type whose value is unordered. An expression such as LIST/@type specifies the type attribute of a LIST element.
The expression LIST[@type=“unordered”] selects all LIST elements whose type value is unordered.
Examples that use the extended square-bracket notation:
The XPath specification defines quite a few addressing mechanisms, and they can be combined in many different ways in order to get interesting combinations:
Many more combinations of address operators are listed in section 2.5 of the XPath specification. This is arguably the most useful section of the specification for defining an XSLT transform.
By definition, an unqualified XPath expression selects a set of XML nodes that matches that specified pattern.
For example, /HEAD matches all top-level HEAD entries, whereas /HEAD[1] matches only the first.
| Wild card | Meaning |
|---|---|
| * | Matches any element node |
| node() | Matches any node of any kind: element node, text node, attribute node, processing instruction node, namespace node, or comment node. |
| text() | selects all text node |
| @* | Matches any attribute node. |
In the project database example, /*/PERSON[.=“Fred”] matches any PROJECT or ACTIVITY element that names Fred.
The first child of the main element is done via indexing.
//main/*[1]
sibling selection:
//h2[1]/preceding-sibling::*
//h2[2]/following-sibling::*
div1//para
is short for
child::div1/descendant-or-self::node()/child::para
So far, all the patterns you have seen have specified an exact number of levels in the hierarchy.
For example, /HEAD specifies any HEAD element at the first level in the hierarchy, whereas /*/* specifies any element at the second level in the hierarchy.
To specify an indeterminate level in the hierarchy, use a double forward slash (//).
For example, the XPath expression //PARA selects all paragraph elements in a document, wherever they may be found.
The // pattern can also be used within a path. So the expression
/HEAD/LIST//PARA
indicates all paragraph elements in a subtree that begins from /HEAD/LIST.
// is short for /descendant-or-self::node()/.
For example, //para is short for /descendant-or-self::node()/child::para and so will select any para element in the document.
XPath expressions yield either a set of nodes, a string, a Boolean (a true/false value), or a number.
| Operator | Meaning |
|---|---|
| | | Alternative. For example, PARA|LIST selects all PARA and LIST elements. |
| or, and | Returns the or/and of two Boolean values. |
| =, != | Equal or not equal, for Booleans, strings, and numbers. |
| <, >, ⇐, >= | Less than, greater than, less than or equal to, greater than or equal to, for numbers. |
| +, -, *, div, mod | Add, subtract, multiply, floating-point divide, and modulus (remainder) operations (e.g., 6 mod 4 = 2). |
Expressions can be grouped in parentheses, so you do not have to worry about operator precedence.
Note - Operator precedence is a term that answers the question, “If you specify a + b * c, does that mean (a+b) * c or a + (b*c)?” (The operator precedence is roughly the same as that shown in the table).
The string-value of an element is the concatenation of all descendent text nodes, no matter how deep. Consider this mixed-content XML data:
<PARA>This paragraph contains a <b>bold</b> word</PARA>
The string-value of the <PARA> element is “This paragraph contains a bold word”. In particular, note that <B> is a child of <PARA> and that the text bold is a child of <B>.
The point is that all the text in all children of a node joins in the concatenation to form the string-value.
Also, it is worth understanding that the text in the abstract data model defined by XPath is fully normalized. So whether the XML structure contains the entity reference < or < in a CDATA section, the element's string-value will contain the < character. Therefore, when generating HTML or XML with an XSLT stylesheet, you must convert occurrences of < to < or enclose them in a CDATA section. Similarly, occurrences of & must be converted to &.
If you manipulate a XHTML document, if you want to find all element where the class attribute contains 3) the value value
//*[contains(@class,'value')]
The XPath specification 4) is the foundation for a variety of specifications: