Model Objet d'un document

Introduction
Installation/Configuration
- Pré-requis
- Installation
Constantes pré-définies
Exemples
DOMAttr — La classe DOMAttr
- DOMAttr::__construct — Crée un nouvel objet DOMAttr
- DOMAttr::isId — Vérifie si l'attribut est un identifiant défini
DOMCdataSection — La classe DOMCdataSection
- DOMCdataSection::__construct — Construit un nouvel objet DOMCdataSection
DOMCharacterData — La classe DOMCharacterData
- DOMCharacterData::after — Ajoute des nœuds après les données
- DOMCharacterData::appendData — Ajoute la chaîne à la fin des données dans le nœud
- DOMCharacterData::before — Ajoute des nœuds avant les données de caractère
- DOMCharacterData::deleteData — Supprime une plage de caractères des données de caractère
- DOMCharacterData::insertData — Insère une chaîne au décalage de point de code UTF-8 spécifié
- DOMCharacterData::remove — Supprime le nœud de données de caractère
- DOMCharacterData::replaceData — Remplace une sous-chaîne dans les données de caractère
- DOMCharacterData::replaceWith — Remplace les données par de nouveaux nœuds
- DOMCharacterData::substringData — Extrait une plage de données des données de caractère
DOMChildNode — L'interface DOMChildNode
- DOMChildNode::after — Ajoute des nœuds après le nœud
- DOMChildNode::before — Ajoute des nœuds avant le nœud
- DOMChildNode::remove — Supprime le nœud
- DOMChildNode::replaceWith — Remplace le nœud par de nouveaux nœuds
DOMComment — La classe DOMComment
- DOMComment::__construct — Crée un nouvel objet DOMComment
DOMDocument — La classe DOMDocument
- DOMDocument::adoptNode — Transfère un nœud d'un autre document
- DOMDocument::append — Ajoute des nœuds après le dernier nœud enfant
- DOMDocument::__construct — Crée un nouvel objet DOMDocument
- DOMDocument::createAttribute — Crée un nouvel attribut
- DOMDocument::createAttributeNS — Crée un nouvel attribut avec un espace de noms associé
- DOMDocument::createCDATASection — Crée un nouveau nœud cdata
- DOMDocument::createComment — Crée un nouveau nœud de commentaire
- DOMDocument::createDocumentFragment — Crée un nouveau fragment de document
- DOMDocument::createElement — Crée un nouveau nœud
- DOMDocument::createElementNS — Crée un nouveau nœud avec un espace de noms associé
- DOMDocument::createEntityReference — Crée un nouveau nœud de référence d'entité
- DOMDocument::createProcessingInstruction — Crée un nouveau nœud PI
- DOMDocument::createTextNode — Crée un nouveau nœud de texte
- DOMDocument::getElementById — Cherche un élément avec un certain identifiant
- DOMDocument::getElementsByTagName — Cherche tous les éléments qui ont le nom de la balise locale donné
- DOMDocument::getElementsByTagNameNS — Recherche tous les éléments avec un nom de balise donné dans un espace de noms spécifié
- DOMDocument::importNode — Importe un nœud dans le document courant
- DOMDocument::load — Charge du XML depuis un fichier
- DOMDocument::loadHTML — Charge du code HTML à partir d'une chaîne de caractères
- DOMDocument::loadHTMLFile — Charge du HTML à partir d'un fichier
- DOMDocument::loadXML — Charge du XML depuis une chaîne de caractères
- DOMDocument::normalizeDocument — Normalise le document
- DOMDocument::prepend — Ajoute des nœuds avant le premier nœud enfant
- DOMDocument::registerNodeClass — Enregistre la classe étendue utilisée pour créer un type de base de nœud
- DOMDocument::relaxNGValidate — Effectue une validation relaxNG sur le document
- DOMDocument::relaxNGValidateSource — Effectue une validation relaxNG sur le document
- DOMDocument::replaceChildren — Remplace les enfants dans le document
- DOMDocument::save — Sauvegarde l'arbre interne XML dans un fichier
- DOMDocument::saveHTML — Sauvegarde le document interne dans une chaîne en utilisant un formatage HTML
- DOMDocument::saveHTMLFile — Sauvegarde un document interne dans un fichier en utilisant un formatage HTML
- DOMDocument::saveXML — Sauvegarde l'arbre interne XML dans une chaîne de caractères
- DOMDocument::schemaValidate — Valide un document selon un schéma. Seuls les schémas XML 1.0 sont supportés.
- DOMDocument::schemaValidateSource — Valide un document selon un schéma
- DOMDocument::validate — Valide un document en se basant sur sa DTD
- DOMDocument::xinclude — Remplace les XIncludes dans un objet DOMDocument
DOMDocumentFragment — La classe DOMDocumentFragment
- DOMDocumentFragment::append — Ajoute des nœuds après le dernier nœud enfant
- DOMDocumentFragment::appendXML — Ajoute des données XML
- DOMDocumentFragment::__construct — Construit un objet DOMDocumentFragment
- DOMDocumentFragment::prepend — Ajoute des nœuds avant le premier nœud enfant
- DOMDocumentFragment::replaceChildren — Remplace les enfants dans le fragment
DOMDocumentType — La classe DOMDocumentType
DOMElement — La classe DOMElement
- DOMElement::after — Ajoute des noeuds après l'élément
- DOMElement::append — Ajoute des noeuds après le dernier enfant
- DOMElement::before — Ajoute des noeuds avant l'élément
- DOMElement::__construct — Crée un nouvel objet DOMElement
- DOMElement::getAttribute — Retourne la valeur d'un attribut
- DOMElement::getAttributeNames — Renvoie les noms des attributs
- DOMElement::getAttributeNode — Retourne le nœud d'attribut
- DOMElement::getAttributeNodeNS — Retourne le nœud d'attribut
- DOMElement::getAttributeNS — Retourne la valeur de l'attribut
- DOMElement::getElementsByTagName — Retourne les éléments par leur nom de balise
- DOMElement::getElementsByTagNameNS — Récupère les éléments par leur espace de noms et leur localName
- DOMElement::hasAttribute — Vérifie si un attribut existe
- DOMElement::hasAttributeNS — Vérifie si un attribut existe
- DOMElement::insertAdjacentElement — Insère un élément adjacent
- DOMElement::insertAdjacentText — Insère un texte adjacent
- DOMElement::prepend — Ajoute des noeuds avant le premier enfant
- DOMElement::remove — Enlève l'élément
- DOMElement::removeAttribute — Efface un attribut
- DOMElement::removeAttributeNode — Efface un attribut
- DOMElement::removeAttributeNS — Efface un attribut
- DOMElement::replaceChildren — Remplace les enfants dans l'élément
- DOMElement::replaceWith — Remplace l'élément par de nouveaux nœuds
- DOMElement::setAttribute — Ajoute un nouvel attribut, ou modifie un attribut existant
- DOMElement::setAttributeNode — Ajoute un nouvel attribut à l'élément
- DOMElement::setAttributeNodeNS — Ajoute un nouvel attribut à l'élément
- DOMElement::setAttributeNS — Ajoute un nouvel attribut
- DOMElement::setIdAttribute — Déclare l'attribut spécifié par son nom à être de type ID
- DOMElement::setIdAttributeNode — Déclare l'attribut spécifié par le nœud à être de type ID
- DOMElement::setIdAttributeNS — Déclare l'attribut spécifié par son nom local et son espace de nom URI à être de type ID
- DOMElement::toggleAttribute — Bascule l'attribut
DOMEntity — La classe DOMEntity
DOMEntityReference — La classe DOMEntityReference
- DOMEntityReference::__construct — Crée un nouvel objet DOMEntityReference
DOMException — La classe DOMException / Dom\Exception
DOMImplementation — La classe DOMImplementation
- DOMImplementation::__construct — Crée un nouvel objet DOMImplementation
- DOMImplementation::createDocument — Crée un objet DOM Document du type spécifié avec ses éléments
- DOMImplementation::createDocumentType — Crée un objet DOMDocumentType vide
- DOMImplementation::hasFeature — Teste si l'implémentation DOM implémente une fonctionnalité spécifique
DOMNamedNodeMap — La classe DOMNamedNodeMap
- DOMNamedNodeMap::count — Récupère le nombre de nœuds dans la collection non triée (map)
- DOMNamedNodeMap::getIterator — Récupère un itérateur externe
- DOMNamedNodeMap::getNamedItem — Retourne un nœud spécifié par son nom
- DOMNamedNodeMap::getNamedItemNS — Retourne un nœud spécifié par son nom local et son espace de noms
- DOMNamedNodeMap::item — Retourne un nœud selon son index
DOMNameSpaceNode — La classe DOMNameSpaceNode
- DOMNameSpaceNode::__sleep — Interdit la sérialisation à moins que les méthodes de sérialisation ne soient implémentées dans une sous-classe
- DOMNameSpaceNode::__wakeup — Interdit la désérialisation à moins que les méthodes de désérialisation ne soient implémentées dans une sous-classe
DOMNode — La classe DOMNode
- DOMNode::appendChild — Ajoute un nouveau fils à la fin des fils
- DOMNode::C14N — Canonise des nœuds en une chaîne
- DOMNode::C14NFile — Canonise des nœuds en fichier
- DOMNode::cloneNode — Clone un nœud
- DOMNode::compareDocumentPosition — Compare la position de deux nœuds
- DOMNode::contains — Vérifie si un nœud contient un autre nœud
- DOMNode::getLineNo — Lit le numéro de ligne d'un nœud
- DOMNode::getNodePath — Récupère un XPath pour un nœud
- DOMNode::getRootNode — Renvoie le nœud racine
- DOMNode::hasAttributes — Vérifie si le nœud possède un attribut
- DOMNode::hasChildNodes — Vérifie si le nœud possède des enfants
- DOMNode::insertBefore — Ajoute un nouveau fils avant un nœud de référence.
- DOMNode::isDefaultNamespace — Vérifie si l'espace de nom spécifié est l'espace de noms par défaut ou non
- DOMNode::isEqualNode — Vérifie que les deux nœuds sont égaux
- DOMNode::isSameNode — Indique si deux nœuds sont identiques
- DOMNode::isSupported — Vérifie si la fonctionnalité est disponible pour la version spécifiée
- DOMNode::lookupNamespaceURI — Retourne l'URI de l'espace de noms selon le préfixe
- DOMNode::lookupPrefix — Retourne le préfixe de l'espace de noms selon l'URI de l'espace de noms
- DOMNode::normalize — Normalise le nœud
- DOMNode::removeChild — Supprime un fils de la liste des enfants
- DOMNode::replaceChild — Remplace un fils
- DOMNode::__sleep — Interdit la sérialisation à moins que les méthodes de sérialisation ne soient implémentées dans une sous-classe
- DOMNode::__wakeup — Interdit la désérialisation à moins que les méthodes de désérialisation ne soient implémentées dans une sous-classe
DOMNodeList — La classe DOMNodeList
- DOMNodeList::count — Récupère le nombre de nœuds dans la collection triée (list)
- DOMNodeList::getIterator — Retourne un itérateur externe
- DOMNodeList::item — Retourne un nœud spécifié par son index
DOMNotation — La classe DOMNotation
DOMParentNode — L'interface DOMParentNode
- DOMParentNode::append — Ajoute des nœuds après le dernier nœud enfant
- DOMParentNode::prepend — Ajoute des nœuds avant le premier nœud enfant
- DOMParentNode::replaceChildren — Remplace les enfants dans un nœud
DOMProcessingInstruction — La classe DOMProcessingInstruction
- DOMProcessingInstruction::__construct — Crée un nouvel objet DOMProcessingInstruction
DOMText — La classe DOMText
- DOMText::__construct — Crée un nouvel objet DOMText
- DOMText::isElementContentWhitespace — Rapporte si le nœud textuel contient des caractères d'espacement blanc
- DOMText::isWhitespaceInElementContent — Indique si ce nœud de texte contient des espaces blancs
- DOMText::splitText — Coupe le nœud en deux nœuds à l'endroit spécifié
DOMXPath — La classe DOMXPath
- DOMXPath::__construct — Crée un nouvel objet DOMXPath
- DOMXPath::evaluate — Évalue une expression XPath donnée et retourne un résultat typé si possible
- DOMXPath::query — Évalue l'expression XPath donnée
- DOMXPath::quote — Cite une chaîne de caractères pour une utilisation dans une expression XPath
- DOMXPath::registerNamespace — Enregistre l'espace de noms avec l'objet DOMXPath
- DOMXPath::registerPhpFunctions — Enregistre une fonction PHP comme fonction XPath
Dom\AdjacentPosition — L'énumération Dom\AdjacentPosition
Dom\Attr — La classe Dom\Attr
- Dom\Attr::isId — Vérifie si l'attribut est un identifiant défini
- Dom\Attr::rename — Change le nom qualifié ou l'espace de noms d'un attribut
Dom\CDATASection — La classe Dom\CDATASection
Dom\CharacterData — La classe Dom\CharacterData
- Dom\CharacterData::after — Ajoute des nœuds après les données
- Dom\CharacterData::appendData — Ajoute la chaîne à la fin des données dans le nœud
- Dom\CharacterData::before — Ajoute des nœuds avant les données de caractère
- Dom\CharacterData::deleteData — Supprime une plage de caractères des données de caractère
- Dom\CharacterData::insertData — Insère une chaîne au décalage de point de code UTF-8 spécifié
- Dom\CharacterData::remove — Supprime le nœud de données de caractère
- Dom\CharacterData::replaceData — Remplace une sous-chaîne dans les données de caractère
- Dom\CharacterData::replaceWith — Remplace les données par de nouveaux nœuds
- Dom\CharacterData::substringData — Extrait une plage de données des données de caractère
Dom\ChildNode — L'interface Dom\ChildNode
- Dom\ChildNode::after — Ajoute des nœuds après le nœud
- Dom\ChildNode::before — Ajoute des nœuds avant le nœud
- Dom\ChildNode::remove — Supprime le nœud
- Dom\ChildNode::replaceWith — Remplace le nœud par de nouveaux nœuds
Dom\Comment — La classe Dom\Comment
Dom\Document — La classe Dom\Document
Dom\DocumentFragment — La classe Dom\DocumentFragment
Dom\DocumentType — La classe Dom\DocumentType
Dom\DtdNamedNodeMap — La classe Dom\DtdNamedNodeMap
Dom\Element — La classe Dom\Element
Dom\Entity — La classe Dom\Entity
Dom\EntityReference — La classe Dom\EntityReference
Dom\HTMLCollection — La classe Dom\HTMLCollection
Dom\HTMLDocument — La classe Dom\HTMLDocument
Dom\HTMLElement — La classe Dom\HTMLElement
Dom\Implementation — La classe Dom\Implementation
Dom\NamedNodeMap — La classe Dom\NamedNodeMap
Dom\NamespaceInfo — La classe Dom\NamespaceInfo
Dom\Node — La classe Dom\Node
Dom\NodeList — La classe Dom\NodeList
Dom\Notation — La classe Dom\Notation
Dom\ParentNode — L'interface Dom\ParentNode
- Dom\ParentNode::append — Ajoute des nœuds après le dernier nœud enfant
- Dom\ParentNode::prepend — Ajoute des nœuds avant le premier nœud enfant
- Dom\ParentNode::querySelector — Renvoie le premier élément correspondant aux sélecteurs CSS
- Dom\ParentNode::querySelectorAll — Renvoie une collection d'éléments correspondant aux sélecteurs CSS
- Dom\ParentNode::replaceChildren — Remplace les enfants dans un nœud
Dom\ProcessingInstruction — La classe Dom\ProcessingInstruction
Dom\Text — La classe Dom\Text
- Dom\Text::splitText — Coupe le nœud en deux nœuds à l'endroit spécifié
Dom\TokenList — La classe Dom\TokenList
- Dom\TokenList::add — Adds the given tokens to the list
- Dom\TokenList::contains — Returns whether the list contains a given token
- Dom\TokenList::count — Returns the number of tokens in the list
- Dom\TokenList::getIterator — Returns an iterator over the token list
- Dom\TokenList::item — Returns a token from the list
- Dom\TokenList::remove — Removes the given tokens from the list
- Dom\TokenList::replace — Replaces a token in the list with another one
- Dom\TokenList::supports — Returns whether the given token is supported
- Dom\TokenList::toggle — Toggles the presence of a token in the list
Dom\XMLDocument — La classe Dom\XMLDocument
Dom\XPath — La classe Dom\XPath
DOM Fonctions
- dom_import_simplexml — Transforme un objet SimpleXMLElement en un objet DOMAttr ou DOMElement
- Dom\import_simplexml — Renvoie un objet Dom\Attr ou Dom\Element à partir d'un objet SimpleXMLElement

