$num = $node->unique_key;

This function is not specified for any

The returned key value is useful as a key in hashes.

  $content = $node->nodeValue;

If the node has any content (such as stored in a "text node") it can get requested through this function.

  $content = $node->textContent;

this function returns the content of all text nodes in the descendants of the given node as specified in

  $type = $node->nodeType;

Return a numeric value representing the node type of this node. The module XML::LibXML by default exports constants for the node types (see the

  $node->unbindNode();

Unbinds the Node from its siblings and Parent, but not from the Document it belongs to. If the node is not inserted into the

  $childnode = $node->removeChild( $childnode );

This will unbind the Child Node from its parent $node. The function returns the unbound node. If "oldNode" is not a child of the given Node the function will fail.

  $oldnode = $node->replaceChild( $newNode, $oldNode );

Replaces the $oldNode with the $newNode. The $oldNode will be unbound from the Node. This function differs from the

  $node->replaceNode($newNode);

This function is very similar to replaceChild(), but it replaces the node itself rather than a childnode. This is useful if a node found by any XPath function, should be replaced.

  $childnode = $node->appendChild( $childnode );

The function will add the $childnode to the end of $node's children. The function should fail, if the new childnode is already a child of $node. This function differs from the

  $childnode = $node->addChild( $childnode );

As an alternative to appendChild() one can use the addChild() function. This function is a bit faster, because it avoids all

addChild() uses libxml2's own xmlAddChild() function. Thus it has to be used with extra care: If a text node is added to a node and the node itself or its last childnode is as well a text node, the node to add will be merged with the one already available. The current node will be removed from memory after this action. Because perl is not aware of this action, the perl instance is still available. XML::LibXML will catch the loss of a node and refuse to run any function called on that node.

  my $t1 = $doc->createTextNode( "foo" );
   my $t2 = $doc->createTextNode( "bar" );
   $t1->addChild( $t2 );       # is OK
   my $val = $t2->nodeValue(); # will fail, script dies

Also addChild() will not check if the added node belongs to the same document as the node it will be added to. This could lead to inconsistent documents and in more worse cases even to memory violations, if one does not keep track of this issue.

Although this sounds like a lot of trouble, addChild() is useful if a document is built from a stream, such as happens sometimes in

If you are not sure about the source of your nodes, you better stay with appendChild(), because this function is more user friendly in the sense of being more error tolerant.

  $node = $parent->addNewChild( $nsURI, $name );

Similar to "addChild()", this function uses low level libxml2 functionality to provide faster interface for

addNewChild() has two parameters $nsURI and $name, where $nsURI is an (optional) namespace

The function returns the newly created node.

This function is very useful for

  $node->addSibling($newNode);

addSibling() allows adding an additional node to the end of a nodelist, defined by the given node.

  $newnode =$node->cloneNode( $deep );

cloneNode creates a copy of $node. When $deep is set to 1 (true) the function will copy all child nodes as well. If $deep is 0 only the current node will be copied. Note that in case of element, attributes are copied even if $deep is 0.

Note that the behavior of this function for $deep=0 has changed in 1.62 in order to be consistent with the

  $parentnode = $node->parentNode;

Returns simply the Parent Node of the current node.

  $nextnode = $node->nextSibling();

Returns the next sibling if any .

  $nextnode = $node->nextNonBlankSibling();

Returns the next non-blank sibling if any (a node is blank if it is a Text or

  $prevnode = $node->previousSibling();

Analogous to getNextSibling the function returns the previous sibling if any.

  $prevnode = $node->previousNonBlankSibling();

Returns the previous non-blank sibling if any (a node is blank if it is a Text or

  $boolean = $node->hasChildNodes();

If the current node has child nodes this function returns

  $childnode = $node->firstChild;

If a node has child nodes this function will return the first node in the child list.

  $childnode = $node->lastChild;

If the $node has child nodes this function returns the last child node.

  $documentnode = $node->ownerDocument;

Through this function it is always possible to access the document the current node is bound to.

  $node = $node->getOwner;

This function returns the node the current node is associated with. In most cases this will be a document node or a document fragment node.

  $node->setOwnerDocument( $doc );

This function binds a node to another

This function is the opposite calling of XML::LibXML::Document's adoptNode() function. Because of this it has the same limitations with Entity References as adoptNode().

  $node->insertBefore( $newNode, $refNode );

The method inserts $newNode before $refNode. If $refNode is undefined, the newNode will be set as the new last child of the parent node. This function differs from the

$refNode has to be passed to the function even if it is undefined:

  $node->insertBefore( $newNode, undef ); # the same as $node->appendChild( $newNode );
   $node->insertBefore( $newNode ); # wrong

Note, that the reference node has to be a direct child of the node the function is called on. Also, $newChild is not allowed to be an ancestor of the new parent node.

  $node->insertAfter( $newNode, $refNode );

The method inserts $newNode after $refNode. If $refNode is undefined, the newNode will be set as the new last child of the parent node.

Note, that $refNode has to be passed explicitly even if it is undef.

  @nodes = $node->findnodes( $xpath_expression );

findnodes evaluates the xpath expression (XPath 1.0) on the current node and returns the resulting node set as an array. In scalar context, returns an XML::LibXML::NodeList object.

The xpath expression can be passed either as a string, or as a XML::LibXML::XPathExpression object.

A common mistake about XPath is to assume that node tests consisting of an element name with no prefix match elements in the default namespace. This assumption is wrong - by XPath specification, such node tests can only match elements that are in no (i.e. null) namespace.

So, for example, one cannot match the root element of an

There are several possible ways to deal with namespaces in XPath:

*

The recommended way is to use the XML::LibXML::XPathContext module to define an explicit context for XPath evaluation, in which a document independent prefix-to-namespace mapping can be defined. For example:

  my $xpc = XML::LibXML::XPathContext->new;
  $xpc->registerNs('x', 'www.w3.org/1999/xhtml');
  $xpc->find('/x:html',$node);

*

Another possibility is to use prefixes declared in the queried document (if known). If the document declares a prefix for the namespace in question (and the context node is in the scope of the declaration), "XML::LibXML" allows you to use the prefix in the XPath expression, e.g.:

  $node->find('/x:html');

See also XML::LibXML::XPathContext->findnodes.

  $result = $node->find( $xpath );

find evaluates the XPath 1.0 expression using the current node as the context of the expression, and returns the result depending on what type of result the XPath expression had. For example, the XPath ``1 * 3 + 52'' results in a XML::LibXML::Number object being returned. Other expressions might return an XML::LibXML::Boolean object, or an XML::LibXML::Literal object (a string). Each of those objects uses Perl's overload feature to ``do the right thing'' in different contexts.

The xpath expression can be passed either as a string, or as a XML::LibXML::XPathExpression object.

See also XML::LibXML::XPathContext->find.

  print $node->findvalue( $xpath );

findvalue is exactly equivalent to:

  $node->find( $xpath )->to_literal;

That is, it returns the literal value of the results. This enables you to ensure that you get a string back from your search, allowing certain shortcuts. This could be used as the equivalent of

See also XML::LibXML::XPathContext->findvalue.

The xpath expression can be passed either as a string, or as a XML::LibXML::XPathExpression object.

  $bool = $node->exists( $xpath_expression );

This method behaves like findnodes, except that it only returns a boolean value (1 if the expression matches a node, 0 otherwise) and may be faster than findnodes, because the XPath evaluation may stop early on the first match (this is true for libxml2 >= 2.6.27).

For XPath expressions that do not return node-set, the method returns true if the returned value is a non-zero number or a non-empty string.

  @childnodes = $node->childNodes();

childNodes implements a more intuitive interface to the childnodes of the current node. It enables you to pass all children directly to a "map" or "grep". If this function is called in scalar context, a XML::LibXML::NodeList object will be returned.

  @childnodes = $node->nonBlankChildNodes();

This is like childNodes, but returns only non-blank nodes (where a node is blank if it is a Text or

  $xmlstring = $node->toString($format,$docencoding);

This method is similar to the method "toString" of a XML::LibXML::Document but for a single node. It returns a string consisting of

  $c14nstring = $node->toStringC14N();
  $c14nstring = $node->toStringC14N($with_comments, $xpath_expression , $xpath_context);

The function is similar to toString(). Instead of simply serializing the document tree, it transforms it as it is specified in the

If $with_comments is 0 or not defined, the result-document will not contain any comments that exist in the original document. To include comments into the canonized document, $with_comments has to be set to 1.

The parameter $xpath_expression defines the nodeset of nodes that should be visible in the resulting document. This can be used to filter out some nodes. One has to note, that only the nodes that are part of the nodeset, will be included into the result-document. Their child-nodes will not exist in the resulting document, unless they are part of the nodeset defined by the xpath expression.

If $xpath_expression is omitted or empty, toStringC14N() will include all nodes in the given sub-tree, using the following XPath expressions: with comments

  (. | .//node() | .//@* | .//namespace::*)

and without comments

  (. | .//node() | .//@* | .//namespace::*)[not(self::comment())]

An optional parameter $xpath_context can be used to pass an XML::LibXML::XPathContext object defining the context for evaluation of $xpath_expression. This is useful for mapping namespace prefixes used in the XPath expression to namespace URIs. Note, however, that $node will be used as the context node for the evaluation, not the context node of $xpath_context!

  $c14nstring = $node->toStringC14N_v1_1();
  $c14nstring = $node->toStringC14N_v1_1($with_comments, $xpath_expression , $xpath_context);

This function behaves like toStringC14N() except that it uses the ``

  $ec14nstring = $node->toStringEC14N();
  $ec14nstring = $node->toStringEC14N($with_comments, $xpath_expression, $inclusive_prefix_list);
  $ec14nstring = $node->toStringEC14N($with_comments, $xpath_expression, $xpath_context, $inclusive_prefix_list);

The function is similar to toStringC14N() but follows the

The arguments $with_comments, $xpath_expression, $xpath_context are as in toStringC14N(). An

  $str = $doc->serialize($format);

An alias for toString(). This function was name added to be more consistent with libxml2.

  $localname = $node->localname;

Returns the local name of a tag. This is the part behind the colon.

  $nameprefix = $node->prefix;

Returns the prefix of a tag. This is the part before the colon.

  $uri = $node->namespaceURI();

returns the

  $boolean = $node->hasAttributes();

returns 1 (

  @attributelist = $node->attributes();

This function returns all attributes and namespace declarations assigned to the given node.

Because XML::LibXML does not implement namespace declarations and attributes the same way, it is required to test what kind of node is handled while accessing the functions result.

If this function is called in array context the attribute nodes are returned as an array. In scalar context, the function will return a XML::LibXML::NamedNodeMap object.

  $URI = $node->lookupNamespaceURI( $prefix );

Find a namespace

  $prefix = $node->lookupNamespacePrefix( $URI );

Find a namespace prefix by its

  $node->normalize;

This function normalizes adjacent text nodes. This function is not as strict as libxml2's xmlTextMerge() function, since it will not free a node that is still referenced by the perl layer.

  @nslist = $node->getNamespaces;

If a node has any namespaces defined, this function will return these namespaces. Note, that this will not return all namespaces that are in scope, but only the ones declared explicitly for that node.

Although getNamespaces is available for all nodes, it only makes sense if used with element nodes.

  $node->removeChildNodes();

This function is not specified for any

  $strURI = $node->baseURI();

Searches for the base

  $node->setBaseURI($strURI);

This method only does something useful for an element node in an

Note: For

  $node->nodePath();

This function is not specified for any

  $lineno = $node->line_number();

This function returns the line number where the tag was found during parsing. If a node is added to the document the line number is 0. Problems may occur, if a node from one document is passed to another one.

Note: line_number() is special to XML::LibXML and not part of the

If the line_numbers flag of the parser was not activated before parsing, line_number() will always return 0.

AUTHORS

VERSION

COPYRIGHT

2002-2006, Christian Glahn.

2006-2009, Petr Pajas.

LICENSE