PHP XML Parser

PHP es un popular lenguaje de scripting para el desarrollo web que permite a los desarrolladores crear sitios web dinámicos integrando código dentro de HTML. Una de sus funciones más útiles es la capacidad de trabajar con XML, un lenguaje de marcado diseñado para almacenar y transportar datos.

En esta guía cubriremos la funcionalidad XML de PHP, incluyendo sus ventajas, sintaxis y ejemplos de uso. Al finalizar, comprenderás cómo trabajar con XML para construir mejores sitios web y aplicaciones.

¿Qué es XML?

XML significa "eXtensible Markup Language" (Lenguaje de Marcado Extensible). Es un lenguaje de marcado que permite a los desarrolladores definir sus propias etiquetas y estructuras de documento, lo que lo convierte en un lenguaje muy flexible y personalizable. XML se utiliza habitualmente para almacenar y transportar datos, como en servicios web, bases de datos y feeds RSS.

XML es similar a HTML, pero mientras que HTML define cómo se muestran las páginas web en un navegador, XML define la estructura y el contenido de los datos. Las etiquetas XML se usan para identificar elementos de datos y sus relaciones, facilitando la transferencia de datos entre distintos sistemas.

Ventajas de usar XML en PHP

Usar XML en PHP ofrece varias ventajas, entre ellas:

• Intercambio de datos: XML es un formato ideal para intercambiar datos entre distintos sistemas y plataformas. Al ser independiente de la plataforma, los datos pueden transferirse fácilmente entre sistemas sin importar el sistema operativo o el lenguaje de programación utilizado.
• Almacenamiento de datos: XML es una excelente forma de almacenar y organizar datos en un formato estructurado. Al usar XML para almacenar datos, los desarrolladores pueden acceder y manipular los datos fácilmente cuando sea necesario.
• Transformación de datos: XML puede transformarse fácilmente en otros formatos, como HTML, PDF y CSV, usando XSLT (Extensible Stylesheet Language Transformations).

Sintaxis de XML en PHP

Para trabajar con XML en PHP, deberás familiarizarte con la sintaxis utilizada para definir documentos XML. Los documentos XML se componen de elementos, atributos y valores.

Los elementos se definen mediante etiquetas de apertura y cierre, como <book> y </book>. Los elementos también pueden contener elementos hijos, como:

<book>
  <title>The Great Gatsby</title>
  <author>F. Scott Fitzgerald</author>
</book>

Los atributos se usan para proporcionar información adicional sobre los elementos, por ejemplo:

<book id="1234">
  <title>The Great Gatsby</title>
  <author>F. Scott Fitzgerald</author>
</book>

Los valores son el contenido de un elemento, como "The Great Gatsby" o "F. Scott Fitzgerald."

¿Qué enfoque XML deberías usar?

PHP incluye tres analizadores, y elegir el correcto es importante:

• SimpleXML — la API más sencilla. Convierte un documento XML en un árbol de objetos que se navega con la sintaxis de propiedades normal ($xml->book->title). Ideal para documentos pequeños y medianos con una estructura conocida. Esta guía se centra en SimpleXML; consulta PHP SimpleXML para una referencia más profunda.
• DOMDocument (la extensión DOM) — una implementación completa del DOM del W3C. Más verbosa, pero permite crear, mover y eliminar nodos con precisión, y es necesaria para XSLT y validación. Consulta PHP XML DOM.
• XMLReader / XMLWriter — un analizador en streaming basado en pull. Lee un nodo a la vez en lugar de cargar todo el árbol en memoria, por lo que es la opción adecuada para archivos muy grandes (cientos de MB) donde SimpleXML y DOM agotarían la memoria.

Las funciones SAX históricas de xml_parser_create() aún existen, pero rara vez se usan en código nuevo; SimpleXML cubre el mismo terreno con mucho menos código repetitivo.

Leer un documento XML con SimpleXML

Para cargar un archivo XML en un árbol de objetos, usa la función simplexml_load_file(). Si el origen es una cadena (por ejemplo, una respuesta de API) en lugar de un archivo, usa simplexml_load_string() en su lugar.

Comprueba siempre el valor de retorno: ante un documento mal formado, ambas funciones devuelven false en lugar de lanzar una excepción, por lo que un resultado sin comprobar es una fuente común de errores silenciosos.

$xml = simplexml_load_file("books.xml");
if ($xml === false) {
    echo "Failed to load XML file.";
    exit;
}

Esto lee el archivo XML y lo convierte en un objeto SimpleXMLElement, al que accedes con la sintaxis orientada a objetos de PHP. Los elementos hijos se convierten en propiedades, y los elementos repetidos (como múltiples etiquetas <book>) se comportan como una lista iterable.

Leer atributos

Los atributos no son propiedades — se leen con sintaxis de array en el elemento. Dado <book id="1234">, el id es $book['id']:

$xml = simplexml_load_string('<book id="1234"><title>The Great Gatsby</title></book>');
echo $xml['id'];     // 1234
echo $xml->title;    // The Great Gatsby