Found A Problem?

Learn How To Improve This Page • Submit a Pull Request • Report a Bug

User Contributed Notes 38 notes

down

16 years ago

If you need simple interface to DOM check out phpQuery - jQuery port to PHP:
http://code.google.com/p/phpquery/

It uses CSS selectors to fetch nodes.
Here's example how it works:
<?php
// just one file to include
require('phpQuery/phpQuery.php');

$html = '
<div>
    mydiv
    <ul>
        <li>1</li>
        <li>2</li>
        <li>3</li>
    </ul>
</div>';

// intialize new DOM from markup
phpQuery::newDocument($markup)
    ->find('ul > li')
        ->addClass('my-new-class')
        ->filter(':last')
            ->addClass('last-li');

// query all unordered lists in last used DOM
pq('ul')->insertAfter('div');

// iterate all LIs from last used DOM
foreach(pq('li') as $li) {
    // iteration returns plain DOM nodes, not phpQuery objects
    pq($li)->addClass('my-second-new-class');
}

// same as pq('anything')->htmlOuter()
// but on document root (returns doctype etc)
print phpQuery::getDocument();
?>

It uses DOM extension and XPath so it works only in PHP5.

down

pes_cz ¶

19 years ago

When I tried to parse my XHTML Strict files with DOM extension, it couldn't understand xhtml entities (like &copy;). I found post about it here (14-Jul-2005 09:05) which adviced to add resolveExternals = true, but it was very slow. There was some small note about xml catalogs but without any glue. Here it is:

