XML::XPath(3)

📦

version 1.49 · 13 versions

💖 XML::XPath 💖

okay bestie, welcome to the XML::XPath(3) page — yes that's the manual name, and yes it's a whole vibe. This is where we learn to parse and evaluate XPath statements, and honestly? iconic behavior.

✨ NAME ✨

XML::XPath — Parse and evaluate XPath statements. that's it. that's the whole name. slay.

🎀 VERSION 🎀

Version 1.49 — no cap, that's the one.

🌸 DESCRIPTION 🌸

okay so the whole goal here: this module is trying so hard (affectionate) to comply exactly to the XPath specification at http://www.w3.org/TR/xpath, and yet still let extensions get added in the form of functions. modules like XSLT and XPointer might need to do this, because they support functionality that goes beyond XPath. it's giving "we color inside the lines but we also brought our own glitter pens" 💅

🦋 SYNOPSIS 🦋

use XML::XPath;
use XML::XPath::XMLParser;

my $xp = XML::XPath->new(filename => 'test.xhtml');

my $nodeset = $xp->find('/html/body/p'); # find all paragraphs

foreach my $node ($nodeset->get_nodelist) {
    print "FOUND\n\n",
        XML::XPath::XMLParser::as_string($node),
        "\n\n";
}

look at that. it's chef's kiss. find all the paragraphs, print them, live your truth.

🔥 DETAILS 🔥

ngl there is an awful lot to all of this, so bear with it — if you stick it out it should be worth it, fr fr. please get a good understanding of XPath by reading the spec before asking me questions, bestie, i'm begging 🙈.

All of the classes and parts herein are named to be synonymous with the names in the specification, so consult that if you don't understand why something in the code is the way it is. the naming is intentional, i promise.

Currently, it supports XPath 1.0 with a small number of XPath 2.0 functions. See XML::XPath::Function for the complete list of predefined functions. 👑

💅 METHODS 💅

The API of XML::XPath itself is extremely simple to allow you to get going almost immediately — lowkey the easiest part of this whole module. The deeper API's are more complex, but you shouldn't have to touch most of that. 🫶

🌟 `new()`

This constructor follows the often seen named parameter method call. Parameters you can use are: filename, parser, xml, ioref and context.

The filename parameter specifies an XML file to parse.
The xml parameter specifies a string to parse.
The ioref parameter specifies an ioref to parse.
The context option allows you to specify a context node. The context node has to be in the format of a node as specified in XML::XPath::XMLParser.

The 4 parameters filename, xml, ioref and context are mutually exclusive — you should only specify one. (If you specify anything other than context, the context node is the root of your document.) The parser option allows you to pass in an already prepared XML::Parser object, to save you having to create more than one in your application (if, for example, you are doing more than just XPath). 💖

my $xp = XML::XPath->new( context => $node );