Ten en cuenta que los valores de SimpleXML son objetos, no cadenas simples. Haz un cast con (string) cuando necesites una cadena real (por ejemplo, antes de una comparación estricta o json_encode).

Escribir un documento XML con SimpleXML

Para construir XML desde cero, crea un SimpleXMLElement con un elemento raíz y añade hijos con addChild():

$xml = new SimpleXMLElement('<books></books>');
$book = $xml->addChild('book');
$book->addChild('title', 'The Great Gatsby');
$book->addChild('author', 'F. Scott Fitzgerald');
$xml->asXML('books.xml');

Esto crea un SimpleXMLElement con el elemento raíz <books>, añade un hijo <book> con hijos <title> y <author>, y guarda el documento en books.xml. Llamar a asXML() sin argumento devuelve el XML como cadena en lugar de escribir un archivo, lo cual es útil cuando necesitas enviarlo en una respuesta HTTP.

Ejemplos de uso

Veamos algunos ejemplos prácticos del uso de XML en PHP.

Leer datos XML

Supón que tienes un archivo XML llamado "books.xml" con los siguientes datos:

<books>
  <book>
    <title>The Great Gatsby</title>
    <author>F. Scott Fitzgerald</author>
  </book>
  <book>
    <title>To Kill a Mockingbird</title>
    <author>Harper Lee</author>
  </book>
</books>

Para leer estos datos en PHP, puedes usar la función simplexml_load_file(), de esta forma:

$xml = simplexml_load_file("books.xml");
if ($xml === false) {
    echo "Failed to load XML file.";
    exit;
}
foreach ($xml->book as $book) {
  echo $book->title . " by " . $book->author . "\n";
}

Este código carga el archivo XML en un objeto SimpleXMLElement y luego itera sobre cada elemento <book> usando un bucle foreach. Dentro del bucle, accede a los elementos hijos <title> y <author> con sintaxis orientada a objetos y los imprime en la consola.

Escribir datos XML

Supón que quieres crear un nuevo archivo XML con los siguientes datos:

<colors>
  <color>
    <name>Red</name>
    <hex>#FF0000</hex>
  </color>
  <color>
    <name>Green</name>
    <hex>#00FF00</hex>
  </color>
  <color>
    <name>Blue</name>
    <hex>#0000FF</hex>
  </color>
</colors>

Para crear estos datos XML en PHP, puedes usar la clase SimpleXMLElement, de esta forma:

$xml = new SimpleXMLElement('<colors></colors>');
$red = $xml->addChild('color');
$red->addChild('name', 'Red');
$red->addChild('hex', '#FF0000');
$green = $xml->addChild('color');
$green->addChild('name', 'Green');
$green->addChild('hex', '#00FF00');
$blue = $xml->addChild('color');
$blue->addChild('name', 'Blue');
$blue->addChild('hex', '#0000FF');
$xml->asXML('colors.xml');

Este código crea un nuevo objeto SimpleXMLElement con el elemento raíz <colors>. Luego añade tres elementos hijos <color>, cada uno con dos elementos hijos <name> y <hex>, y establece sus valores correspondientes. Finalmente, guarda el documento XML en un archivo llamado "colors.xml."

Problemas comunes

• Resultado de carga sin comprobar. simplexml_load_file() y simplexml_load_string() devuelven false, no null, ante un error de análisis. Comprueba con === false antes de usar el resultado.
• Los valores son objetos, no cadenas. $xml->title es un SimpleXMLElement. Funciona en contextos de cadena (echo, concatenación) pero falla en comparaciones inesperadas; haz un cast con (string) cuando tengas dudas.
• Errores de análisis suprimidos. Para inspeccionar por qué falló el análisis, llama a libxml_use_internal_errors(true) antes de cargar y luego lee libxml_get_errors().
• Espacios de nombres. Si tu XML usa espacios de nombres (por ejemplo, xmlns:), el acceso a propiedades simples no encontrará los elementos — usa children() o xpath() con el espacio de nombres registrado.
• Entrada no confiable. No analices XML de fuentes no confiables sin precaución: los ataques de entidades externas (XXE) son un riesgo real. En PHP moderno la carga de entidades relevante está desactivada por defecto, pero verifica antes de procesar XML proporcionado por el usuario.

Temas relacionados

• PHP SimpleXML — referencia completa de la extensión SimpleXML.
• simplexml_load_file() y simplexml_load_string() — las dos funciones de carga en detalle.
• PHP XML DOM — la API DOMDocument más potente.
• PHP JSON — la alternativa más ligera para el intercambio de datos.

Conclusión

En esta guía hemos cubierto qué es XML, por qué es útil y cómo leer, escribir y manipular XML en PHP con la biblioteca SimpleXML, además de los errores comunes que hay que vigilar. SimpleXML es la forma más rápida de manejar datos XML estructurados en PHP; recurre a DOMDocument cuando necesites control preciso de nodos y a XMLReader para archivos muy grandes. Ten en cuenta que las funciones XML de PHP requieren la extensión libxml, que está habilitada por defecto en la mayoría de las instalaciones estándar.

Práctica