Para qué sirven los analizadores XML y cómo pueden resultar útiles. Analizando XML con SimpleXML Php analizando XML

El otro día comencé a reelaborar mi sistema de informes internos de la empresa, sobre la estructura general de la que escribí no hace tanto tiempo. Sin doblar mi corazón, diré que crecí por encima de mí en términos de PHP y, como resultado, me di cuenta de que el algoritmo del sistema está lo suficientemente torcido como para poder reescribirlo.

Antes de esto, el documento XML se analizó utilizando funciones tomadas de PHP 4. Sin embargo, PHP5 le dio al mundo una cosa muy útil llamada SimpleXML. Hoy se discutirá cómo trabajar con él.

Vale la pena comenzar con el hecho de que SimpleXML es un complemento separado y, por lo tanto, debe conectarse con anticipación al servidor que se está utilizando.

¡Ahora podemos trabajar!

Para procesar el documento, usamos la función simplexml_load_file (). Como parámetro, se pasa la dirección del archivo en el formato eXtended Markup Language (XML - su K.O.).

La belleza de esta función es que puede transferirle fácilmente un archivo desde cualquier servidor. Por lo tanto, tenemos la capacidad de procesar cargas xml externas (por ejemplo, Yandex-XML o feeds RSS de terceros).

La función genera una matriz en la salida. El error que encontré es que XML puede tener una estructura torpe y, por lo tanto, le aconsejo que comience con un rastro figurativo y muestre la matriz para comprender cómo lo manejó la función. Después de eso, puede comenzar a procesar los datos recibidos.

Por ejemplo, tomaré una construcción simple de aquí:

>
>
> PHP: Introducción al analizador >
>
>
> Milisegundo. Descifrador >
> Onlivia Actora >
>
>
> Señor. Descifrador >
> El ActÓ r >
>
> > Señor. Analizador > > John Doe > > >
>
Entonces es un idioma. Sigue siendo un lenguaje de programación. O
¿es un lenguaje de secuencias de comandos? Todo se revela en este documental
como una película de terror.
>
>
> PHP resuelve todas mis tareas web >
>
7>
5>
PG > >
>

Sea el archivo export.xml, que se encuentra justo en la raíz de mi servidor, junto con el script que lo procesa.
La matriz se construye de acuerdo con la estructura de los elementos DOM en el documento XML. El procesamiento comienza desde la raíz. Para obtener el nombre de Ms. Codificador, tenemos que construir la siguiente ruta: $ xml-> películas-> película-> personajes-> personaje-> nombre.
Tenga en cuenta que estamos eligiendo un valor específico. Aquí es donde se toma este tipo de carácter, ¡no olvide que estamos trabajando con una matriz!

Al igual que con cualquier matriz, nuestros datos se pueden procesar mediante un bucle foreach. El código será así:

$ xml = simplexml_load_file ("export.xml"); // subió el archivo
$ ttl = $ xml -> películas -> película -> título; // obtuve el título. es uno, por lo que no es necesario poner ningún otro valor