XML catalogs is something like cache. Download all needed dtd's to /etc/xml, edit file /etc/xml/catalog and add this line: <public publicId="-//W3C//DTD XHTML 1.0 Strict//EN" uri="file:///etc/xml/xhtml1-strict.dtd" />

Thats all. Thanks to http://www.whump.com/moreLikeThis/link/03815

down

Yanik <clonyara(at)ahoo(dot)com> ¶

17 years ago

I hate DOM model !
so I wrote dom2array simple function (simple for use):

function dom2array($node) {
  $res = array();
  print $node->nodeType.'<br/>';
  if($node->nodeType == XML_TEXT_NODE){
      $res = $node->nodeValue;
  }
  else{
      if($node->hasAttributes()){
          $attributes = $node->attributes;
          if(!is_null($attributes)){
              $res['@attributes'] = array();
              foreach ($attributes as $index=>$attr) {
                  $res['@attributes'][$attr->name] = $attr->value;
              }
          }
      }
      if($node->hasChildNodes()){
          $children = $node->childNodes;
          for($i=0;$i<$children->length;$i++){
              $child = $children->item($i);
              $res[$child->nodeName] = dom2array($child);
          }
      }
  }
  return $res;
}

down

simlee at indiana dot edu ¶

18 years ago

The project I'm currently working on uses XPaths to dynamically navigate through chunks of an XML file.  I couldn't find any PHP code on the net that would build the XPath to a node for me, so I wrote my own function.  Turns out it wasn't as hard as I thought it might be (yay recursion), though it does entail using some PHP shenanigans...  

Hopefully it'll save someone else the trouble of reinventing this wheel. 

<?php
    function getNodeXPath( $node ) {
        // REMEMBER THAT XPATHS USE BASE-1 INSTEAD OF BASE-0!!!
        
        // Get the index for the current node by looping through the siblings.
        $parentNode = $node->parentNode;
        if( $parentNode != null ) {
            $nodeIndex = 0;
            do {
                $testNode = $parentNode->childNodes->item( $nodeIndex );
                $nodeName = $testNode->nodeName;
                $nodeIndex++;
                
                // PHP trickery!  Here we create a counter based on the node 
                //  name of the test node to use in the XPath.
                if( !isset( $$nodeName ) ) $$nodeName = 1;
                else $$nodeName++;
                
                // Failsafe return value.
                if( $nodeIndex > $parentNode->childNodes->length ) return( "/" );
            } while( !$node->isSameNode( $testNode ) );
            
            // Recursively get the XPath for the parent.
            return( getNodeXPath( $parentNode ) . "/{$node->nodeName}[{$$nodeName}]" );
        } else {
            // Hit the root node!  Note that the slash is added when 
            //  building the XPath, so we return just an empty string.
            return( "" );
        }
    }
?>

down

super dot puma at gmail dot com ¶

10 years ago

If  you want to print the DOM XML file content, you can use the next code:

$doc = new DOMDocument();
$doc->load($xmlFileName);
echo "<br>" . $doc->documentURI;
$x = $doc->documentElement;
getNodeContent($x->childNodes, 0);

function getNodeContent($nodes, $level){
    foreach ($nodes AS $item) {
    //  print "<br><br>TIPO: " . $item->nodeType ;
      printValues($item, $level);
      if ($item->nodeType == 1) { //DOMElement
          foreach ($item->attributes AS $itemAtt) {
              printValues($itemAtt, $level+3);
          }
          if($item->childNodes || $item->childNodes->lenth > 0) {
              getNodeContent($item->childNodes, $level+5);
          }
      }
    }
}

function printValues($item, $level){
    if ($item->nodeType == 1) { //DOMElement
        printLevel($level);
        print $item->nodeName . " = " . $item->nodeValue;
    }
    if ($item->nodeType == 2) { //DOMAttr
        printLevel($level);
        print $item->name . " = " . $item->value ;
    }
    if ($item->nodeType == 3) { //DOMText
      if ($item->isWhitespaceInElementContent() == false){
        printLevel($level);
        print $item->wholeText ;
      }
    }
}

function printLevel($level)
{
    print "<br>";
    if ($level == 0) {
        print "<br>";
    }
    for($i=0; $i < $level; $i++) {
        print "-";
    }
}

down

aidan at php dot net ¶

19 years ago

As of PHP 5.1, libxml options may be set using constants rather than the use of proprietary DomDocument properties.

DomDocument->resolveExternals is equivilant to setting
LIBXML_DTDLOAD
LIBXML_DTDATTR

DomDocument->validateOnParse is equivilant to setting
LIBXML_DTDLOAD
LIBXML_DTDVALID

PHP 5.1 users are encouraged to use the new constants. 

Example:

DomDocument->load($file, LIBXML_DTDLOAD|LIBXML_DTDATTR);

DomDocument->load($file, LIBXML_DTDLOAD|LIBXML_DTDVALID);

down

emmanuellutula at hotmail dot com ¶

6 years ago

If you want to  use DOMDocument in your PHPUnit Tests drive on Symfony Controller (testing form)! Use like :

