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
implementa
el
estándar
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.
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
Readonly
Description
nodeName
string
yes
Returns the most accurate name for
the current node type
nodeValue
string
no
The value of this node, depending on
its type.
nodeType
int
yes
Gets the type of the node. One of the
predefined XML_xxx_NODE
constants
parentNode
DOMNode
yes
The parent of this node.
childNodes
DOMNodeList
yes
A DOMNodeList that contains all
children of this node. If there are no
children, this is an empty
DOMNodeList.
firstChild
DOMNode
yes
The first child of this node. If there is
no such node, this returns NULL.
lastChild
DOMNode
yes
The last child of this node. If there is
no such node, this returns NULL.
previousSibling DOMNode
yes
The node immediately preceding this
node. If there is no such node, this
returns NULL.
nextSibling
yes
The node immediately following this
node. If there is no such node, this
returns NULL.
DOMNamedNodeMap yes
A DOMNamedNodeMap containing
the attributes of this node (if it is a
DOMElement) or NULL otherwise.
attributes
DOMNode
ownerDocument DOMDocument
yes
The DOMDocument object associated
with this node.
namespaceURI string
yes
The namespace URI of this node, or
NULL if it is unspecified.
Name
Type
Readonly
Description
prefix
string
no
The namespace prefix of this node, or
NULL if it is unspecified.
localName
string
yes
Returns the local part of the qualified
name of this node.
baseURI
string
yes
The absolute base URI of this node or
NULL if the implementation wasn't able
to obtain an absolute URI.
textContent
string
no
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.
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
$link=conectar();
$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){
$message = 'Invalid query: ' .mysql_error() . "\n";
$message = 'Whole query: ' . $query;
die($message);
}
$dom = new DOMDocument('1.0', 'iso-8859-1');
$element = $dom->createElement('Catalogo');
$Catalogo = $dom -> appendChild($element);
while($row = mysql_fetch_assoc($result))
{
$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 raíz $Producto = $Catalogo ->
appendChild($element);
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;
//Insertamos el producto en la BBDD
$query="INSERT INTO catalogo (categoria, descripcion, precio,
unidades) VALUES(".$categ.",".$name.",".$precio.",".$unidades.")";
mysql_query($query,$l);
}
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
mysql_select_db().
en
particular
usando
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).
5. Se recorre la matriz de resultados con la función
mysql_fetch_assoc(). Cada llamada a la función devuelve una fila de
la tabla hasta que llegar al final.
// Printing results in HTML
while ($line = mysql_fetch_array($result, MYSQL_ASSOC)) {
echo "<tr>";
echo "\t\t<td><input type=\"radio\" name=\"id\"
value=\"".$line["id"]."\"></td>\n";
echo "<td>".$line["descripcion"]."</td>\n";
echo "<td>".$line["precio"]."</td>\n";
echo "<td>".$line["unidades"]."</td>\n";
echo "\t</tr>\n";
}
6. Se liberan memoria con mysql_free_result(). Para consultas grandes
esto mejora el rendimiento.
7. Se cierra la conexión a la BBDD cuando no hay más consultas que
ejecutar
mysql_close($link);
Los pasos 3, 4 y 5 se repiten tantas veces como sea necesario, es decir
para cada consulta que sea necesario hacer.
La sintaxis de las consultas más comunes es la siguiente:
Borrar:
DELETE FROM Tabla WHERE user = 'jcole'
Insertar:
INSERT INTO Tabla (col1, col2, col3) VALUES(15, 76, 43)
Actualizar una fila:
UPDATE Tabla SET dni=48423234
UPDATE Tabla SET age=age+1
Seleccionar datos:
SELECT * FROM Tabla;
SELECT dni, edad FROM Tabla
Para seleccionar, actualizar o borrar se pueden especificar condiciones
añadiendo la cláusula WHERE al final. Esta cláusula puede usar
expresiones:
SELECT * FROM Tabla WHERE dni=47373621
SELECT * FROM Tabla WHERE unidades=15 AND precio < 100
UPDATE Tabla SET edad=26 WHERE dni=48423234
Aunque se podrían realizar múltiples consultas sucesivas con PHP, casi
siempre es preferible combinar consultas sobre varias tablas. Por ejemplo:
SELECT tabla.dni, tabla2.salario FROM tabla1, tabla2
WHERE t1.dni = t2.dni;
La consulta anterior permite seleccionar elementos de tablas relacionales,
como las siguientes:
dni
nombre
apellidos
edad
4523345
Juan
García
46
1234223
Ana
Pérez
37
dni
4523345
3232535
salario
15000
26000
fechaContrato
11-12-2005
09-10-2005
La consulta anterior devolvería el salario del usuario con dni 4523345 ya
que es la única coincidencia en el campo dni entre la tabla 1 y la tabla 2.
Para más información sobre sintaxis SQL consultar el capítulo 13 del
manual de MySQL