simplexml_load_file - ¿Cómo se analiza y procesa HTML/XML en PHP?
simplexmlelement php ejemplo (29)
¿Cómo se puede analizar HTML / XML y extraer información de él?
Extensiones XML nativas
Prefiero usar una de las extensiones XML nativas ya que vienen con PHP, generalmente son más rápidas que todas las librerías de terceros y me dan todo el control que necesito sobre el marcado.
DOM
La extensión DOM le permite operar en documentos XML a través de la API DOM con PHP 5. Es una implementación del Document Object Model Core Level 3 del W3C, una interfaz de plataforma y lenguaje neutral que permite a los programas y scripts acceder y actualizar dinámicamente El contenido, estructura y estilo de los documentos.
DOM es capaz de analizar y modificar HTML del mundo real (roto) y puede hacer consultas XPath . Se basa en libxml .
Se necesita algo de tiempo para ser productivo con DOM, pero ese tiempo vale la pena IMO. Dado que DOM es una interfaz de lenguaje independiente, encontrará implementaciones en muchos lenguajes, por lo que si necesita cambiar su lenguaje de programación, es probable que ya sepa cómo usar la API DOM de ese idioma.
Un ejemplo de uso básico se puede encontrar en Agarrar el atributo href de un elemento A y se puede encontrar una visión general conceptual en DOMDocument en php
La forma de usar la extensión DOM se ha cubierto ampliamente en , por lo que si decide usarla, puede estar seguro de que la mayoría de los problemas con los que se encuentra pueden resolverse mediante la búsqueda / navegación de Desbordamiento de pila.
XMLReader
La extensión XMLReader es un analizador de extracción XML. El lector actúa como un cursor que avanza en la secuencia del documento y se detiene en cada nodo en el camino.
XMLReader, como DOM, se basa en libxml. No tengo conocimiento de cómo activar el Módulo de analizador de HTML, por lo que es probable que el uso de XMLReader para analizar el HTML dañado pueda ser menos robusto que el uso de DOM, donde puede indicarle explícitamente que use el Módulo de análisis de HTML de libxml.
Se puede encontrar un ejemplo de uso básico al obtener todos los valores de las etiquetas h1 usando php
Analizador de XML
Esta extensión le permite crear analizadores XML y luego definir controladores para diferentes eventos XML. Cada analizador XML también tiene algunos parámetros que puede ajustar.
La biblioteca del analizador XML también se basa en libxml e implementa un analizador de inserción XML de estilo SAX . Puede ser una mejor opción para la administración de memoria que DOM o SimpleXML, pero será más difícil trabajar con él que el analizador de extracción implementado por XMLReader.
SimpleXml
La extensión SimpleXML proporciona un conjunto de herramientas muy simple y fácil de usar para convertir XML en un objeto que se puede procesar con los selectores de propiedades normales y los iteradores de matriz.
SimpleXML es una opción cuando sabe que el HTML es XHTML válido. Si necesita analizar HTML roto, ni siquiera considere SimpleXml porque se ahogará.
Se puede encontrar un ejemplo de uso básico en Un programa simple para los valores de nodo y nodo CRUD del archivo xml y hay muchos ejemplos adicionales en el Manual de PHP .
Bibliotecas de terceros (basadas en libxml)
Si prefiere usar una biblioteca de terceros, sugeriría usar una biblioteca que realmente use DOM / libxml debajo en lugar del análisis de cadenas.
FluentDom - Repo
FluentDOM proporciona una interfaz XML fluida similar a jQuery para el DOMDocument en PHP. Los selectores están escritos en XPath o CSS (utilizando un convertidor de CSS a XPath). Las versiones actuales extienden el DOM implementando interfaces estándar y agregan características del DOM Living Standard. FluentDOM puede cargar formatos como JSON, CSV, JsonML, RabbitFish y otros. Puede ser instalado vía Composer.
HtmlPageDom
Wa72 / HtmlPageDom` es una biblioteca de PHP para la fácil manipulación de documentos HTML, ya que requiere DomCrawler de los componentes de Symfony2 para atravesar el árbol DOM y lo amplía agregando métodos para manipular el árbol DOM de los documentos HTML.
phpQuery (no actualizado por años)
phpQuery es una API del Modelo de Objeto de Documento (DOM) basada en el selector CSS3 del lado del servidor, basada en la Biblioteca de JavaScript jQuery escrita en PHP5 y proporciona una Interfaz de línea de comandos (CLI) adicional.
También vea: https://github.com/electrolinux/phpquery
Zend_Dom
Zend_Dom proporciona herramientas para trabajar con documentos y estructuras DOM. Actualmente, ofrecemos Zend_Dom_Query, que proporciona una interfaz unificada para consultar documentos DOM que utilizan los selectores XPath y CSS.
QueryPath
QueryPath es una biblioteca de PHP para manipular XML y HTML. Está diseñado para funcionar no solo con archivos locales, sino también con servicios web y recursos de base de datos. Implementa gran parte de la interfaz jQuery (incluidos los selectores de estilo CSS), pero está muy adaptado para el uso del lado del servidor. Puede ser instalado vía Composer.
fDOMDocument
fDOMDocument extiende el DOM estándar para utilizar excepciones en todas las ocasiones de errores en lugar de avisos o avisos de PHP. También agregan varios métodos personalizados y accesos directos para mayor comodidad y para simplificar el uso de DOM.
sabre/xml
sabre / xml es una biblioteca que envuelve y extiende las clases XMLReader y XMLWriter para crear un sistema de mapeo y un patrón de diseño "xml a objeto / matriz" simple. Escribir y leer XML es de una sola pasada y, por lo tanto, puede ser rápido y requerir poca memoria en archivos xml grandes.
FluidXML
FluidXML es una biblioteca de PHP para manipular XML con una API concisa y fluida. Aprovecha XPath y el patrón de programación fluido para ser divertido y efectivo.
Terceros (no basados en libxml)
El beneficio de construir sobre DOM / libxml es que obtienes un buen rendimiento de la caja porque estás basado en una extensión nativa. Sin embargo, no todas las librerías de terceros bajan por esta ruta. Algunos de ellos enumerados a continuación
PHP Simple HTML DOM Parser
- ¡Un analizador HTML DOM escrito en PHP5 + te permite manipular HTML de una manera muy fácil!
- Requiere PHP 5+.
- Soporta HTML inválido.
- Encuentre etiquetas en una página HTML con selectores como jQuery.
- Extraer contenidos de HTML en una sola línea.
Generalmente no recomiendo este analizador. La base de código es horrible y el analizador en sí es bastante lento y tiene hambre de memoria. No todos los selectores jQuery (como los selectores de niños ) son posibles. Cualquiera de las bibliotecas basadas en libxml debería superar este rendimiento fácilmente.
PHP HTML Analizador
PHPHtmlParser es un analizador html simple y flexible que le permite seleccionar etiquetas usando cualquier selector css, como jQuery. El objetivo es ayudar en el desarrollo de herramientas que requieren una forma rápida y fácil de desechar HTML, ya sea válido o no. Este proyecto fue respaldado originalmente por sunra / php-simple-html-dom-parser pero el soporte parece haberse detenido, por lo que este proyecto es mi adaptación de su trabajo anterior.
De nuevo, no recomendaría este analizador. Es bastante lento con un alto uso de CPU. Tampoco hay una función para borrar la memoria de los objetos DOM creados. Estos problemas se escalan particularmente con los bucles anidados. La documentación en sí misma es inexacta y está mal escrita, sin respuestas a arreglos desde el 14 de abril del 16.
Ganon
- Un tokenizador universal y HTML / XML / RSS DOM Parser
- Capacidad para manipular elementos y sus atributos.
- Soporta HTML inválido y UTF8
- Puede realizar consultas avanzadas de tipo CSS3 en elementos (como jQuery - espacios de nombres compatibles)
- Un embellecedor de HTML (como HTML Tidy)
- Reducir CSS y Javascript
- Ordenar atributos, cambiar caso de carácter, sangría correcta, etc.
- Extensible
- Análisis de documentos utilizando devoluciones de llamada en función del carácter / token actual
- Operaciones separadas en funciones más pequeñas para una fácil anulación
- Rapido y facil
Nunca lo usé. No puedo decir si es bueno.
HTML 5
Puede usar lo anterior para analizar HTML5, pero puede haber peculiaridades debido a que el marcado HTML5 lo permite. Por lo tanto, para HTML5, debe considerar el uso de un analizador dedicado, como
Implementaciones de Python y PHP de un analizador HTML basado en la especificación de WHATWG HTML5 para la máxima compatibilidad con los principales navegadores web de escritorio.
Podríamos ver más analizadores dedicados una vez que HTML5 esté finalizado. También hay un blogpost por el W3 titulado How-To para el análisis de html 5 que vale la pena revisar.
Servicios web
Si no tiene ganas de programar PHP, también puede usar servicios web. En general, encontré muy poca utilidad para estos, pero eso es solo yo y mis casos de uso.
YQL
El servicio web de YQL permite a las aplicaciones consultar, filtrar y combinar datos de diferentes fuentes a través de Internet. Las declaraciones YQL tienen una sintaxis similar a SQL, familiar para cualquier desarrollador con experiencia en bases de datos.
ScraperWiki .
La interfaz externa de ScraperWiki le permite extraer datos en la forma que desee para usar en la web o en sus propias aplicaciones. También puede extraer información sobre el estado de cualquier raspador.
Expresiones regulares
Por último y menos recomendado , puede extraer datos de HTML con expresiones regulares . En general se desaconseja el uso de expresiones regulares en HTML.
La mayoría de los fragmentos que encontrará en la web para hacer coincidir el marcado son frágiles. En la mayoría de los casos, solo están trabajando para una pieza muy particular de HTML. Los pequeños cambios en el marcado, como agregar espacios en blanco en algún lugar, o agregar o cambiar atributos en una etiqueta, pueden hacer que el RegEx falle cuando no está escrito correctamente. Debe saber lo que está haciendo antes de usar RegEx en HTML.
Los analizadores de HTML ya conocen las reglas sintácticas de HTML. Las expresiones regulares se deben enseñar para cada nuevo RegEx que escriba. RegEx está bien en algunos casos, pero realmente depende de su caso de uso.
Puede escribir analizadores más confiables , pero escribir un analizador personalizado completo y confiable con expresiones regulares es una pérdida de tiempo cuando las bibliotecas mencionadas ya existen y hacen un trabajo mucho mejor en esto.
También vea Parsing Html The Cthulhu Way
Libros
Si quieres gastar algo de dinero, echa un vistazo a
No estoy afiliado a PHP Architect ni a los autores.
Con FluidXML puede consultar e iterar XML utilizando los selectores XPath y CSS .
$doc = fluidxml(''<html>...</html>'');
$title = $doc->query(''//head/title'')[0]->nodeValue;
$doc->query(''//body/p'', ''div.active'', ''#bgId'')
->each(function($i, $node) {
// $node is a DOMNode.
$tag = $node->nodeName;
$text = $node->nodeValue;
$class = $node->getAttribute(''class'');
});
Esto se conoce comúnmente como raspado de pantalla , por cierto. La biblioteca que he usado para esto es Simple HTML Dom Parser .
Esto suena como una buena descripción de la tarea de la tecnología W3C XPath . Es fácil expresar consultas como "devolver todos los atributos href en etiquetas img que están anidadas en <foo><bar><baz> elements ". Al no ser un buff de PHP, no puedo decirte de qué forma XPath puede estar disponible. Si puede llamar a un programa externo para procesar el archivo HTML, debería poder usar una versión de línea de comandos de XPath. Para una introducción rápida, vea XPath .
HTML simple es un gran analizador de código abierto:
Trata los elementos DOM de una manera orientada a objetos, y la nueva iteración tiene mucha cobertura para el código no compatible. También hay algunas funciones geniales como las que verías en JavaScript, como la función "buscar", que devolverá todas las instancias de los elementos de ese nombre de etiqueta.
He usado esto en varias herramientas, probándolo en diferentes tipos de páginas web, y creo que funciona muy bien.
Hay muchas formas de procesar HTML / XML DOM de las cuales la mayoría ya se ha mencionado. Por lo tanto, no haré ningún intento de enumerarlos.
Simplemente quiero agregar que personalmente prefiero usar la extensión DOM y por qué:
- iit hace un uso óptimo de la ventaja de rendimiento del código C subyacente
- Es OO PHP (y me permite subclasificarlo)
- es un nivel bastante bajo (lo que me permite usarlo como una base no hinchada para un comportamiento más avanzado)
- proporciona acceso a cada parte del DOM (a diferencia de, por ejemplo, SimpleXml, que ignora algunas de las características XML menos conocidas)
- tiene una sintaxis utilizada para el rastreo de DOM que es similar a la sintaxis utilizada en JavaScript nativo.
Y aunque echo de menos la capacidad de usar los selectores de CSS para DOMDocument , hay una manera bastante simple y conveniente de agregar esta característica: subclasificar el DOMDocument y agregar los métodos querySelectorAll y querySelector a su subclase.
Para analizar los selectores, recomiendo usar el componente CssSelector muy minimalista del marco de Symfony . Este componente simplemente traduce los selectores de CSS a los selectores de XPath, que luego pueden introducirse en un DOMXpath para recuperar la lista de Nodel correspondiente.
Luego puede usar esta subclase (aún de muy bajo nivel) como base para más clases de alto nivel, pensadas para, por ejemplo, analice tipos muy específicos de XML o agregue más comportamiento similar a jQuery.
El siguiente código sale directamente de mi PHPPowertools/DOM-Query y usa la técnica que describí.
Para el análisis de HTML:
namespace PowerTools;
use /Symfony/Component/CssSelector/CssSelector as CssSelector;
class DOM_Document extends /DOMDocument {
public function __construct($data = false, $doctype = ''html'', $encoding = ''UTF-8'', $version = ''1.0'') {
parent::__construct($version, $encoding);
if ($doctype && $doctype === ''html'') {
@$this->loadHTML($data);
} else {
@$this->loadXML($data);
}
}
public function querySelectorAll($selector, $contextnode = null) {
if (isset($this->doctype->name) && $this->doctype->name == ''html'') {
CssSelector::enableHtmlExtension();
} else {
CssSelector::disableHtmlExtension();
}
$xpath = new /DOMXpath($this);
return $xpath->query(CssSelector::toXPath($selector, ''descendant::''), $contextnode);
}
[...]
public function loadHTMLFile($filename, $options = 0) {
$this->loadHTML(file_get_contents($filename), $options);
}
public function loadHTML($source, $options = 0) {
if ($source && $source != '''') {
$data = trim($source);
$html5 = new HTML5(array(''targetDocument'' => $this, ''disableHtmlNsInDom'' => true));
$data_start = mb_substr($data, 0, 10);
if (strpos($data_start, ''<!DOCTYPE '') === 0 || strpos($data_start, ''<html>'') === 0) {
$html5->loadHTML($data);
} else {
@$this->loadHTML(''<!DOCTYPE html><html><head><meta charset="'' . $encoding . ''" /></head><body></body></html>'');
$t = $html5->loadHTMLFragment($data);
$docbody = $this->getElementsByTagName(''body'')->item(0);
while ($t->hasChildNodes()) {
$docbody->appendChild($t->firstChild);
}
}
}
}
[...]
}
Consulte también Análisis de documentos XML con selectores de CSS del creador de Symfony, Fabien Potencier, sobre su decisión de crear el componente CssSelector para Symfony y cómo usarlo.
Hay varias razones para no analizar HTML mediante expresiones regulares. Pero, si tiene control total sobre qué HTML se generará, entonces puede hacerlo con una expresión regular simple.
Encima se encuentra una función que analiza HTML mediante expresiones regulares. Tenga en cuenta que esta función es muy sensible y exige que el HTML obedezca ciertas reglas, pero funciona muy bien en muchos escenarios. Si desea un analizador simple y no desea instalar bibliotecas, pruebe esto:
function array_combine_($keys, $values) {
$result = array();
foreach ($keys as $i => $k) {
$result[$k][] = $values[$i];
}
array_walk($result, create_function(''&$v'', ''$v = (count($v) == 1)? array_pop($v): $v;''));
return $result;
}
function extract_data($str) {
return (is_array($str))
? array_map(''extract_data'', $str)
: ((!preg_match_all(''#<([A-Za-z0-9_]*)[^>]*>(.*?)<//1>#s'', $str, $matches))
? $str
: array_map((''extract_data''), array_combine_($matches[1], $matches[2])));
}
print_r(extract_data(file_get_contents("http://www.google.com/")));
He creado una biblioteca llamada HTML5DOMDocument que está disponible gratuitamente en https://github.com/ivopetkov/html5-dom-document-php
También es compatible con los selectores de consultas que creo que serán extremadamente útiles en su caso. Aquí hay un código de ejemplo:
$dom = new IvoPetkov/HTML5DOMDocument();
$dom->loadHTML(''<!DOCTYPE html><html><body><h1>Hello</h1><div class="content">This is some text</div></body></html>'');
echo $dom->querySelector(''h1'')->innerHTML;
He escrito un analizador XML de propósito general que puede manejar fácilmente archivos GB. Está basado en XMLReader y es muy fácil de usar:
$source = new XmlExtractor("path/to/tag", "/path/to/file.xml");
foreach ($source as $tag) {
echo $tag->field1;
echo $tag->field2->subfield1;
}
Aquí está el repositorio XmlExtractor : XmlExtractor
Hemos creado bastantes rastreadores para nuestras necesidades antes. Al final del día, generalmente las expresiones regulares son las que mejor hacen la cosa. Si bien las bibliotecas enumeradas anteriormente son buenas por el motivo por el que se crearon, si sabe lo que está buscando, las expresiones regulares son una forma más segura de ir, ya que también puede manejar estructuras HTML / XHTML no válidas, que podrían fallar, si se cargan a través de la mayoría de los analizadores.
JSON y matriz de XML en tres líneas:
$xml = simplexml_load_string($xml_string);
$json = json_encode($xml);
$array = json_decode($json,TRUE);
Ta da!
Para 1a y 2: votaría por la nueva clase DOMCrawler ( DomCrawler ) de Symfony Componet. Esta clase permite consultas similares a los selectores de CSS. Eche un vistazo a esta presentación para ver ejemplos del mundo real: news-of-the-symfony2-world .
El componente está diseñado para funcionar de forma independiente y se puede usar sin Symfony.
El único inconveniente es que solo funcionará con PHP 5.3 o posterior.
Pruebe Simple HTML DOM Parser
- ¡Un analizador HTML DOM escrito en PHP 5+ que te permite manipular HTML de una manera muy fácil!
- Requiere PHP 5+.
- Soporta HTML inválido.
- Encuentre etiquetas en una página HTML con selectores como jQuery.
- Extraer contenidos de HTML en una sola línea.
- Download
Ejemplos:
Cómo obtener elementos HTML:
// Create DOM from URL or file
$html = file_get_html(''http://www.example.com/'');
// Find all images
foreach($html->find(''img'') as $element)
echo $element->src . ''<br>'';
// Find all links
foreach($html->find(''a'') as $element)
echo $element->href . ''<br>'';
Cómo modificar elementos HTML:
// Create DOM from string
$html = str_get_html(''<div id="hello">Hello</div><div id="world">World</div>'');
$html->find(''div'', 1)->class = ''bar'';
$html->find(''div[id=hello]'', 0)->innertext = ''foo'';
echo $html;
Extraer contenido de HTML:
// Dump contents (without tags) from HTML
echo file_get_html(''http://www.google.com/'')->plaintext;
Raspado Slashdot:
// Create DOM from URL
$html = file_get_html(''http://slashdot.org/'');
// Find all article blocks
foreach($html->find(''div.article'') as $article) {
$item[''title''] = $article->find(''div.title'', 0)->plaintext;
$item[''intro''] = $article->find(''div.intro'', 0)->plaintext;
$item[''details''] = $article->find(''div.details'', 0)->plaintext;
$articles[] = $item;
}
print_r($articles);
Puede intentar usar algo como HTML Tidy para limpiar cualquier HTML "roto" y convertir el HTML a XHTML, que luego puede analizar con un analizador XML.
Recomiendo PHP Simple HTML DOM Parser .
Realmente tiene buenas características, como:
foreach($html->find(''img'') as $element)
echo $element->src . ''<br>'';
Sí, puedes usar simple_html_dom para este propósito. Sin embargo, he trabajado bastante con simple_html_dom, especialmente para el desguace web y he encontrado que es demasiado vulnerable. Hace el trabajo básico pero no lo recomendaré de todos modos.
Nunca he usado el rizo para este propósito, pero lo que he aprendido es que el rizo puede hacer el trabajo de manera mucho más eficiente y mucho más sólido.
Por favor, echa un vistazo a este enlace: scraping-websites-with-curl
Si está familiarizado con jQuery selector, puede usar ScarletsQuery para PHP
<pre><?php
include "ScarletsQuery.php";
// Load the HTML content and parse it
$html = file_get_contents(''https://www.lipsum.com'');
$dom = Scarlets/Library/MarkupLanguage::parseText($html);
// Select meta tag on the HTML header
$description = $dom->selector(''head meta[name="description"]'')[0];
// Get ''content'' attribute value from meta tag
print_r($description->attr(''content''));
$description = $dom->selector(''#Content p'');
// Get element array
print_r($description->view);
Esta biblioteca suele tardar menos de 1 segundo en procesar html sin conexión.
También acepta HTML no válido o comillas faltantes en atributos de etiqueta.
Simplemente use DOMDocument->loadHTML() y DOMDocument->loadHTML() con él. El algoritmo de análisis de HTML de libxml es bastante bueno y rápido, y, contrariamente a la creencia popular, no se asfixia con el HTML mal formado.
Un enfoque general que no he visto mencionado aquí es ejecutar HTML a través de Tidy , que se puede configurar para escupir XHTML válido garantizado. Entonces puedes usar cualquier biblioteca XML vieja en él.
Pero para su problema específico, debe echar un vistazo a este proyecto: http://fivefilters.org/content-only/ : es una versión modificada del algoritmo de Readability , que está diseñada para extraer solo el contenido textual (no los encabezados). y pies de página) de una página.
phpQuery y QueryPath son extremadamente similares en la replicación de la API jQuery fluida. Por eso también son dos de los enfoques más fáciles para analizar correctamente HTML en PHP.
Ejemplos para QueryPath
Básicamente, primero creas un árbol DOM consultable desde una cadena HTML:
$qp = qp("<html><body><h1>title</h1>..."); // or give filename or URL
El objeto resultante contiene una representación de árbol completa del documento HTML. Se puede recorrer utilizando métodos DOM. Pero el enfoque común es usar selectores de CSS como en jQuery:
$qp->find("div.classname")->children()->...;
foreach ($qp->find("p img") as $img) {
print qp($img)->attr("src");
}
Principalmente desea utilizar los selectores de etiquetas #id y .class o DIV simples para ->find() . Pero también puedes usar sentencias XPath , que a veces son más rápidas. También los métodos típicos de jQuery como ->children() y ->text() y particularmente ->attr() simplifican la extracción de los fragmentos de código HTML correctos. (Y ya tienen sus entidades SGML descodificadas).
$qp->xpath("//div/p[1]"); // get first paragraph in a div
QueryPath también permite inyectar nuevas etiquetas en el flujo ( ->append ), y luego generar y precintar un documento actualizado ( ->writeHTML ). No solo puede analizar HTML con formato incorrecto, sino también varios dialectos XML (con espacios de nombres) e incluso extraer datos de microformatos HTML (XFN, vCard).
$qp->find("a[target=_blank]")->toggleClass("usability-blunder");
.
phpQuery o QueryPath?
En general, QueryPath es más adecuado para la manipulación de documentos. Mientras que phpQuery también implementa algunos métodos pseudo AJAX (solo solicitudes HTTP) para parecerse más a jQuery. Se dice que phpQuery suele ser más rápido que QueryPath (debido a que tiene menos características generales).
Para obtener más información sobre las diferencias, consulte esta comparación en la máquina wayback de tagbyte.org . (La fuente original desapareció, así que aquí hay un enlace a un archivo de Internet. Sí, todavía puedes localizar personas que faltan, personas).
Y aquí hay una introducción completa de QueryPath .
Ventajas
- Simplicidad y fiabilidad
- Alternativas fáciles de usar
->find("a img, a object, div a") - Datos correctos que no se escapan (en comparación con la expresión regular grepping)
XML_HTMLSax es bastante estable, incluso si ya no se mantiene. Otra opción podría ser canalizar el HTML a través de Html Tidy y luego analizarlo con herramientas XML estándar.
PHPPowertools/DOM-Query una biblioteca llamada PHPPowertools/DOM-Query , que le permite rastrear documentos HTML5 y XML como lo hace con jQuery.
Bajo el capó, usa Symfony / DomCrawler para la conversión de los selectores de CSS a los selectores de XPath . Siempre utiliza el mismo DomDocument, incluso cuando se pasa un objeto a otro, para garantizar un rendimiento decente.
Ejemplo de uso:
namespace PowerTools;
// Get file content
$htmlcode = file_get_contents(''https://github.com'');
// Define your DOMCrawler based on file string
$H = new DOM_Query($htmlcode);
// Define your DOMCrawler based on an existing DOM_Query instance
$H = new DOM_Query($H->select(''body''));
// Passing a string (CSS selector)
$s = $H->select(''div.foo'');
// Passing an element object (DOM Element)
$s = $H->select($documentBody);
// Passing a DOM Query object
$s = $H->select( $H->select(''p + p''));
// Select the body tag
$body = $H->select(''body'');
// Combine different classes as one selector to get all site blocks
$siteblocks = $body->select(''.site-header, .masthead, .site-body, .site-footer'');
// Nest your methods just like you would with jQuery
$siteblocks->select(''button'')->add(''span'')->addClass(''icon icon-printer'');
// Use a lambda function to set the text of all site blocks
$siteblocks->text(function( $i, $val) {
return $i . " - " . $val->attr(''class'');
});
// Append the following HTML to all site blocks
$siteblocks->append(''<div class="site-center"></div>'');
// Use a descendant selector to select the site''s footer
$sitefooter = $body->select(''.site-footer > .site-center'');
// Set some attributes for the site''s footer
$sitefooter->attr(array(''id'' => ''aweeesome'', ''data-val'' => ''see''));
// Use a lambda function to set the attributes of all site blocks
$siteblocks->attr(''data-val'', function( $i, $val) {
return $i . " - " . $val->attr(''class'') . " - photo by Kelly Clark";
});
// Select the parent of the site''s footer
$sitefooterparent = $sitefooter->parent();
// Remove the class of all i-tags within the site''s footer''s parent
$sitefooterparent->select(''i'')->removeAttr(''class'');
// Wrap the site''s footer within two nex selectors
$sitefooter->wrap(''<section><div class="footer-wrapper"></div></section>'');
[...]
Métodos soportados:
- [x] $ (1)
- [x] $.parseHTML
- [x] $.parseXML
- [x] $.parseJSON
- [x] $selection.add
- [x] $selection.addClass
- [x] $selection.after
- [x] $selection.append
- [x] $selection.attr
- [x] $selection.before
- [x] $selection.children
- [x] $selection.closest
- [x] $selection.contents
- [x] $selection.detach
- [x] $selection.each
- [x] $selection.eq
- [x] $selection.empty (2)
- [x] $selection.find
- [x] $selection.first
- [x] $selection.get
- [x] $selection.insertAfter
- [x] $selection.insertBefore
- [x] $selection.last
- [x] $selection.parent
- [x] $selection.parents
- [x] $selection.remove
- [x] $selection.removeAttr
- [x] $selection.removeClass
- [x] $selection.text
- [x] $selection.wrap
- Renombrado ''seleccionar'', por razones obvias
- Renombrado como ''vacío'', ya que ''vacío'' es una palabra reservada en PHP
NOTA :
La biblioteca también incluye su propio autocargador de configuración cero para bibliotecas compatibles con PSR-0. El ejemplo incluido debería funcionar fuera de la caja sin ninguna configuración adicional. Alternativamente, puedes usarlo con el compositor.
Advanced Html Dom es un simple reemplazo de HTML DOM que ofrece la misma interfaz, pero está basado en DOM, lo que significa que no se produce ninguno de los problemas de memoria asociados.
También tiene soporte completo para CSS, incluidas las extensiones jQuery .
QueryPath es bueno, pero tenga cuidado con el "estado de seguimiento" porque si no se dio cuenta de lo que significa, puede significar que perderá mucho tiempo de depuración tratando de averiguar qué sucedió y por qué el código no funciona.
Lo que significa es que cada llamada en el conjunto de resultados modifica el conjunto de resultados en el objeto, no se puede cambiar como en jquery donde cada enlace es un conjunto nuevo, tiene un solo conjunto que es el resultado de su consulta y cada función se modifica ese único conjunto.
Para obtener un comportamiento similar al de jquery, debe bifurcarse antes de realizar una operación de filtro / modificación, lo que significa que reflejará lo que sucede en jquery mucho más de cerca.
$results = qp("div p");
$forename = $results->find("input[name=''forename'']");
$results ahora contiene el conjunto de resultados para la input[name=''forename''] NO la consulta original "div p" esto me sorprendió mucho, lo que descubrí fue que QueryPath rastrea los filtros y las búsquedas y todo lo que modifica sus resultados y almacena ellos en el objeto tienes que hacer esto en su lugar
$forename = $results->branch()->find("input[name=''forname'']")
entonces $results no se modificarán y puede reutilizar el conjunto de resultados una y otra vez, tal vez alguien con mucho más conocimiento pueda aclararlo un poco, pero básicamente es así por lo que he encontrado.
¿Por qué no deberías y cuándo deberías usar expresiones regulares?
En primer lugar, un nombre inapropiado común: las expresiones regulares no son para " analizar " HTML. Sin embargo, las expresiones regulares pueden " extraer " datos. Extraer es para lo que están hechos. El principal inconveniente de la extracción de expresiones regulares en HTML sobre los juegos de herramientas SGML adecuados o los analizadores de base XML es su esfuerzo sintáctico y su confiabilidad variable.
Considere que hacer una expresión regular de extracción de HTML algo confiable:
<a/s+class="?playbutton/d?[^>]+id="(/d+)".+? <a/s+class="[/w/s]*title
[/w/s]*"[^>]+href="(http://[^">]+)"[^>]*>([^<>]+)</a>.+?
es mucho menos legible que un simple phpQuery o equivalente de QueryPath:
$div->find(".stationcool a")->attr("title");
Sin embargo, hay casos de uso específicos en los que pueden ayudar.
- Muchas interfaces frontales de DOM no revelan comentarios HTML
<!--, que sin embargo son a veces los anclajes más útiles para la extracción. En particular, las variaciones pseudo-HTML<$var>o los residuos SGML son fáciles de dominar con expresiones regulares. - A menudo, las expresiones regulares pueden guardar el procesamiento posterior. Sin embargo, las entidades HTML a menudo requieren cuidado manual.
- Y, por último, para tareas sumamente sencillas como extraer <img src = urls, en realidad son una herramienta probable. La ventaja de la velocidad sobre los analizadores SGML / XML principalmente viene a jugar para estos procedimientos de extracción muy básicos.
A veces, incluso es aconsejable extraer previamente un fragmento de HTML usando expresiones regulares /<!--CONTENT-->(.+?)<!--END-->/ y procesar el resto usando las /<!--CONTENT-->(.+?)<!--END-->/ más simples del analizador de HTML.
Nota: en realidad tengo esta app , en la que empleé el análisis XML y las expresiones regulares de forma alternativa. La semana pasada, el análisis de PyQuery se rompió, y la expresión regular todavía funcionó. Sí raro, y no puedo explicarlo yo mismo. Pero así sucedió.
Así que, por favor, no rechacen las consideraciones del mundo real, simplemente porque no coinciden con el meme regex = evil. Pero tampoco vamos a votar esto demasiado. Es sólo una nota al margen para este tema.