It is very much recommended that you use only 1 XPath object throughout the life of your application. This is because the object (and it's sub-objects) maintain certain bits of state information that will be useful (such as XPath variables) to later calls to find(). It's also a good idea because you'll use less memory this way. main character energy: one object, one destiny ✨

🌈 `find($path, [$context])`

The find function takes an XPath expression (a string) and returns either an XML::XPath::NodeSet object containing the nodes it found (or empty if no nodes matched the path), or one of XML::XPath::Literal (a string), XML::XPath::Number or XML::XPath::Boolean.

It should always return something — and you can use ->isa() to find out what it returned. If you need to check how many nodes it found you should check $nodeset->size. See XML::XPath::NodeSet.

An optional second parameter of a context node allows you to use this method repeatedly — for example XSLT needs to do this. 🎀

⭐ `findnodes($path, [$context])`

Returns a list of nodes found by $path, optionally in context $context. In scalar context returns an XML::XPath::NodeSet object.

💜 `matches($node, $path, [$context])`

Returns true if the node matches the path (optionally in context $context). vibe check passed ✅

🍓 `findnodes_as_string($path, [$context])`

Returns the nodes found reproduced as XML. The result isn't guaranteed to be valid XML though. so like… mostly fine. probably. 🙈

🧚 `findvalue($path, [$context])`

Returns either a "XML::XPath::Literal", a "XML::XPath::Boolean" or a "XML::XPath::Number" object.

If the path returns a NodeSet, $nodeset->to_literal is called automatically for you (and thus a "XML::XPath::Literal" is returned).

Note that for each of the objects stringification is overloaded, so you can just print the value found, or manipulate it in the ways you would a normal perl value (e.g. using regular expressions). it's giving "just works" 💅

🌸 `exists($path, [$context])`

Returns true if the given path exists.

🦋 `getNodeText($path)`

Returns the XML::XPath::Literal for a particular XML node. Returns a string if it exists, or '' (empty string) if the node doesn't exist.

🎀 `setNodeText($path, $text)`

Sets the text string for a particular XML node. The node can be an element or an attribute. If the node to be set is an attribute, and the attribute node does not exist, it will be created automatically. no manual labor required ✨

👑 `createNode($path)`

Creates the node matching the $path given. If part of the path given or all of the path do not exist, the necessary nodes will be created automatically.

🔥 `set_namespace($prefix, $uri)`

Sets the namespace prefix mapping to the uri.

Normally in "XML::XPath" the prefixes in XPath node test take their context from the current node. This means that foo:bar will always match an element <foo:bar> regardless of the namespace that the prefix foo is mapped to (which might even change within the document, resulting in unexpected results 👀). In order to make prefixes in XPath node tests actually map to a real URI, you need to enable that via a call to the set_namespace method of your "XML::XPath" object.

💖 `clear_namespaces()`

Clears all previously set namespace mappings. bye bye 👋

🌟 `$XML::XPath::Namespaces`

Set this to 0 if you don't want namespace processing to occur. This will make everything a little (tiny) bit faster, but you'll suffer for it, probably. 😭

seriously. tiny. bit. faster. that's the whole trade. you have been warned.

🧸 Node Object Model

See XML::XPath::Node, XML::XPath::Node::Element, XML::XPath::Node::Text, XML::XPath::Node::Comment, XML::XPath::Node::Attribute, XML::XPath::Node::Namespace, and XML::XPath::Node::PI. collect them all 🌈

💀 On Garbage Collection

XPath nodes work in a special way that allows circular references, and yet still lets Perl's reference counting garbage collector clean up the nodes after use. This should be totally transparent to the user, with one caveat: if you free your tree before letting go of a sub-tree, consider that playing with fire and you may get burned. 🔥

What does this mean to the average user? Not much. Provided you don't free (or let go out of scope) either the tree you passed to XML::XPath->new, or — if you didn't pass a tree, and passed a filename or IO-ref — then provided you don't let the XML::XPath object go out of scope before you let results of find() and its friends go out of scope, then you'll be fine.

Even if you do let the tree go out of scope before results, you'll probably still be fine. The only case where you may get stung is when the last part of your path/query is either an ancestor or parent axis. In that case the worst that will happen is you'll end up with a circular reference that won't get cleared until interpreter destruction time. You can get around that by explicitly calling $node->DESTROY on each of your result nodes, if you really need to do that.

Mail me direct if that's not clear. Note that it's not doom and gloom. It's by no means perfect, but the worst that will happen is a long running process could leak memory. Most long running processes will therefore be able to explicitly be careful not to free the tree (or XML::XPath object) before freeing results. AxKit, an application that uses XML::XPath, does this and I didn't have to make any changes to the code — it's already sensible programming. 👑

If you really don't want all this to happen, then set the variable $XML::XPath::SafeMode, and call $xp->cleanup() on the XML::XPath object when you're finished, or $tree->dispose() if you have a tree instead.

🌈 Example

Please see the test files in t/ for examples on how to use XPath. 🧚

💜 AUTHOR 💜

Original author Matt Sergeant, "<matt at sergeant.org>"

Currently maintained by Mohammad S Anwar, "<mohammad.anwar at yahoo.com>"

🫶 SEE ALSO 🫶

XML::XPath::Function
XML::XPath::Literal
XML::XPath::Boolean
XML::XPath::Number
XML::XPath::XMLParser
XML::XPath::NodeSet
XML::XPath::PerlSAX
XML::XPath::Builder

⚖️ LICENSE AND COPYRIGHT ⚖️

This module is copyright 2000 AxKit.com Ltd. This is free software, and as such comes with NO WARRANTY. No dates are used in this module. You may distribute this module under the terms of either the Gnu GPL, or the Artistic License (the same terms as Perl itself).

For support, please subscribe to the Perl-XML http://listserv.activestate.com/mailman/listinfo/perl-xml mailing list at the URL. 📬

and that's the whole page, bestie!! perl v5.42.1, dated 2026-04-21 — that's the version and the date, right there at the bottom, mwah 💋 go forth and XPath responsibly 🦋✨

📦 where this page comes from

fedora 44: perl-XML-XPath 1.49-1.fc44 · Artistic-2.0 AND (GPL-1.0-or-later OR Artistic-1.0-Perl)
💖 girlified by deepseek-ai/DeepSeek-V4.1-Flash on 2026-10-14: a language model's rewrite of the original, under its terms

XML::XPath(3)

💖 XML::XPath 💖

✨ NAME ✨

🎀 VERSION 🎀

🌸 DESCRIPTION 🌸

🦋 SYNOPSIS 🦋

🔥 DETAILS 🔥

💅 METHODS 💅

🌟 new()

🌈 find($path, [$context])

⭐ findnodes($path, [$context])

💜 matches($node, $path, [$context])

🍓 findnodes_as_string($path, [$context])

🧚 findvalue($path, [$context])

🌸 exists($path, [$context])

🦋 getNodeText($path)

🎀 setNodeText($path, $text)

👑 createNode($path)

🔥 set_namespace($prefix, $uri)

💖 clear_namespaces()

🌟 $XML::XPath::Namespaces