I have a small problem with XPath contains with dom4j ...
Let's say my XML is
<Home>
<Addr>
<Street>ABC</Street>
<Number>5</Number>
<Comment>BLAH BLAH BLAH <br/><br/>ABC</Comment>
</Addr>
</Home>
Let's say I want to find all the nodes that have ABC in the text given the root Element...
So the XPath that I would needed to write would be
//*[contains(text(),'ABC')]
However this is not what dom4j returns .... is this a dom4j problem or my understanding how XPath works, since that query returns only the Street
element and not the Comment
element?
The DOM makes the Comment
element a composite element with four tags two
[Text = 'XYZ'][BR][BR][Text = 'ABC']
I would assume that the query should still return the element since it should find the element and run contains on it, but it doesn't ...
The following query returns the element, but it returns far more then just the element – it returns the parent elements as well, which is undesirable to the problem.
//*[contains(text(),'ABC')]
Does any one know the XPath query that would return just the elements <Street/>
and <Comment/>
?
//*[contains(text(),'ABC')]
returns only the <Street>
element. It doesn't return any ancestors of <Street>
or <Comment>
.
The <Comment>
tag contains two text nodes and two <br>
nodes as children.
Your xpath expression was
//*[contains(text(),'ABC')]
To break this down,
* is a selector that matches any element (i.e. tag) -- it returns a node-set. The [] are a conditional that operates on each individual node in that node set. It matches if any of the individual nodes it operates on match the conditions inside the brackets. text() is a selector that matches all of the text nodes that are children of the context node -- it returns a node set. contains is a function that operates on a string. If it is passed a node set, the node set is converted into a string by returning the string-value of the node in the node-set that is first in document order. Hence, it can match only the first text node in your
You need to change this to
//*[text()[contains(.,'ABC')]]
* is a selector that matches any element (i.e. tag) -- it returns a node-set. The outer [] are a conditional that operates on each individual node in that node set -- here it operates on each element in the document. text() is a selector that matches all of the text nodes that are children of the context node -- it returns a node set. The inner [] are a conditional that operates on each node in that node set -- here each individual text node. Each individual text node is the starting point for any path in the brackets, and can also be referred to explicitly as . within the brackets. It matches if any of the individual nodes it operates on match the conditions inside the brackets. contains is a function that operates on a string. Here it is passed an individual text node (.). Since it is passed the second text node in the
The XML document:
<Home>
<Addr>
<Street>ABC</Street>
<Number>5</Number>
<Comment>BLAH BLAH BLAH <br/><br/>ABC</Comment>
</Addr>
</Home>
The XPath expression:
//*[contains(text(), 'ABC')]
//*
matches any descendant element of the root node. That is, any element but the root node.
[...]
is a predicate, it filters the node-set. It returns nodes for which ...
is true
:
A predicate filters a node-set [...] to produce a new node-set. For each node in the node-set to be filtered, the PredicateExpr is evaluated [...]; if PredicateExpr evaluates to true for that node, the node is included in the new node-set; otherwise, it is not included.
contains('haystack', 'needle')
returns true
if haystack
contains needle
:
Function: boolean contains(string, string) The contains function returns true if the first argument string contains the second argument string, and otherwise returns false.
But contains()
takes a string as its first parameter. And it's passed nodes. To deal with that every node or node-set passed as the first parameter is converted to a string by the string()
function:
An argument is converted to type string as if by calling the string function.
string()
function returns string-value
of the first node:
A node-set is converted to a string by returning the string-value of the node in the node-set that is first in document order. If the node-set is empty, an empty string is returned.
string-value
of an element node:
The string-value of an element node is the concatenation of the string-values of all text node descendants of the element node in document order.
string-value
of a text node:
The string-value of a text node is the character data.
So, basically string-value
is all text that is contained in a node (concatenation of all descendant text nodes).
text()
is a node test that matches any text node:
The node test text() is true for any text node. For example, child::text() will select the text node children of the context node.
Having that said, //*[contains(text(), 'ABC')]
matches any element (but the root node), the first text node of which contains ABC
. Since text()
returns a node-set that contains all child text nodes of the context node (relative to which an expression is evaluated). But contains()
takes only the first one. So for the document above the path matches the Street
element.
The following expression //*[text()[contains(., 'ABC')]]
matches any element (but the root node), that has at least one child text node, that contains ABC
. .
represents the context node. In this case, it's a child text node of any element but the root node. So for the document above the path matches the Street
, and the Comment
elements.
Now then, //*[contains(., 'ABC')]
matches any element (but the root node) that contains ABC
(in the concatenation of the descendant text nodes). For the document above it matches the Home
, the Addr
, the Street
, and the Comment
elements. As such, //*[contains(., 'BLAH ABC')]
matches the Home
, the Addr
, and the Comment
elements.
[contains(text(),'')]
only returns true or false. It won't return any element results.
contains(text(),'JB-')
is not work! conatains
takes two strings as arguments - contains(**string**, **string**)
! text() is not string, is a function!
The accepted answer will return all the parent nodes too. To get only the actual nodes with ABC even if the string is after :
//*[text()[contains(.,'ABC')]]/text()[contains(.,"ABC")]
/..
like so: //*[text()[contains(.,'ABC')]]/text()[contains(.,"ABC")]/..
Thanks! @roger
//*[text()='ABC']
returns
<street>ABC</street>
<comment>BLAH BLAH BLAH <br><br>ABC</comment>
Modern answer that covers XPath 1.0 vs XPath 2.0+ behavior ...
This XPath,
//*[contains(text(),'ABC')]
behaves differently with XPath 1.0 and later versions of XPath (2.0+).
Common behavior
//* selects all elements within a document.
[] filters those elements according to the predicate expressed therein.
contains(string, substring) within the predicate will filter those elements to those for which substring is a substring in string.
XPath 1.0 behavior
contains(string, substring) will convert a node set to a string by taking the string value of the first node in the node set.
For //*[contains(text(),'ABC')] that node set will be all child text nodes of each element in the document.
Since only the first text node child is used, the expectation that all child text nodes are tested for 'ABC' substring containment is violated.
This leads to counter-intuitive results to anyone unfamiliar with the above conversion rules.
XPath 1.0 online example shows that only one 'ABC'
is selected.
XPath 2.0+ behavior
It is an error to call contains(string, substring) with a sequence of more than one item as the first argument.
This corrected the counter-intuitive behavior described above in XPath 1.0.
XPath 2.0 online example shows a typical error message due to the conversion error particular to XPath 2.0+.
Common solutions
If you wish to include descendent elements (beyond children), test against the string value of an element as a single string, rather than the individual string values of the child text nodes, this XPath, //*[contains(.,'ABC')] selects your targeted Street and Comment elements and also their Addr and Home ancestor elements because those too have 'ABC' as substrings of their string values. Online example shows ancestors being selected too. If you wish to exclude descendent elements (beyond children), this XPath, //*[text()[contains(.,'ABC')]] selects only your targeted Street and Comment because only those elements have text node children whose string values contain the 'ABC' substring. This will be true for all versions of XPath Online example shows only Street and Comment being selected.
Here is an alternate way to match nodes which contain a given text string. First query for the text node itself, then get the parent:
//text()[contains(., "ABC")]/..
For me this is easy to read and understand.
This is the best answer for the topic question:
//*[text()[contains(.,'ABC')]]/text()[contains(.,"ABC")]
An example: example case
Xpath to get bon dua madam
//h3[text()='Contact Information']/parent::div/following-sibling::div/p[text()[contains(.,'bon dua madam')]]/text()[contains(.,'bon dua madam')]
It took me a little while but finally figured out. Custom xpath that contains some text below worked perfectly for me.
//a[contains(text(),'JB-')]
contains(text(),'JB-')
is not work! conatains
takes two strings as arguments - contains(**string**, **string**)
! text() is not string, is a function!
Success story sharing
//*[contains(., 'ABC')]
. I had always used the pattern given by Mike Milkin, thinking it was more appropriate, but just doingcontains
on the current context seems to actually be what I want more often.//*[text()[contains(.,'ABC')]]
means any element for whichtext()[contains(.,'ABC')]
istrue
.text()[contains(.,'ABC')]
is a node-set of all text node children of the context node for whichcontains(.,'ABC')
istrue
. Sincetext()[contains(.,'ABC')]
is a node-set, it's converted to boolean byboolean()
function. For a node-set,boolean()
returnstrue
if it's not empty.