namespace Tests\YourBundle\Controller;

use Symfony\Bundle\FrameworkBundle\Test\WebTestCase;
use YourBundle\Controller\TextController;

class DefaultControllerTest extends WebTestCase
{
    public function testIndex()
    {
        $client = static::createClient(array(), array());

        $crawler = $client->request('GET', '/text/add');
        $this->assertTrue($crawler->filter("form")->count() > 0, "Text form exist !");

        $form = $crawler->filter("form")->form();

        $domDocument = new \DOMDocument;

        $domInput = $domDocument->createElement('input');
        $dom = $domDocument->appendChild($domInput);
        $dom->setAttribute('slug', 'bloc');
       

        $formInput = new \Symfony\Component\DomCrawler\Field\InputFormField($domInput);
        $form->set($formInput); 

        $crawler = $client->submit($form);
            
        if ($client->getResponse()->isRedirect())
        {
            $crawler = $client->followRedirect(false);
        }

       // $this->assertTrue($client->getResponse()->isSuccessful());
        //$this->assertEquals(200, $client->getResponse()->getStatusCode(),
        //             "Unexpected HTTP status code for GET /backoffice/login");
        
    }
}

down

cooper at asu dot ntu-kpi dot kiev dot ua ¶

18 years ago

If you are using not object-oriented functions and it takes too much time to change them all (or you'll be replacing them later) then as a temporary decision can be used this modules:

For DOM XML:
http://alexandre.alapetite.net/doc-alex/domxml-php4-php5/

For XSLT:
http://alexandre.alapetite.net/doc-alex/xslt-php4-php5/

down

aidan at php dot net ¶

19 years ago

When dealing with validation or loading, the output errors can be quite annoying.

PHP 5.1 introduces libxml_get_errors().

http://php.net/libxml_get_errors

down

johanwthijs-at-hotmail-dot-com ¶

19 years ago

Being an experienced ASP developer I was wondering how to replace textual content of a node (with msxml this is simply acheived by setting the 'text' property of a node). Out of frustration I started to play around with SimpleXml but I could not get it to work in combination with xPath.

I took me a lot of time to find out so I hope this helps others:

function replaceNodeText($objXml, $objNode, $strNewContent){
    /*
    This function replaces a node's string content with strNewContent
    */
    $objNodeListNested = &$objNode->childNodes;
    foreach ( $objNodeListNested as $objNodeNested ){
         if ($objNodeNested->nodeType == XML_TEXT_NODE)$objNode->removeChild ($objNodeNested);
    }
    
    $objNode->appendChild($objXml->createTextNode($strNewContent));
}

$objXml= new DOMDocument();
$objXml->loadXML('<root><node id="1">bla</note></root>');
$objXpath = new domxpath($objXml);

$strXpath="/root/node[@id='1']";
$objNodeList = $objXpath ->query($strXpath);
foreach ($objNodeList as $objNode){
//pass the node by reference
replaceNodeText($objXml, &$objNode, $strImportedValue);
}

down

toby at tobiasly dot com ¶

19 years ago

This module is not included by default either in the CentOS 4 "centosplus" repository. For those using PHP5 on CentOS 4, a simple "yum --enablerepo=centosplus install php-xml" will do the trick (this will install both the XML and DOM modules).

down

PHPdeveloper ¶

17 years ago

The Yanik's dom2array() function (added on 14-Mar-2007 08:40) does not handle multiple nodes with the same name, i.e.:

<foo>
  <name>aa</name>
  <name>bb</name>
</foo>

It will overwrite former and your array will contain just the last one ("bb")

down

amir.laherATcomplinet.com ¶

19 years ago

This particular W3C page provides invaluable documentation for the DOM classes implemented in php5 (via libxml2). It fills in plenty of php.net's gaps:

http://www.w3.org/TR/DOM-Level-2-Core/core.html

Some key examples:
* concise summary of the class heirachy (1.1.1)
* clarification that DOM level 2 doesn't allow for population of internal DTDs
* explanation of DOMNode->normalize()
* explanation of the DOMImplementation class

The interfaces are described in OMG's Interface Definition Language

down

ohcc at 163 dot com ¶

9 years ago

<?php
    // this note is about how to get a DOMNode's outerHTML and innerHTML.
    $dom = new DOMDocument('1.0','UTF-8');
    $dom->loadHTML('<html><body><div><p>p1</p><p>p2</p></div></body></html>');    
    $node = $dom->getElementsByTagName('div')->item(0);    
    $outerHTML = $node->ownerDocument->saveHTML($node);    
    $innerHTML = '';
    foreach ($node->childNodes as $childNode){
        $innerHTML .= $childNode->ownerDocument->saveHTML($childNode);
    }
    echo '<h2>outerHTML: </h2>';
    echo htmlspecialchars($outerHTML);
    echo '<h2>innerHTML: </h2>';    
    echo htmlspecialchars($innerHTML);    
?>

down

miguelangelhdz at NOSPAM dot com ¶

16 years ago

After searching how to extend the DOMDocument and DOMElement I found a way in the bug: http://bugs.php.net/bug.php?id=35104. The following code shows how:

<?php
class extDOMDocument extends DOMDocument {
 public function createElement($name, $value=null) {
  $orphan = new extDOMElement($name, $value); // new  sub-class object
  $docFragment = $this->createDocumentFragment(); // lightweight container maintains "ownerDocument"
  $docFragment->appendChild($orphan); // attach
  $ret = $docFragment->removeChild($orphan); // remove
  return $ret; // ownerDocument set; won't be destroyed on  method exit
 }
 // .. more class definition
}

class extDOMElement extends DOMElement {
 function __construct($name, $value='', $namespaceURI=null) {
  parent::__construct($name, $value, $namespaceURI);
 }
  //  ... more class definition here
}

$doc = new extDOMDocument('test');
$el = $doc->createElement('tagname');
$el->setAttribute("attr", "val");
$doc->appendChild($el); 

// append discards the DOMDocumentFragment and just adds its child nodes, but ownerDocument is maintained.
echo get_class($el)."<br/>";
echo get_class($doc->documentElement)."<br/>";
echo "<xmp>".$doc->saveXML()."</xmp>";
?>

down

sweisman at pobox dot com ¶

15 years ago

I had problems with the dom2array_full function by "nospam at ya dot ru". Here's my function, which works correctly for my project, and might work for yours:



<?php

function dom_to_array($root)

{

    $result = array();



    if ($root->hasAttributes())

    {

        $attrs = $root->attributes;



        foreach ($attrs as $i => $attr)

            $result[$attr->name] = $attr->value;

    }



    $children = $root->childNodes;



    if ($children->length == 1)

    {

        $child = $children->item(0);



        if ($child->nodeType == XML_TEXT_NODE)

        {

            $result['_value'] = $child->nodeValue;



            if (count($result) == 1)

                return $result['_value'];

            else

                return $result;

        }

    }



    $group = array();



    for($i = 0; $i < $children->length; $i++)

    {

        $child = $children->item($i);



        if (!isset($result[$child->nodeName]))

            $result[$child->nodeName] = dom_to_array($child);

        else

        {

            if (!isset($group[$child->nodeName]))

            {

                $tmp = $result[$child->nodeName];

                $result[$child->nodeName] = array($tmp);

                $group[$child->nodeName] = 1;

            }



            $result[$child->nodeName][] = dom_to_array($child);

        }

    }



    return $result;

}

?>

down

Drupella ¶

13 years ago

Here is a fast innerHTML function that returns the result without iterating over child nodes.

<?php
function innerHTML($el) {
  $doc = new DOMDocument();
  $doc->appendChild($doc->importNode($el, TRUE));
  $html = trim($doc->saveHTML());
  $tag = $el->nodeName;
  return preg_replace('@^<' . $tag . '[^>]*>|</' . $tag . '>$@', '', $html);
}
?>

Example
<?php
$doc = new DOMDocument();
// A corrupt HTML string
$doc->loadHTML('<HTML><A HREF="ss">asd</A>');
$body = $doc->getElementsByTagName('body')->item(0);
print htmlspecialchars(innerHTML($body));
// Prints <a href="ss">asd</a>
?>

down

Junior ¶

15 years ago

innerHTML in PHP DOM 



<?php

function DOMinnerHTML($element)

{

    $innerHTML = "";

    $children = $element->childNodes;

    foreach ($children as $child) 

    {

        $tmp_dom = new DOMDocument();

        $tmp_dom->appendChild($tmp_dom->importNode($child, true));

        $innerHTML.=trim($tmp_dom->saveHTML());

    }

    return $innerHTML;

}

?>



Example:



<?php

$dom= new DOMDocument(); 

$dom->load($html_string);

$dom->preserveWhiteSpace = false;



$domTable = $dom->getElementsByTagName("table");



foreach ($domTable as $tables)

{

    echo DOMinnerHTML($tables);

}

?>

down

spammable69 at hotmail dot com ¶

19 years ago

I wrote a framework to implement the StyleSheet interfaces as specified on the W3C website.  The code is written in PHP, and is NOT a complete implementation.  Use it how ya like.  I was planning on adding the CSSStyleSheet interfaces as well.  Feel free to ask.

<?
    class StyleSheetList {
        public length;
        private self;
        
        function __construct ( ) {
            $this->self = array();
        }
        
        function __get($property, $&ret) {
            if($property == 'length')
                $ret = count($this->self);
            return true;
        }
        
        function __set($property, $val) {
            if($property == 'length')
                return true;
        }
        
        function item( $index ) {
            return $this->self[$index];
        }
    }
    
    class MediaList extends StyleSheetList {
        
        function appendMedium ( $newMedium ) {
            array_push($this->self, $newMedium);
        }
        
        function deleteMedium ( $oldMedium ) {
            foreach($this->self as $item) {
                if( $item == $oldMedium ) {
                    $item = $this->self[ $this->length-1 ];
                    array_pop($this->self);
                    break;
                }
            }
        }
    }
    
    class DocumentStyle {
        public styleSheets;
        
        function __construct ( ) {
            $this->styleSheets = new StyleSheetList();
        }
        
        function __set($property, $val) {
            if($property == 'styleSheets')
                return true;
        }
    }
    
    class LinkStyle {
        public sheet;
        
        function __construct () {
            $this->sheet = new StyleSheet();
        }
        
        function __set($property, $val) {
            if($property == 'sheet')
                return true;
        }
    }
    
    class StyleSheet {
        public type;
        public disabled;
        public ownerNode;
        public parentStyleSheet;
        public href;
        public title;
        public media;
        
        function __construct( $type, $disabled, $ownerNode, $parentStyleSheet, $href, $title){
            $this->type = $type;
            $this->disabled = $disabled;
            $this->media = new MediaList();
            $this->ownerNode = $ownerNode;
            $this->parentStyleSheet = $parentStyleSheet;
            $this->href = $href;
            $this->title = $title;
        }
    }
?>

Only contactable via http://murpsoft.com/contact.html

down

-1

ben_demott at hotmail dot com ¶

14 years ago

A function among several others to parse a google results page, I wrote this some time ago - google has probably changed their site since then, but I thought this might be helpful to someone.

I'm moving servers, but I will probably throw this up on my blog when I get it back up.

<?php

function googleResult($listItem) {
    // given a LIST ITEM element, this will validate, and return an array for that LI entry as an inline result from google.
    /*
     * <li class='g w0'>
     *   <h3 class='r'>
     *     <a href='the URL' class='l'>
     *       Description <em>description</em>
     *     </a>
     *   </h3>
     * </li>
     *
       UPDATE:
       This function will now look for any subcontainer that has an href, it doesn't have to be an H3
       this will make it work with a few more formatted search results.
     */

    $listItem = $listItem->childNodes;
        // Yes I don't use instanceof - I guess you'll have to deal.
    foreach($listItem as $element) {
        if(is_object($element) && get_class($element) == 'DOMElement' && $element->hasChildNodes()) {
            $hrefContainer = $element->childNodes;
            foreach($hrefContainer as $element2) {
                if(is_object($element2) && get_class($element2) == 'DOMElement' && $element2->nodeName == 'a' && $element2->hasAttribute('href')) {
                    $anchor = $element2;
                    unset($h3);
                    unset($element2);
                    break;
                } else {
                  //print __LINE__ ." :: Breaking out of loop (normal result) element is not an annchor Element='".$element2->nodeName."'\n";
                }
            }
            unset($element);
            unset($listItem);
            break;
        }
    }
    if(empty($anchor) || !is_object($anchor) || get_class($anchor) != 'DOMElement') {
        //print __LINE__ ." :: Returning false, did not locate anchor through iteration...";
        return false;
    }
    $href = $anchor->getAttribute('href');
    if(empty($href)) {
        //print __LINE__ ." :: Found anchor object, could not read href attribute / href is empty? href='$href'\n";
        return false;
    }
    $description = $anchor->childNodes;
    $urlDescription = '';
    foreach($description as $words) {
        $name =  trim($words->nodeName);
        if($name == 'em' || $name == '#text' || $name == 'b') {
            if(!empty($words->nodeValue)) {
                $text = trim($words->nodeValue);
                $urlDescription = $urlDescription . $text . ' ';
            }
        }
    }
    $urlDescription = htmlspecialchars_decode($urlDescription, ENT_QUOTES);
    $urlDescription = trim($urlDescription);
    return array('description' => $urlDescription, 'href' => $href);
}

down

-1

philipwaynerollins at gmail dot com ¶

15 years ago

You can get the "innerHTML" by nodeValue so

<?php
    $doc = new DOMDocument( );
    $ele = $doc->createElement( 'p', 'Sensei Ninja' );
    print $ele->nodeValue;
?>

You can even set it if you want

<?php
    $doc = new DOMDocument( );
    $ele = $doc->createElement( 'p' );
    $ele->nodeValue = 'Sensei Ninja';
    $doc->appendChild( $ele );
    print $doc->saveHTML( );
?>

down

-1

sean at lookin3d dot com ¶

18 years ago

$xmlDoc=<<<XML
<?xml version="1.0"?>
<methodCall>
   <methodName>examples.getStateName</methodName>
   <params>
      <param>
         <value><i4>41</i4></value>
         </param>
      </params>
   </methodCall>
XML;

$xml= new DOMDocument();
$xml->preserveWhiteSpace=false;
$xml->loadXML($xmlDoc);
print_r(xml2array($xml));

function xml2array($n)
{
    $return=array();
    foreach($n->childNodes as $nc)
    ($nc->hasChildNodes())
    ?($n->firstChild->nodeName== $n->lastChild->nodeName&&$n->childNodes->length>1)
    ?$return[$nc->nodeName][]=xml2array($item)
    :$return[$nc->nodeName]=xml2array($nc)
    :$return=$nc->nodeValue;
    return $return;
}

down

-1

fantasyman3000 at gmail dot com ¶

16 years ago

In response to "simlee at indiana dot edu",
- First of all thanks for sharing your funciton.
- It didn't work for me so i rewrite it from scratch using different method.

Here is the new version, hope it helps someone : 

<?php
/**
* result sample : /html[1]/body[1]/span[1]/fieldset[1]/div[1]
* @return string
*/
function getNodeXPath( $node ) {    
    $result='';
    while ($parentNode = $node->parentNode) {
        $nodeIndex=-1;
        $nodeTagIndex=0;
        do {
            $nodeIndex++;
            $testNode = $parentNode->childNodes->item( $nodeIndex );
                
            if ($testNode->nodeName==$node->nodeName and $testNode->parentNode->isSameNode($node->parentNode) and $testNode->childNodes->length>0) {
                //echo "{$testNode->parentNode->nodeName}-{$testNode->nodeName}-{}<br/>";
                $nodeTagIndex++;
            }
                
        } while (!$node->isSameNode($testNode));

        $result="/{$node->nodeName}[{$nodeTagIndex}]".$result;
        $node=$parentNode;
    };
    return $result;
}
?>

By Sina.Salek.ws

down

-1

odessa131 at aol dot nospam dot com ¶

15 years ago

I had the hardest time updating a complex XML document. Here's a quick example on how to do it.

<?php 

// Load the XML from a file.
$xml = "a2062.xml"; // This is an XFDL form previously unencoded and ungzipped.
$dom = new DOMDocument();
$dom->preserveWhiteSpace = false;
$dom->Load($xml);

// Create an XPath query.
// Note: you must define the namespace if the XML document has defined namespaces.
$xpath = new DOMXPath($dom);
$xpath->registerNamespace('xfdl', "http://www.PureEdge.com/XFDL/6.5");

// Locate the value for the first Item Description field.
$query = "//xfdl:page/xfdl:field[@sid='ITEMDESA']/xfdl:value";
$nodeList = $xpath->query($query);

$nodeList->item(0)->nodeValue = "This is the text in the value node of the first Item Description field inside the DA 2062 PureEdge form.";

$dom->save($xml);

?>

I hope this helps someone.

down

-1

nospam at ya dot ru ¶

15 years ago

<?PHP
function dom2array_full($node){ 
    $result = array(); 
    if($node->nodeType == XML_TEXT_NODE) { 
        $result = $node->nodeValue; 
    } 
    else { 
        if($node->hasAttributes()) { 
            $attributes = $node->attributes; 
            if(!is_null($attributes))  
                foreach ($attributes as $index=>$attr)  
                    $result[$attr->name] = $attr->value; 
        } 
        if($node->hasChildNodes()){ 
            $children = $node->childNodes; 
            for($i=0;$i<$children->length;$i++) { 
                $child = $children->item($i); 
                if($child->nodeName != '#text') 
                if(!isset($result[$child->nodeName])) 
                    $result[$child->nodeName] = dom2array($child); 
                else { 
                    $aux = $result[$child->nodeName]; 
                    $result[$child->nodeName] = array( $aux ); 
                    $result[$child->nodeName][] = dom2array($child); 
                } 
            } 
        } 
    } 
    return $result; 
} 
?>

down

-1

brian dot reynolds at risaris dot com ¶

17 years ago

I found the xml2array function below very useful, but there seems to be a bug in it. The $item variable was never getting set. I've expanded this out to be a bit more readable, and the corrected code is : 

function xmlToArray($n)
{
    $return=array();

    foreach($n->childNodes as $nc){
        if( $nc->hasChildNodes() ){
            if( $n->firstChild->nodeName== $n->lastChild->nodeName&&$n->childNodes->length>1){
                $item = $n->firstChild;
                $return[$nc->nodeName][]=$this->xmlToArray($item);
            }
            else{
                 $return[$nc->nodeName]=$this->xmlToArray($nc);
            }
       }
       else{
           $return=$nc->nodeValue;
       } 
    }
    return $return;
}

down

-1

danf dot 1979 at []gmail[] dot com ¶

16 years ago

This is a couple of classes to deal with yahoo yui menu.

/*
  $menubar = new MenuBar();

  $file = new Menu("File");
  $file->setAttribute("href", "http://file.com");

  $quit = new Menu("Quit");
  $quit->setAttribute("href", "http://quit.com");

  $file->appendChild($quit);
  $menubar->appendChild($file);

  echo $menubar->grab();
*/

//
// Author: Daniel Queirolo.
// LGPL
//

/** ---------------------------------
/**  Class MenuBar()
/**  Creates a the menubar and appends
/**  yuimenubaritems to it.
/** ---------------------------------*/

class MenuBar extends DOMDocument
{

  public $menuID = "nav_menu";  // holds the css id that javascript yui menu code should have to recognize
  private $UL;                  // This node holds every menu, This is THE node.

  /** ---------------------------------
  /**  Constructor
  /**  Generates a menubar skeleton and the UL node
  /** ---------------------------------*/

  public function __construct() {

    parent::__construct();

    $rootdiv = parent::createElement("div");
    $rootdiv->setAttribute("class", "yui-skin-sam");

    parent::appendChild($rootdiv);

    $yui_menubar = parent::createElement("div");
    $yui_menubar->setAttribute("id", $this->menuID);
    $yui_menubar->setAttribute("class", "yuimenubar");

    $rootdiv->appendChild($yui_menubar);

    $bd = parent::createElement("div");
    $bd->setAttribute("class", "bd");

    $yui_menubar->appendChild($bd);

    $ul = parent::createElement("ul");
    $ul->setAttribute("class", "first-of-type");

    // ALL Menu() instances ocurr inside an <ul> tag.

    $this->UL = $bd->appendChild($ul);

  }

  /** ---------------------------------
  /**  appendChild()
  /**  Appends a new yuimenubaritem to the menubar UL node.
  /**  This function changes <li> and <a> classes to yuiMENUBARsomething
  /** ---------------------------------*/

  public function appendChild($child) {

    $li = parent::importNode($child->LI, true);

    $li->setAttribute("class", "yuimenubaritem");

    $li->getElementsByTagName("a")->item(0)->setAttribute("class", "yuimenubaritemlabel");

    $this->UL->appendChild($li);

  }

  public function grab() {

    return parent::saveHTML();

  }

}

/** ---------------------------------
/**  Class Menu()
/**  Creates a yuimenuitem li node
/** ---------------------------------*/

class Menu extends DOMDocument {

  public $LI; // stores the <li> node (THE link) that will be exported to MenuBar() or used on appendChild()

  /** ---------------------------------
  /**  Constructor
  /**  Generates a yuimenuitem li node
  /**  No yuimenubar items are created here. MenuBar handles that.
  /** ---------------------------------*/

  public function __construct($link_name) {

    parent::__construct();

    $li = parent::createElement("li");
    $li->setAttribute("class", "yuimenuitem");

    // LI node stores THE link.
    // if appendChild is used, the new (sub) Menu() would be LI node child.

    $this->LI = parent::appendChild($li);

    $a = parent::createElement("a", $link_name);
    $a->setAttribute("class", "yuimenuitemlabel");

    $li->appendChild($a);

    $this->li = $li;
    $this->a = $a;

  }

  /** ---------------------------------
  /**  appendChild
  /**  Appends a (sub) Menu() to current Menu() in LI
  /** ---------------------------------*/

  public function appendChild($child) {

    $yuimenu = parent::createElement("div");
    $yuimenu->setAttribute("class", "yuimenu");

    $this->LI->appendChild($yuimenu);

    $bd = parent::createElement("div");
    $bd->setAttribute("class", "bd");

    $yuimenu->appendChild($bd);

    $ul = parent::createElement("ul");

    $bd->appendChild($ul);

    // child->NODE holds THE link from the new child (from child's __construct())

    $ul->appendChild(parent::importNode($child->LI, true));

  }

  public function setAttribute($name, $value, $node="a") {

      if ($node == "a") {
        $this->a->setAttribute($name, $value);
      }

      else {
        $this->li->setAttribute($name, $value);
      }
  }

}

down

-1

Sanados at failure dot at ¶

17 years ago

appended to 
brian dot reynolds at risaris dot com
20-Feb-2007 10:09

when you got variable nodes at start you array fails and looses nodes  beneath.
solution that counts occurance though eats up performance:

function xmlToArray($n)
{
    $xml_array = array();
    $occurance = array();

     foreach($n->childNodes as $nc)
     {
         $occurance[$nc->nodeName]++;
     }
     
    foreach($n->childNodes as $nc){
        if( $nc->hasChildNodes() )
        {
            if($occurance[$nc->nodeName] > 1)
            {
                $xml_array[$nc->nodeName][] = xmlToArray($nc);
            }
            else
            {
                $xml_array[$nc->nodeName] = xmlToArray($nc);
            }
        }
        else
        {
            return utf8_decode($nc->nodeValue);
        }
    }
    return $xml_array;
}

down

-1

Nevyn at N dot O dot S dot P dot A dot M dot emai dot it ¶

17 years ago

I wrote a couple of functions to:
 - create a DOMDocument from a file
 - parse the namespaces in it
 - create a XPath object with all the namespaces registered
 - load the schemalocations
 - validate the file on the main schema (the one without prefix)

It is useful for me, see if it is also for someone else!!

Giulio

function decodeNode($node)
{
    $out = $node->ownerDocument->saveXML($node);
    $re = "{^<((?:\\w*:)?\\w*)". //the tag name
    "[\\s\n\r]*((?:[\\s\n\r]*". 
    "(?:\\w*:)?\\w+[\\s\n\r]*=[\\s\n\r]*". //possible attribute name
    "(?:\"[^\"]*\"|\'[^\']*\'))*)". //attribute value
    "[\\s\n\r]*>[\r\n]*".
    "((?:.*[\r\n]*)*)". //content
    "[\r\n]*</\\1>$}"; //closing tag
    preg_match($re, $out, $mat);
    return $mat;
}

function innerXml($node)
{
    $mat = decodeNode($node);
    return $mat[3];
}

function getnodeAttributes($node)
{
    $mat = decodeNode($node);
    $txt = $mat[2];
    $re = "{((?:\\w*:)?\\w+)[\\s\n\r]*=[\\s\n\r]*(\"[^\"]*\"|\'[^\']*\')}";
    preg_match_all($re, $txt, $mat);
    $att = array();
    for ($i=0; $i<count($mat[0]); $i++)
    {
        $value = $mat[2][$i];
        if ($value[0] == "\'" || $value[0] == "\"")
        {
            $len = strlen($value);
            $value = substr($value, 1, strlen($value)-2);
        }
        $att[ $mat[1][$i] ] = $value;
    }
    return $att;
}

function loadXml($file)
{
    $doc = new DOMDocument();
    $doc->load($file);
    //cerca l'attributo xmlns
    $xsi = false;
    $doc->namespaces = array();
    $doc->xpath = new DOMXPath($doc);
    
    $attr = getnodeAttributes($doc->documentElement);
    foreach ($attr as $name => $value)
    {
        if (substr($name,0,5) == "xmlns")
        {
            $uri = $value;
            $pre = $doc->documentElement->lookupPrefix($uri);
            if ($uri == "http://www.w3.org/2001/XMLSchema-instance")
                $xsi = $pre;
            $doc->namespaces[$pre] = $uri;
            if ($pre == "")
                $pre = "noname";
            $doc->xpath->registerNamespace($pre, $uri);
        }
    }
    
    if ($xsi)
    {
        $doc->schemaLocations = array();
        $lst = $doc->xpath->query("//@$xsi:schemaLocation");
        foreach($lst as $el)
        {
            $re = "{[\\s\n\r]*([^\\s\n\r]+)[\\s\n\r]*([^\\s\n\r]+)}";
            preg_match_all($re, $el->nodeValue, $mat);
            for ($i=0; $i<count($mat[0]); $i++)
            {
                $value = $mat[2][$i];
                $doc->schemaLocations[ $mat[1][$i] ] = $value;
            }
        }

        $olddir = getcwd();
        chdir(dirname($file));
        $schema = $doc->schemaLocations[$doc->namespaces[""]];
        if (substr($schema,0,7) == "file://")
        {
            $schema = substr($value,7);
        }
        if (!$doc->schemaValidate($schema))
            dbg()->err("Invalid file");
        chdir($olddir);
    }
    
    return $doc;
}

down

-1

mark at vectrex dot org dot uk ¶

19 years ago

Note that these DOM functions expect (and presumably return) all their data in UTF-8 character encoding, regardless of what PHP's current encoding is. This means that text nodes, attribute values etc, should be in utf8.

This applies even if you're generating an XML document which is not ultimately in utf8.

Mark

down

-1

php at webdevelopers dot cz ¶

19 years ago

[Editor's Note: If you're using entities, then you have no choice. XML Catalogs can speed DTD resolution.]



Never use 



$dom->resolveExternals=true;



when parsing XHTML document that has the DOCTYPE declaration with DTD URL specified in it.



Otherwise parsing the XHTML with DOCTYPE like this one:



<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">



will result in PHP/DOM downloading the DTD file from W3C site when parsing your document. It will add extra delay to your script - I experienced that $dom->load()'s total time was from 1 to 16 seconds.



elixon

down

-1

chealer at gmail dot com ¶

6 years ago

This extension allows editing an HTML snippet, for example removing an element:
‌‌$dom = new DOMDocument();
‌‌$dom->loadHTML('keep<b id="simple">REMOVE</b>');
$‌‌remove = $dom->getElementById('simple');
‌‌$dom->removeChild($‌‌remove);
echo ‌‌$dom->saveHTML();
...would output "keep".

But it does not preserve formatting. If your code defines attributes using double quotes, saveHTML() may for instance return single quotes instead.

down

-3

naudyj at aus3d.com ¶

16 years ago

The following can take a XML_TEXT_NODE node and return the contents in an array. Yanick's contribution rocks - but
it overwrote with duplicates only keeping the last line
in the returned array. All the other functions i tested from various sources failed to handle text nodes correctly. Hope this helps someone. It is adapted from code on this site.

function myTextNode($n, &$a)
{
 static $depth = 0;
 static $sz = '';

 if ($cn = $n->firstChild) 
 {
  while ($cn)
  {
   if ($cn->nodeType == XML_TEXT_NODE) 
   {
    $sz .= $cn->nodeValue;
   } 
   elseif ($cn->nodeType == XML_ELEMENT_NODE) 
   {
    $b = 1;
    if ($cn->hasChildNodes()) 
    {
     $depth++;
     if ($this->myHeadings($cn, $a)) 
     {
      if ($sz){
       array_push($a, $sz);
       $sz = '';
      }
     }
     $depth--;
    }
   }
   $cn = $cn->nextSibling;
  }
  return $b;
 }
} 

so you could use:   

$nodes = $dom->getElementsByTagName("td"); 
if($nodes){
 foreach ($nodes as $node){
  $a = Array();
  myTextNode($node, $a);
 }
}

down

-2

Anonymous ¶

16 years ago

In response to...
"If you create your own custom element extending DOMElement and append him in place of the document element, you cannot access to any new members newly defined in your custom class via DOMDocument::$documentElement."

... it is not a bug, it is a feature. The DOMDocument::$documentElement property name may be misleading but according to the DOM Level 2 Core specification it is a convenience attribute meant to access the root element of your DOMDocument. See here: http://www.w3.org/TR/DOM-Level-2-Core/core.html#i-Document

down

-2

ryoroxdahouse at hotmail dot com ¶

16 years ago

I use DOM to generate dynamically XHTML document.

When trying to extend the DOMDocument and DOMElement classes, I found a very annoying bug concerning DOMDocument::$documentElement.

If you create your own custom element extending DOMElement and append him in place of the document element, you cannot access to any new members newly defined in your custom class via DOMDocument::$documentElement.

In my situation, I cannot use DOMDocument::registerNodeClass() because the document element is not necessarily the base class for all the elements in my document.

*******
problem
*******

See bellow for the repro step:

<?php
    class MyElement extends DOMElement{
        public $myProp="myProp";
        public function myMethod(){
            return 'myMethod()';
        }
    }
    
    $myDocument=new DOMDocument();
    $myDocument->appendChild(new MyElement('myElement','myElement'));
    echo ('$myElement->myProp :'.$myDocument->documentElement->myProp.'<br />');
    echo ('$myElement->myMethod :'.$myDocument->documentElement->myMethod().'<br />');
?>

will output:

Notice: Undefined property: DOMElement::$myProp in C:\Program Files\EasyPHP 2.0b1\www\testDOMBug\test2.php on line 11
$myElement->myProp :

Fatal error: Call to undefined method DOMElement::myMethod() in C:\Program Files\EasyPHP 2.0b1\www\testDOMBug\test2.php on line 12

*******
solution
*******

After searching around, I found a pretty odd way to fix this problem. It seems that you have to stock a reference to your appended document element in an user-defined (and persistent) variable (in other words, not only in DOMDocument::$documentElement). See below:

<?php    
    class MyElement extends DOMElement{
        public $myProp="myProp";
        public function myMethod(){
            return 'myMethod()';
        }
    }
    
    $myDocument=new DOMDocument();
    $mydocumentElement=$myDocument->appendChild(new MyElement('myElement','myElement')); //here is the hack
    echo ('$myElement->myProp :'.$myDocument->documentElement->myProp.'<br />');
    echo ('$myElement->myMethod :'.$myDocument->documentElement->myMethod().'<br />');
?>

will output:

$myElement->myProp :myProp
$myElement->myMethod :myMethod()

Hope it will help.

down

-3

Francois Hill ¶

17 years ago

In response to lutfi at smartconsultant dot us :

(see my post on
http://fr2.php.net/manual/en/
function.dom-domdocument-getelementsbytagname.php
)

Use this class I wrote:

class XPathableNode extends DOMNode
{
    protected $Node;
    protected $DOMDocument_from_node;
    protected $DOMXpath_for_node;

    public function __construct(/* DOMNode */ $node)
    {
        $this->Node=$node;
        $this->DOMDocument_from_node=new 
                                                          DomDocument();
        $domNode=$this->DOMDocument_from_node
                                  ->importNode($this->Node, true);
        $this->DOMDocument_from_node
                                 ->appendChild($domNode);
        $this->DomXpath_for_node = 
                    new Domxpath($this->
                                         DOMDocument_from_node);
    }

    public function convertHTML()
    {    return $this->DOMDocument_from_node
                                                             ->saveHTML();
    }

    public /*DomNodeList*/ function applyXpath($xpath)
    {    return $this->DomXpath_for_node
                                                       ->query($xpath);
    }
}

(sorry for the display... What a terrible hinderance on the
part of php.net !)

Then :
Make a new XPathableNode out of your parent node.
You may then retrieve a DOMNodeList from it by applying a
xpath (thus being able to specify the depth  and name of 
elements you want).

Has got me around some (of the many) DOM awkwardnesses a few times.

;o)

