PDF de programación - Resumen de uso de funciones DOM con PHP

Resumen de uso de funciones DOM con PHP



El Document Object Mode (DOM), es la especificación de una interfaz no
dependiente del lenguaje de programación que permite a programas
acceder, modificar y actualizar la estructura y el estilo de documentos.
DOM proporciona un conjunto de objetos estándar para representar
documentos XML y HTML y un conjunto de operaciones para acceder a
ellos y modificarlos.
PHP
DOM
(http://www.php.net/manual/en/ref.dom.php) mediante un conjunto de
clases que representan los objetos definidos en la especificación y las
funciones para trabajar con ellos.
La siguiente figura representa de manera simplificado el conjunto de
entidades (objetos, clases) que podemos utilizar en con DOM, con un
ejemplo de documento.


implementa

estándar

el




En la implementación PHP manejaremos fundamentalmente las siguientes
clases:

• DOMNode. Es la clase base de la mayoría de clases de la
implementación. Proporciona métodos para crear nuevos elementos,
moverse por el árbol que representa un documento, etc. Las clases
que extienden (por herencia) a esta, tienen acceso a sus métodos y
propiedades.

• DOMDocument. Extiende DOMElement. Representa un documento
y proporciona métodos para crear nuevos elementos y realizar
búsquedas por un documento DOM.

• DOMElement. Extiende DOMElement. Representa un elemento
dentro del documento y proporciona métodos para acceder y
modificar los atributos de un nodo.

• DOMNodeList. Representa una lista de DOMNodes.
Algunas de las funciones más utilizadas son las siguientes:

• DOMNode->appendChild() - Adds new child at the end of the children

• DOMNode->removeChild() - Removes child from list of children

• DOMNode->hasAttributes() - Checks if node has attributes

• DOMNode->hasChildNodes() - Checks if node has children

Sus propiedades son:

Name

Type

Read-
only

Description

nodeName

string

nodeValue

string

nodeType

int

parentNode

DOMNode

childNodes

DOMNodeList

firstChild

DOMNode

lastChild

DOMNode

previousSibling DOMNode

nextSibling

DOMNode

yes

no

yes

yes

yes

yes

yes

yes

yes

attributes

DOMNamedNodeMap yes

ownerDocument DOMDocument

namespaceURI string

yes

yes

Returns the most accurate name for
the current node type
The value of this node, depending on
its type.
Gets the type of the node. One of the
predefined XML_xxx_NODE
constants
The parent of this node.
A DOMNodeList that contains all
children of this node. If there are no
children, this is an empty
DOMNodeList.
The first child of this node. If there is
no such node, this returns NULL.
The last child of this node. If there is
no such node, this returns NULL.
The node immediately preceding this
node. If there is no such node, this
returns NULL.
The node immediately following this
node. If there is no such node, this
returns NULL.
A DOMNamedNodeMap containing
the attributes of this node (if it is a
DOMElement) or NULL otherwise.
The DOMDocument object associated
with this node.
The namespace URI of this node, or
NULL if it is unspecified.

Name

Type

prefix

string

localName

string

baseURI

string

textContent

string

Read-
only

no

yes

yes

no

Description

The namespace prefix of this node, or
NULL if it is unspecified.
Returns the local part of the qualified
name of this node.
The absolute base URI of this node or
NULL if the implementation wasn't able
to obtain an absolute URI.
This attribute returns the text content
of this node and its descendants.

La segunda columna indica el tipo de datos devuelto al invocar a la
propiedad.

Si observamos la propiedad nodeList, por ejemplo, vemos que devuelve un
DOMNodeList, es decir una lista de nodos que son descendientes del nodo
sobre el que se invoca la propiedad.

La clase DOMNodeList sólo tiene un método DOMNode item($index) y
una propiedad length. Es decir, que sólo se utiliza para recorrer una lista de
nodos, mediante un bucle for y acceder a sus elementos.


$link=conectar();


El siguiente ejemplo muestra cómo crear un documento XML:
<?php
//Incluimos las funciones de conexion y desconexion a la BBDD
include carrito.php
























//Nos conectamos a la Base de Datos



$query = "SELECT * FROM catalogo ";

$result = mysql_query($query, $link);
//print_r($result);
//Comprobar resultado de la conexi�n y muestra del cat�logo
if(!$result){



}



$dom = new DOMDocument('1.0', 'iso-8859-1');

$element = $dom->createElement('Catalogo');
$Catalogo = $dom -> appendChild($element);

while($row = mysql_fetch_assoc($result))

$message = 'Invalid query: ' .mysql_error() . "\n";
$message = 'Whole query: ' . $query;
die($message);

















$element = $dom->createElement('Producto');

$Producto = $Catalogo -> appendChild($element);



$Producto -> setAttribute("Cat", $row['categoria']);



$element = $dom->createElement('Nombre'

,$row['descripcion']);
$Descripcion = $Producto -> appendChild($element);


$element = $dom->createElement('Precio',

$row['precio']);
$Precio = $Producto -> appendChild($element);




$element = $dom->createElement('Unidades',
$row['unidades']);
$Cantidad = $Producto -> appendChild($element);





?>

{













}
mysql_close($link);
echo $dom -> saveXML();






En el ejemplo, se accede a una BBDD para seleccionar una tabla de un
catálogo. A continuación se crea una instancia de la clase DOMDocument,
que utilizaremos para crear todos los elementos del documento. Es
necesario añadir los nodos al documento invocando la función appendChild
del nodo sobre el que queremos insertar un descendiente en el árbol. Por
tanto se añade un nuevo elemento al documento creado, de manera que
tenemos el elemento raíz. La invocación del método appenChild devuelve
un puntero al nuevo nodo insertado en el documento, que utilizaremos para
seguir insertando descendientes jerárquicamente. Por ejemplo, $Catalogo =
$dom -> appendChild($element); Inserta el elemento raíz y devuelve un
puntero al nodo añadido, con lo que posteriormente podemos insertar
elementos que desciendan del
->
appendChild($element);

$Producto =

$Catalogo

raíz

Finalmente, la función saveXML() devuelve una cadena de texto con la
instancia XML del documento DOM en uso.

Para trabajar con instancias XML previamente creadas se utilizan las
funciones de búsqueda de DOMDocument, así como las propiedades de los
DOMNodes:
$dom = new DOMDocument('1.0');
$dom->load('exportar.xml');
//Obtenemos el elemento raiz como DOMNodeList
$array = $dom->getElementsByTagName("Catalogo");
//Obtenemos el primer elemento (la lista solo tiene uno)
$cat=$array->item(0);
//Obtenemos todos los hijos de este nodo (productos)
$nodes = $cat->childNodes;
for ($i = 0; $i < $nodes->length; $i++) {

$node= $nodes->item($i);
//Buscamos su atributo
$categ= $node->attributes->getNamedItem("Cat")->nodeValue;
//Para cada producto obtenemos sus hijos
$prod = $node->childNodes;
$name = $prod -> item(0)->nodeValue;
$precio = $prod->item(1)->nodeValue;
$unidades = $prod->item(2)->nodeValue;
$query="INSERT INTO catalogo (categoria, descripcion, precio,
mysql_query($query,$l);









//Insertamos el producto en la BBDD

unidades) VALUES(".$categ.",".$name.",".$precio.",".$unidades.")";

}
desconectar($l);
?>



