Can I refactor to avoid "self::" and "parent::"?

Question

I want to extract //pre and //code elements but exclude //pre/code. For example:

<root>
    <pre><code>foo</code></pre>
    <code>bar</code>
    <pre>baz</pre>
    <span>ignore me<code>select me</code></span>
</root>

I want to retrieve four elements:

<pre><code>foo</code></pre>
<code>bar</code>
<pre>baz</pre>
<code>select me</code>

(And I specifically don't want <code>foo</code>)

The following xpath seems to do the trick:

//*[(self::pre or self::code) and not (self::code and parent::pre)]

I don't know if that's the right approach, but it seems to work.

Is there a less verbose way to express this (e.g. that doesn't require self:: and parent::)?

Isn't `//*[(self::pre or self::code)` the same as `(//pre union //code)`? — biziclop, Mar 14 '16 at 15:42

score 3 · Accepted Answer · edited May 23 '17 at 11:59

Trying to eliminate self:: and parent:: isn't really a laudable goal in general. You may be searching for an abbreviation of those axes in the hope that they'll allow a shortened equivalent form of expression.

This is understandable given, for example, that the child axis,

/child::a/child:b

can be more concisely written

/a/b

What are the parallel abbreviations for self:: and parent::?

self::node() can be abbreviated .
parent::node() can be abbreviated ..

However, these are more useful in cases where the name of the context node or its parent are immaterial — not so in your case. (For example, ./ is used for a relative path as opposed to / for an absolute path; ../@attr is used to refer to the attr attribute of the parent element as opposed to @attr for the context element.)

So, in short, other than logical simplification as suggested by @JLRishe, your XPaths are reasonably simple already. Axes abbreviations aren't going to be of much help.

Answer updated to reflect (I hope) a better understanding of the essence of your question. — kjhughes, Mar 14 '16 at 18:01
Thanks a lot. You've helped me understand much more clearly what my XPath expression actually means. — ᴇʟᴇvᴀтᴇ, Mar 14 '16 at 18:42

score 2 · Answer 2 · answered Mar 14 '16 at 16:03

What you have there seems like a fine reason to use self:: and pre::. I don't think there's a better way to express it without them.

Note, however, that your condition has more operands than it needs. You could express the same thing like this:

//*[self::pre or (self::code and not(parent::pre))]

Can I refactor to avoid "self::" and "parent::"?

2 Answers2