down

-6

Sven Arduwie ¶

16 years ago

I needed a function that quickly converts an xml with key/value pairs to an array.

for example:
<?xml version="1.0" encoding="UTF-8"?>
<test>
    <key id="Array key #1" value="Value #1"/>
    <key id="Array key #2" value="Value #2"/>
    <key id="Dupe" value="Duplicate keys"/>
    <key id="Dupe" value="create numeric arrays"/>
    <key id="And another key">
        <![CDATA[
            Multiline
            data
            works
            just
            as
            well.
        ]]>
    </key>
    <nested>
        <key id="Nested key" value="Nested data works as well, but it still results in a 1 dimensional array."/>
    </nested>
</test>

Results in the following array:
array(5) {
  ["Array key #1"]=>
  string(8) "Value #1"
  ["Array key #2"]=>
  string(8) "Value #2"
  ["Dupe"]=>
  array(2) {
    [0]=>
    string(14) "Duplicate keys"
    [1]=>
    string(21) "create numeric arrays"
  }
  ["And another key"]=>
  string(49) "Multiline
            data
            works
            just
            as
            well."
  ["Nested key"]=>
  string(73) "Nested data works as well, but it still results in a 1 dimensional array."
}

Here's the code:
<?php
    function xml2array($xml) {
        $domDocument = new DOMDocument;
        $domDocument->loadXML($xml);
        $domXPath = new DOMXPath($domDocument);
        $array = array();
        foreach ($domXPath->query('//key') as $keyDOM) {
            $id = $keyDOM->getAttribute('id');
            $value = $keyDOM->hasAttribute('value') ? $keyDOM->getAttribute('value') : trim($keyDOM->textContent);
            if (array_key_exists($id, $array)) {
                if (is_array($array[$id])) {
                    $array[$id][] = $value;
                } else {
                    $array[$id] = array($array[$id]);
                    $array[$id][] = $value;
                }
            } else {
                $array[$id] = $value;
            }
        }
        return $array;
    }
