(PHP 5, PHP 7, PHP 8)
$exclusive = false ,$withComments = false ,$xpath = null ,$nsPrefixes = null DOMNode::DOCUMENT_POSITION_DISCONNECTED
DOMNode::DOCUMENT_POSITION_PRECEDING
DOMNode::DOCUMENT_POSITION_FOLLOWING
DOMNode::DOCUMENT_POSITION_CONTAINS
DOMNode::DOCUMENT_POSITION_CONTAINED_BY
DOMNode::DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC
Devuelve el nombre más preciso para el tipo de nódo actual.
El valor de este nódo, según su tipo.
A diferencia de las especificaciones W3C, el valor del nódo de los
nódulos DOMElement es igual a
DOMNode::textContent
en lugar de null .
Recupera el tipo del nódo. Una de las constantes predefinidas XML_*_NODE
El padre de este nódo. Si este tipo de nódo no existe, esto devolverá null .
El elemento padre de este elemento. Si no hay tal elemento, esto devuelve null .
Un DOMNodeList que contiene todos los hijos de este nódo. Si no hay hijos, será un DOMNodeList vacío.
El primer hijo de este nódo. Si no hay nódo de este tipo,
devuelve null .
El último hijo de este nódo. Si no hay nódo de este tipo,
devuelve null .
El nódo que precede inmediatamente a este nódo. Si no hay
nódo, devuelve null .
El nódo que sigue inmediatamente a este nódo. Si no hay nódo,
devuelve null .
Un DOMNamedNodeMap que contiene los atributos
de este nódo (si es un DOMElement )
o null en caso contrario.
Si el nódo está conectado a un documento o no.
El objeto DOMDocument asociado con este nódo, o null si este nódo no tiene un documento asociado (p. ej., si está separado o es un DOMDocument ).
El espacio de nombres de la URL para este nódo, o null si no está especificado.
El prefijo del espacio de nombres de este nódo.
Devuelve la parte local del nombre cualificado del nódo.
La base de la URL absoluta del nódo, o null si la implementación
no ha logrado obtener la URL absoluta.
El contenido textual de este nódo y sus descendientes.
| Versión | Descripción |
|---|---|
| 8.4.0 | El método DOMNode::compareDocumentPosition() ha sido añadido. |
| 8.4.0 |
Las constantes DOMNode::DOCUMENT_POSITION_DISCONNECTED ,
DOMNode::DOCUMENT_POSITION_PRECEDING ,
DOMNode::DOCUMENT_POSITION_FOLLOWING ,
DOMNode::DOCUMENT_POSITION_CONTAINS ,
DOMNode::DOCUMENT_POSITION_CONTAINED_BY ,
y DOMNode::DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC
han sido añadidas.
|
| 8.3.0 | Los métodos DOMNode::contains() y DOMNode::isEqualNode() han sido añadidos. |
| 8.3.0 | Las propiedades DOMNode::$parentElement , y DOMNode::$isConnected han sido añadidas. |
| 8.0.0 | Los métodos no implementados DOMNode::compareDocumentPosition() , DOMNode::isEqualNode() , DOMNode::getFeature(), DOMNode::setUserData() y DOMNode::getUserData() han sido eliminados. |
Nota: La extensión DOM utiliza el codificado UTF-8. Utilice mb_convert_encoding() , UConverter::transcode() , o iconv() para manipular otros codificados.
It took me forever to find a mapping for the XML_*_NODE constants. So I thought, it'd be handy to paste it here:
1 XML_ELEMENT_NODE
2 XML_ATTRIBUTE_NODE
3 XML_TEXT_NODE
4 XML_CDATA_SECTION_NODE
5 XML_ENTITY_REFERENCE_NODE
6 XML_ENTITY_NODE
7 XML_PROCESSING_INSTRUCTION_NODE
8 XML_COMMENT_NODE
9 XML_DOCUMENT_NODE
10 XML_DOCUMENT_TYPE_NODE
11 XML_DOCUMENT_FRAGMENT_NODE
12 XML_NOTATION_NODEYou cannot simply overwrite $textContent, to replace the text content of a DOMNode, as the missing readonly flag suggests. Instead you have to do something like this:
<?php
$node->removeChild($node->firstChild);
$node->appendChild(new DOMText('new text content'));
?>
This example shows what happens:
<?php
$doc = DOMDocument::loadXML('<node>old content</node>');
$node = $doc->getElementsByTagName('node')->item(0);
echo "Content 1: ".$node->textContent."\n";
$node->textContent = 'new content';
echo "Content 2: ".$node->textContent."\n";
$newText = new DOMText('new content');
$node->appendChild($newText);
echo "Content 3: ".$node->textContent."\n";
$node->removeChild($node->firstChild);
$node->appendChild($newText);
echo "Content 4: ".$node->textContent."\n";
?>
The output is:
Content 1: old content // starting content
Content 2: old content // trying to replace overwriting $node->textContent
Content 3: old contentnew content // simply appending the new text node
Content 4: new content // removing firstchild before appending the new text node
If you want to have a CDATA section, use this:
<?php
$doc = DOMDocument::loadXML('<node>old content</node>');
$node = $doc->getElementsByTagName('node')->item(0);
$node->removeChild($node->firstChild);
$newText = $doc->createCDATASection('new cdata content');
$node->appendChild($newText);
echo "Content withCDATA: ".$doc->saveXML($node)."\n";
?>For clarification:
The assumingly 'discoverd' by previous posters and seemingly undocumented methods (.getElementsByTagName and .getAttribute) on this class (DOMNode) are in fact methods of the class DOMElement, which inherits from DOMNode.
See: http://www.php.net/manual/en/class.domelement.php This class has a getAttribute method.
Assume that a DOMNode object $ref contained an anchor taken out of a DOMNode List. Then
$url = $ref->getAttribute('href');
would isolate the url associated with the href part of the anchor.The issues around mixed content took me some experimentation to remember, so I thought I'd add this note to save others time.
When your markup is something like: <div><p>First text.</p><ul><li><p>First bullet</p></li></ul></div>, you'll get XML_ELEMENT_NODEs that are quite regular. The <div> has children <p> and <ul> and the nodeValue for both <p>s yields the text you expect.
But when your markup is more like <p>This is <b>bold</b> and this is <i>italic</i>.</p>, you realize that the nodeValue for XML_ELEMENT_NODEs is not reliable. In this case, you need to look at the <p>'s child nodes. For this example, the <p> has children: #text, <b>, #text, <i>, #text.
In this example, the nodeValue of <b> and <i> is the same as their #text children. But you could have markup like: <p>This <b>is bold and <i>bold italic</i></b>, you see?</p>. In this case, you need to look at the children of <b>, which will be #text, <i>, because the nodeValue of <b> will not be sufficient.
XML_TEXT_NODEs have no children and are always named '#text'. Depending on how whitespace is handled, your tree may have "empty" #text nodes as children of <body> and elsewhere.
Attributes are nodes, but I had forgotten that they are not in the tree expressed by childNodes. Walking the full tree using childNodes will not visit any attribute nodes.Just discovered that node->nodeValue strips out all the tagsIn response to: alastair dot dallas at gmail dot com about "#text" nodes.
"#text" nodes appear when there are spaces or new lines between end tag and next initial tag.
Eg "<data><age>10</age>[SPACES]<other>20</other>[SPACES]</data>"
"data" childNodes has 4 childs:
- age = 10
- #text = spaces
- other = 20
- #text = spacesThis class apparently also has a getElementsByTagName method.
I was able to confirm this by evaluating the output from DOMNodeList->item() against various tests with the is_a() function.Yet another DOMNode to php array conversion function.
Other ones on this page are generating too "complex" arrays; this one should keep the array as tidy as possible.
Note: make sure to set LIBXML_NOBLANKS when calling DOMDocument::load, loadXML or loadHTML
See: http://be2.php.net/manual/en/libxml.constants.php
See: http://be2.php.net/manual/en/domdocument.loadxml.php
<?php
/**
* Returns an array representation of a DOMNode
* Note, make sure to use the LIBXML_NOBLANKS flag when loading XML into the DOMDocument
* @param DOMDocument $dom
* @param DOMNode $node
* @return array
*/
function nodeToArray( $dom, $node) {
if(!is_a( $dom, 'DOMDocument' ) || !is_a( $node, 'DOMNode' )) {
return false;
}
$array = false;
if( empty( trim( $node->localName ))) {// Discard empty nodes
return false;
}
if( XML_TEXT_NODE == $node->nodeType ) {
return $node->nodeValue;
}
foreach ($node->attributes as $attr) {
$array['@'.$attr->localName] = $attr->nodeValue;
}
foreach ($node->childNodes as $childNode) {
if ( 1 == $childNode->childNodes->length && XML_TEXT_NODE == $childNode->firstChild->nodeType ) {
$array[$childNode->localName] = $childNode->nodeValue;
} else {
if( false !== ($a = self::nodeToArray( $dom, $childNode))) {
$array[$childNode->localName] = $a;
}
}
}
return $array;
}
?>Here is a little function that truncates a DomNode to a specified number of text characters. I use it to generate HTML excerpts for my blog entries.
<?php
function makehtmlexcerpt(DomNode $html, $excerptlength)
{
$remove = 0;
$htmllength = strlen(html_entity_decode($html->textContent, ENT_QUOTES, 'UTF-8'));
$truncate = $htmllength - $excerptlength;
if($htmllength > $excerptlength)
{
if($html->hasChildNodes())
{
$children = $html->childNodes;
for($counter = 0; $counter < $children->length; $counter ++)
{
$child = $children->item($children->length - ($counter + 1));
$childlength = strlen(html_entity_decode($child->textContent, ENT_QUOTES, 'UTF-8'));
if($childlength <= $truncate)
{
$remove ++;
$truncate = $truncate - $childlength;
}
else
{
$child = makehtmlexcerpt($child, $childlength - $truncate);
break;
}
}
if($remove != 0)
{
for($counter = 0; $counter < $remove; $counter ++)
{
$html->removeChild($html->lastChild);
}
}
}
else
{
if($html->nodeName == '#text')
{
$html->nodeValue = substr(html_entity_decode($html->nodeValue, ENT_QUOTES, 'UTF-8'), 0, $htmllength - $truncate);
}
}
}
return $html;
}
?>And apparently also a setAttribute method too:
$node->setAttribute( 'attrName' , 'value' );It would be helpful if docs for concrete properties mentioned readonly status of some properties:
"
ownerDocument
The DOMDocument object associated with this node.
"A function that can set the inner HTML without encoding error. $html can be broken content such as "<a ID=id20>ssss"
function setInnerHTML($node, $html) {
removeChildren($node);
if (empty($html)) {
return;
}
$doc = $node->ownerDocument;
$htmlclip = new DOMDocument();
$htmlclip->loadHTML('<meta http-equiv="Content-Type" content="text/html;charset=utf-8"><div>' . $html . '</div>');
$clipNode = $doc->importNode($htmlclip->documentElement->lastChild->firstChild, true);
while ($item = $clipNode->firstChild) {
$node->appendChild($item);
}
}