XPath CheatSheet

It uses a non-XML syntax to provide a flexible way of addressing (pointing to) different parts of an XML document. It can also be used to test addressed nodes within a document to determine whether they match a pattern or not.

• XPath is a major element in the XSLT standard.
• XPath can be used to navigate through elements and attributes in an XML document.
• XPath stands for XML Path Language
• XPath uses "path like" syntax to identify and navigate nodes in an XML document
• XPath contains over 200 built-in functions
• XPath is a major element in the XSLT standard
• XPath is a W3C recommendation

XPath is a specification for a query language that locates and extracts data from XML documents, and a comprehensive set of functions for the manipulation of that data. XPath is used to identify, filter, and test nodes and content; and to apply functions or operations on the resulting data sets.

XML provides tree-structured data objects. Each tag in an XML document is a node in the tree. A tag can contain attributes, other tags, and raw data content: these are also nodes in the tree. A valid XML document has exactly one node at the root of its tree. Contained by that node are its children and, contained in those children, descendent nodes branching out until reaching terminal nodes that contain only data content.

XPath provides a language with which to locate nodes, by identifying the nodes address or by finding nodes using tests or filters, and to perform operations on the identified nodes.

In identifying the location of a node, XPath uses the concept of an axis, which describes the relationship between the node that is currently identified (the context) and the node that one wants to locate. These axes include familial relations (parent, child, descendent, sibling, etc.), linear relations (preceding, following, etc.), and two XML markup identifies (attribute and namespace). Combined with tests and filters, XPath provides an immensely powerful but succinct way to exactly identify a specific node or collection of nodes.

An example XPath statement can illustrate this power. The only further knowledge you require is that the slash character is used to separate steps in the traversal; double colons separate axes from tag names, and square brackets contain filtering statements.

Testing these command in Firefox or Chrome console:
$x('/html/body')
$x('//h1')
$x('//h1')[0].innerText
$x('//a[text()="XPath"]')[0].click()

//div[true()]
//div[@class="head"]
//div[@class="head"][@id="top"]

# Comparison
//a[@id = "abcdef"]
//a[@id != "abcdef"]
//a[@yourPrice > 5000]

# Logic (and/or)
//div[@id="head" and position()=10]
//div[(xa and ya) or not(za)]

# Use it inside functions
//ul[count(li) > 5]
//ul[count(li[@class='hide']) > 5]

# Returns '<ul>' that has a '<li>' child
//ul[li]

# first for tag <a>
//a[1]

# last for tag <a>                
//a[last()]

# second <li>
//ol/li[2]

# same as above        
//ol/li[position()=2] 

//ol/li[position() > 1] #:not(:first-child)

a[1][@href='/']
a[@href='/'][1]

//section[.//h1[@id='hi']]

Example

name()            # //[starts-with(name(), 'cool')]
text()            # //button[text()="Submit"]
                  # //button/text()
lang(str)
namespace-uri()

count()           # //table[count(tr)=1]
position()        # //ol/li[position()=2]

Example

contains()        # font[contains(@class,"head")]
starts-with()     # font[starts-with(@class,"head")]
ends-with()       # font[ends-with(@class,"head")]

concat(x,y)
substring(str, start, len)
substring-before("01/02", "/")  # Result: 01
substring-after("01/02", "/")   # Result: 02
translate()
normalize-space()
string-length()

not(expr)         # button[not(starts-with(text(),"Submit"))]

string()
number()
boolean()

//ul/li                       # ul > li
//ul/child::li                # ul > li (same)
//ul/following-sibling::li    # ul ~ li
//ul/descendant-or-self::li   # ul li
//ul/ancestor-or-self::li     # $('ul').closest('li')

# both the same
//ul/li/a
//child::ul/child::li/child::a

# both the same
# this works because `child::li` is truthy 
//ul[li]
//ul[child::li]
# both the same
//ul[count(li) > 2]
//ul[count(child::li) > 2]

# both the same
//div//h4
//div/descendant-or-self::h4

# both the same
//ul//[last()]
//ul/descendant-or-self::[last()]

//a | //span