En primer lugar se carga en memoria la instancia XML con la que se va a
trabajar:
$dom = new DOMDocument('1.0');
$dom->load('exportar.xml');

A continuación se buscan los elementos que nos interesan.
$array = $dom->getElementsByTagName("Catalogo");

La invocación anterior devolvería un DOMNodeList con todos los
elementos del documento que se llamen “Catalogo”. Como, en este caso
“Catalogo” es el elemento raíz, la lista sólo contendrá un elemento.
$cat=$array->item(0);

En este momento podemos obtener todos los descendientes de raíz y
recorrerlos para trabajar con ellos:
//Obtenemos todos los hijos de este nodo (productos)
$nodes = $cat->childNodes;
for ($i = 0; $i < $nodes->length; $i++) {




$node= $nodes->item($i);



...
...











Resumen de acceso a BBDD con PHP

Para acceder a una BBDD con PHP debemos utilizar las funciones
correspondientes a la BBDD que estamos utilizando. En la documentación
de PHP se pueden encontrar funciones para trabajar con multitud de
BBDD. En nuestro caso utilizamos una BBDD MySQL, con lo que
tenemos que usar las funciones correspondiente.

Para trabajar con una BBDD usualmente se siguen los siguientes pasos:

1. Conectar a la BBDD usando la función mysql_connect().

$link = mysql_connect('localhost', 'ad', 'ad')


or die('Could not connect: ' . mysql_error());



2. Seleccionar una BBDD en particular usando

mysql_select_db().

la

función

mysql_select_db('adprueba') or die('Could not select database');

3. A partir de este momento, se realiza la consulta deseada, creando una

cadena de caracteres con las sentencias SQL necesarias.

$query = 'SELECT * FROM catalogo WHERE
`categoria`='.mysql_escape_string($c);

4. Se ejecuta la consulta con mysql_query(). Los resultados se
devuelven en forma de tabla (matriz) dónde cada fila corresponde a
la fila correspondiente en la BBDD (según la consulta).

recorre

la matriz

función
mysql_fetch_assoc(). Cada llamada a la función devuelve una fila de
la tabla hasta que llegar al final.

la

5. Se

de

resultados

con

// Printing results in HTML


echo "<tr>";
echo "\t\t<td><input type=\"radio\" name=\"id\"

value=\"".$line["id"]."\"></t