?>

down

-4

jim.filter (at gmail.com) ¶

17 years ago

Array to DOM

Here is a recursive function to turn a multidimensional array into an XML document.  It will handle multiple elements of the same tag, but only one per parent element. IE: 

Can't generate:         Can generate:
<root>                  <root>
  <sub1>data1</sub1>      <subs1>
  <sub1>data2</sub1>         <value>data1</value>
  <sub2>data1</sub2>         <value>data2</value>
  <sub2>data2</sub2>      </subs1>
</root>                   <subs2>
                            <value>data1</value>
                            <value>data2</value>
                          <subs2>
                        </root>

Also, the function performs no type of error checking on your array and will throw a DOMException if a key value you used in your array contains invalid characters for a proper DOM tag. This function is untested for "deep" multidimensional arrays.

Complete code ready to run with example:

<?PHP
  function AtoX($array, $DOM=null, $root=null){
    
    if($DOM  == null){$DOM  = new DOMDocument('1.0', 'iso-8859-1');}
    if($root == null){$root = $DOM->appendChild($DOM->createElement('root'));}
    
    $name = $array['#MULTIPLE_ELEMENT_NAME'];

      foreach($array as $key => $value){    
        if(is_int($key) && $name != null){
          if(is_array($value)){
            $subroot = $root->appendChild($DOM->createElement($name));
            AtoX($value, $DOM, $subroot);
          }
          else if(is_scalar($value)){
            $root->appendChild($DOM->createElement($name, $value));
          }
        }
        else if(is_string($key) && $key != '#MULTIPLE_ELEMENT_NAME'){
          if(is_array($value)){
            $subroot = $root->appendChild($DOM->createElement($key));
            AtoX($value, $DOM, $subroot);
          }
          else if(is_scalar($value)){
            $root->appendChild($DOM->createElement($key, $value));
          }
        }
      }
    return $DOM;  
  }
  
  $array = array(
                    '#MULTIPLE_ELEMENT_NAME' => 'GenericDatas',
                    'Date'      => 'November 03, 2007',
                    'Company'   => 'Facility One',
                    'Field'     => 'Facility Management Software',
                    'Employees' => array(
                                      '#MULTIPLE_ELEMENT_NAME' => 'Employee',
                                      'Cindy',
                                      'Sean',
                                      'Joe',
                                      'Owen',
                                      'Jim',
                                      'Dale',
                                      'Kelly',
                                      'Ryan',
                                      'Johnathan',
                                      'Robin',
                                      'William Marcus',
                                      'NewCoops' => array(
                                                          '#MULTIPLE_ELEMENT_NAME' => 'Coop',
                                                          'John',
                                                          'Tyler',
                                                          'Ray',
                                                          'Dawn'
                                                         )     
                                    ),
                    'Datas',
                    'DATAS',
                    'OtherDatas'
                );
  
  $DOM  = new DOMDocument('1.0', 'iso-8859-1');
  $root = $DOM->appendChild($DOM->createElement('CompanyData')); 
  $DOM  = AtoX($array, $DOM, $root);
  $DOM->save('C:\test.xml');
?>

＋add a note