foreach ($ xml -> películas -> película -> personajes como $ crc) // y ahora trabajemos en dinámica
{
// muestra los nombres de los héroes
$ nombre = $ crc -> caracter -> nombre;
eco (" $ nombre
" ) ;
}

Este código pondrá el texto "PHP: Parser Appearance" en la variable $ ttl, y luego mostrará los nombres de los héroes línea por línea.
Milisegundo. Codificador, Sr. Codificador, Sr. Analizador.

He visto muchos analizadores xml, pero no he abordado la programación web. Ahora quiero averiguar y aprender contigo cómo hacer un analizador xml simple en php.

¿Para qué? ¡Necesario!

No, bueno, en realidad: los archivos xml son algo muy útil. Y cualquier profesional debería ... no, no debería, pero debería saber trabajar con ellos. ¿Queremos convertirnos en profesionales? Si estás en mi blog, entonces tienes ese deseo.

Asumiremos que sabemos qué es XML y no lo describiremos aquí. Bueno, si no lo sabemos, podemos averiguarlo fácilmente aquí: http://ru.wikipedia.org/wiki/XML

Mientras buscaba formas de analizar XML en PHP, descubrí un conjunto simple de funciones en PHP para trabajar con archivos XML llamado "Funciones de analizador XML". El análisis comienza con la inicialización del analizador llamando a la función xml_parser_create:

$ analizador_xml = analizador_xml_create ();

Luego necesitamos decirle al analizador qué funciones procesarán las etiquetas xml con las que se encuentra y información de texto en el proceso de análisis. Aquellos. necesitas instalar algunos controladores:

xml_set_element_handler ($ analizador_xml, "startElement", "endElement");

Esta función es responsable de establecer el inicio del elemento y el final de los manejadores del elemento. Por ejemplo, si se encuentra una combinación en el texto de un archivo xml, la función startElement se activará cuando el analizador encuentre el elemento y la función endElement cuando lo encuentre.

Las funciones startElement y endElement en sí toman varios parámetros de acuerdo con la documentación de php:

Pero, ¿cómo se leen los datos de un archivo? ¡Todavía no hemos visto un solo parámetro para esto en ninguna de las funciones! Y más sobre eso más adelante: leer el archivo es responsabilidad del programador, es decir, tenemos que usar funciones estándar para trabajar con archivos:

Abrió el archivo. Y ahora necesita leerlo línea por línea y alimentar las líneas leídas a la función xml_parse:

Error XML: ".xml_error_string (xml_get_error_code ($ xml_parser)); echo" en la línea ".xml_get_current_line_number ($ xml_parser); break;))?>

Hay dos cosas muy importantes a tener en cuenta aquí. La primera es que la función xml_parse en el tercer parámetro necesita pasar la bandera de lectura de la última línea (verdadero - si la línea es la última, falso - si no). La segunda es que, como en cualquier negocio, debemos estar atentos a los errores aquí. Las funciones xml_get_error_code y xml_error_string son responsables de esto. La primera función recibe el código de error y la segunda, basada en el código recibido, devuelve una descripción textual del error. Lo que sucederá como resultado del error, lo consideraremos más adelante. No menos función útil xml_get_current_line_number nos dirá el número de la línea procesada actualmente en el archivo.

Y como siempre, debemos liberar los recursos que ocupa el sistema. Para analizar XML, esta es la función xml_parser_free:

analizador_xml_free ($ analizador_xml);

Aquí, hemos cubierto las funciones principales. Es hora de verlos en práctica. Para esto, se me ocurrió un archivo xml con una estructura muy simple:

Llamemos a este archivo data.xml e intentemos analizarlo usando el siguiente código:

Elemento: $ nombre
"; // nombre del elemento $ profundidad ++; // aumenta la profundidad para que el navegador muestre sangrías foreach ($ atributos como $ atributo => $ valor) (echo str_repeat (" ", $ profundidad * 3); // sangrías // muestra el atributo de nombre y su valor echo "Atributo:". $ attr. "=". $ valor. "
";)) function endElement ($ analizador, $ nombre) (global $ profundidad; $ profundidad--; // disminuir la profundidad) $ profundidad = 0; $ archivo =" data.xml "; $ xml_parser = xml_parser_create (); xml_set_element_handler ($ xml_parser, "startElement", "endElement"); if (! ($ fp = fopen ($ file, "r"))) (die ("no se pudo abrir la entrada XML");) while ($ data = fgets ($ fp)) (if (! xml_parse ($ xml_parser, $ datos, feof ($ fp))) (echo "
Error XML: "; echo xml_error_string (xml_get_error_code ($ xml_parser)); echo" en la línea ".xml_get_current_line_number ($ xml_parser); break;)) xml_parser_free ($ xml_parser);?>

Como resultado del script más simple que desarrollamos, el navegador mostró la siguiente información en su ventana:

Elemento: RAÍZ
Elemento: INFO
Atributo: QUIÉN = mío
Elemento: DIRECCIÓN

Atributo: KVARTIRA = 12
Atributo: DOM = 15
Elemento: TELÉFONO

Intentemos estropear el archivo XML reemplazando la etiqueta Sobre y dejando la etiqueta de cierre igual:

Elemento: RAÍZ
Elemento: INFO
Atributo: QUIÉN = mío
Elemento: DIRECCIÓN
Atributo: ULICA = mi calle !!
Atributo: KVARTIRA = 12
Atributo: DOM = 15
Elemento: TELÉFONO

Error XML: etiqueta no coincidente en la línea 5

¡Guau! ¡Los mensajes de error están funcionando! Además, son bastante informativos.

Eh, olvidé una cosa más ... No mostramos el texto contenido dentro de las etiquetas de dirección y teléfono. Solucionamos nuestra deficiencia: agregamos un controlador de texto usando la función xml_set_character_data_handler:

xml_set_character_data_handler ($ analizador_xml, 'stringElement');

Y agregue la función de controlador en sí misma al código.

Analizador XML es un programa que se extrae de archivo fuente xml y guárdelos o utilícelos para acciones posteriores.

¿Por qué se necesitan analizadores xml?

Principalmente porque el formato xml en sí es popular entre los estándares informáticos. El archivo XML tiene este aspecto:

aquellos. de hecho, hay etiquetas, hay algunas reglas para las cuales las etiquetas deben seguirse entre sí.

La razón de la popularidad de los archivos xml es que son altamente legibles por humanos. Y el hecho de que es relativamente fácil de manejar en programas.

Contras de los archivos xml.

La desventaja es, en primer lugar, una gran cantidad de espacio en disco que ocupan estos datos. Debido al hecho de que las etiquetas, que se repiten constantemente, con grandes cantidades de datos, ocupan una cantidad relativamente grande de megabytes, que solo necesitan descargarse de la fuente y luego procesarse. ¿Existen alternativas? Existen, por supuesto, pero de todos modos, los analizadores xml y xml son hoy uno de los formatos más simples, confiables y tecnológicamente populares.

¿Cómo se escriben los analizadores XML?

Los analizadores están escritos en lenguajes de programación. Como dicen, están escritos en todos, pero no en algunos más. Debe entenderse que existen lenguajes de programación que ya tienen bibliotecas integradas para analizar archivos xml. Pero en cualquier caso, incluso si no hay biblioteca, siempre puede encontrar una biblioteca adecuada para este caso y usarla para extraer datos de un archivo.

A nivel mundial, existen 2 enfoques diferentes sobre cómo analizar archivos xml.

La primera es cargar el archivo xml completamente en la memoria y luego realizar manipulaciones de extracción de datos.

La segunda es la opción de transmisión. En este caso, el lenguaje de programación define ciertas etiquetas a las que deben responder las funciones del analizador xml generado, y el programador mismo decide qué se debe hacer si se encuentra una etiqueta en particular.

La ventaja del primer enfoque es la velocidad. Inmediatamente cargué todo en el archivo, luego revisé rápidamente mi memoria y encontré lo que se necesitaba y, lo que es más importante, la programación fue fácil. pero hay un signo menos y muy importante: es

se requiere una gran cantidad de memoria para operar. A veces, incluso diría que sucede a menudo que es simplemente imposible procesar y analizar el archivo xml, es decir, cree un analizador xml para que funcione correctamente de la primera forma. ¿Porqué es eso? Bueno, por ejemplo, la limitación para aplicaciones de 32 bits en Windows permite que el programa ocupe un máximo de 2 gigabytes de memoria, no más.

Sin embargo, es difícil programar usando la opción de transmisión. La complejidad con una extracción suficientemente seria crece significativamente, lo que en consecuencia afecta el tiempo y el presupuesto.

La validez de los analizadores y archivos xml.

Todo estaría bien con archivos xml y analizadores xml, pero hay un problema. Debido a que "cualquier alumno" puede crear un archivo xml, pero en realidad lo es (debido a que los escolares escriben mucho código, aparecen archivos inválidos, es decir, incorrectos. ¿Qué significa esto y cuál es el riesgo? ?, esto es que a veces es simplemente imposible analizar correctamente un archivo no válido. Por ejemplo, sus etiquetas no están cerradas como cabría esperar por el estándar, o por ejemplo, la codificación está configurada incorrectamente. Otro problema es que si, por ejemplo , estás haciendo un analizador en .net, luego puedes crear los llamados envoltorios, y lo más molesto sucede cuando haces un envoltorio de este tipo, y luego lees un archivo que creó el "estudiante", pero el archivo es inválido y es imposible leerlo. = porque muchas personas crean archivos xml sin usar bibliotecas estándar y con total aversión a todos los estándares de archivos xml. Es difícil de explicar a los clientes. Están esperando el resultado: un analizador xml que convierte los datos del archivo original a un formato diferente.

Cómo crear analizadores xml (primera opción)

Existe un lenguaje para consultar datos XML como Xpath. Este idioma tiene dos ediciones, no profundizaremos en los detalles de cada versión. Una mejor comprensión de este lenguaje mostrará ejemplos de cómo usarlo para recuperar datos. Por ejemplo.

// div [@ class = "supcat guru"] / a

qué está haciendo esta solicitud. Toma todas las etiquetas que tienen un rango que contiene el texto catalog.xml? Hid = y esta etiqueta debe ser un div hijo con una clase igual a supcat guru.

Sí, por primera vez puede que no sea lo suficientemente claro, pero, sin embargo, puede resolverlo si lo desea. El punto de partida para mí es http://en.wikipedia.org/wiki/XPath y les aconsejo.

En este artículo, le mostraré un ejemplo de cómo analizar un archivo XML grande. Si su servidor (alojamiento) no prohíbe un aumento en el tiempo de ejecución del script, entonces puede analizar un archivo XML que pesa al menos gigabytes, él personalmente analizó solo archivos de ozono que pesaban 450 megabytes.

Hay dos problemas al analizar archivos XML grandes:
1. No hay suficiente memoria.
2. No hay suficiente tiempo asignado para que funcione el guión.

El segundo problema con el tiempo se puede solucionar si el servidor no lo prohíbe.
Pero el problema con la memoria es difícil de resolver, incluso si estamos hablando de su propio servidor, entonces no es muy fácil mover archivos de 500 megabytes y simplemente no es posible aumentar la memoria en el alojamiento y en VDS.

PHP tiene varias opciones de procesamiento XML integradas: SimpleXML, DOM, SAX.
Todas estas opciones se detallan en muchos artículos de ejemplo, pero todos los ejemplos demuestran cómo trabajar con un documento XML completo.

Aquí hay un ejemplo, obtenemos un objeto de Archivo XML

Ahora puedes procesar este objeto, PERO ...
Como puede ver, todo el archivo XML se lee en la memoria, luego todo se analiza en un objeto.
Es decir, todos los datos van a la memoria y, si la memoria asignada es pequeña, el script se detiene.

Para procesar archivos grandes esta opción no es adecuada, debe leer el archivo línea por línea y procesar estos datos a su vez.
En este caso, la verificación de validez se lleva a cabo de la misma manera que se procesan los datos, por lo que debe poder revertir, por ejemplo, eliminar todos los datos ingresados ​​en la base de datos en el caso de un archivo XML no válido, o haga dos pasadas por el archivo, primero lea para verificar su validez, luego lea para procesar los datos.

A continuación, se muestra un ejemplo teórico de cómo analizar un archivo XML de gran tamaño.
Este script lee un carácter a la vez del archivo, ensambla esos datos en bloques y los envía al analizador XML.
Este enfoque resuelve completamente el problema de la memoria y no causa estrés, pero agrava el problema con el tiempo. Cómo intentar resolver el problema con el tiempo, lea a continuación.

Función webi_xml ($ archivo)
{

########
Función ### para trabajar con datos

{
imprimir $ datos;
}
############################################

{
imprimir $ nombre;
print_r ($ atributos);
}

## función de etiqueta final
función endElement ($ analizador, $ nombre)
{
imprimir $ nombre;
}
############################################

($ xml_parser, "datos");

// abre el archivo
$ fp = fopen ($ archivo, "r");

$ perviy_vxod = 1; $ datos = "";

{

$ simvol = fgetc ($ fp); $ datos. = $ simvol;

if ($ simvol! = ">") (continuar;)

eco "

rotura;
}

$ datos = "";
}
fclose ($ fp);

Webi_xml ("1.xml");

?>

En este ejemplo, puse todo en una función webi_xml () y en la parte inferior puedes ver su llamada.
El script en sí consta de tres funciones principales:
1. La función que detecta la apertura de la etiqueta startElement ()
2. Una función que detecta el cierre de la etiqueta endElement ()
3. Y la función de recibir datos de datos ().

Supongamos que el contenido del archivo 1.xml es una receta

< title >Pan simple
< ingredient amount = "3" unit = "стакан" >Harina
< ingredient amount = "0.25" unit = "грамм" >Levadura
< ingredient amount = "1.5" unit = "стакан" >Agua tibia
< ingredient amount = "1" unit = "чайная ложка" >Sal
< instructions >
< step > Mezclar todos los ingredientes y amasar bien..
< step > Cubrir con un paño y dejar durante una hora en una habitación cálida..
< step > Amasar de nuevo, poner en una bandeja para hornear y meter al horno.
< step > Visite el sitio del sitio

Comenzamos todos llamando a la función común webi_xml ("1.xml");
Además, en esta función, el analizador se inicia y todos los nombres de las etiquetas se convierten a mayúsculas para que todas las etiquetas tengan el mismo caso.

$ analizador_xml = analizador_xml_create ();
xml_parser_set_option ($ xml_parser, XML_OPTION_CASE_FOLDING, verdadero);

Ahora indicamos qué funciones funcionarán para capturar la apertura de la etiqueta, cerrar y procesar los datos

xml_set_element_handler ($ analizador_xml, "startElement", "endElement");
xml_set_character_data_handler($ xml_parser, "datos");

Luego viene la apertura el archivo especificado, iterar sobre el archivo un carácter a la vez y agregar cada carácter a la variable de cadena hasta que se encuentre un carácter > .
Si este es el primer acceso al archivo, a lo largo del camino se eliminará todo lo que será superfluo al principio del archivo, todo lo que está antes , esta es la etiqueta con la que debería comenzar XML.
Por primera vez, la variable de cadena recopilará la cadena

Y enviarla al analizador
xml_parse ($ xml_parser, $ datos, feof ($ fp));
Después de procesar los datos, la variable de cadena se descarta y la recopilación de datos en la cadena comienza de nuevo y la cadena se forma por segunda vez.

En el tercero