parse - php xml get attribute of element




Come si analizzano e si elaborano HTML/XML in PHP? (20)

Estensioni XML native

Preferisco utilizzare una delle estensioni XML native poiché vengono fornite in bundle con PHP, sono in genere più veloci di tutte le librerie di terze parti e mi danno tutto il controllo di cui ho bisogno rispetto al markup.

DOM

L'estensione DOM consente di operare su documenti XML tramite DOM API con PHP 5. È un'implementazione del Document Object Model Core Level 3 del W3C, un'interfaccia indipendente dalla piattaforma e dalla lingua che consente a programmi e script di accedere e aggiornare dinamicamente il contenuto, la struttura e lo stile dei documenti.

DOM è in grado di analizzare e modificare l'HTML (spezzato) del mondo reale e può eseguire query XPath . È basato su libxml .

Ci vuole del tempo per essere produttivi con DOM, ma quel tempo ne vale la pena IMO. Dal momento che DOM è un'interfaccia indipendente dal linguaggio, troverai implementazioni in molte lingue, quindi se hai bisogno di cambiare il tuo linguaggio di programmazione, è probabile che saprai già come usare l'API DOM di quella lingua.

Un esempio di utilizzo di base può essere trovato in Grabbing l'attributo href di un elemento A e una panoramica concettuale generale può essere trovata su DOMDocument in php

Come usare l'estensione DOM è stato ampiamente trattato su StackOverflow , quindi se si sceglie di usarlo, si può essere sicuri che la maggior parte dei problemi che si incontrano possono essere risolti cercando / navigando Stack Overflow.

XMLReader

L'estensione XMLReader è un parser XML pull. Il lettore agisce come un cursore in avanti sul flusso del documento e si ferma su ciascun nodo sulla strada.

XMLReader, come DOM, è basato su libxml. Non sono a conoscenza di come attivare il modulo HTML Parser, quindi è probabile che l'uso di XMLReader per l'analisi dell'HT spezzato potrebbe essere meno affidabile rispetto all'utilizzo di DOM in cui è possibile indicarlo esplicitamente per utilizzare il modulo parser HTML di libxml.

È possibile trovare un semplice esempio di utilizzo per ottenere tutti i valori dai tag h1 utilizzando php

XML Parser

Questa estensione consente di creare parser XML e quindi definire gestori per diversi eventi XML. Ogni parser XML ha anche alcuni parametri che puoi regolare.

La libreria XML Parser si basa anche su libxml e implementa un parser push XML in stile SAX . Potrebbe essere una scelta migliore per la gestione della memoria rispetto a DOM o SimpleXML, ma sarà più difficile lavorare con il parser di pull implementato da XMLReader.

SimpleXml

L'estensione SimpleXML fornisce un set di strumenti molto semplice e facilmente utilizzabile per convertire XML in un oggetto che può essere elaborato con i normali selettori di proprietà e gli iteratori di array.

SimpleXML è un'opzione quando si conosce che l'HTML è XHTML valido. Se hai bisogno di analizzare l'HTML spezzato, non prendere nemmeno in considerazione SimpleXml perché si strozzerà.

Un semplice esempio di utilizzo può essere trovato in Un programma semplice al nodo CRUD e ai valori del nodo del file xml e ci sono molti esempi aggiuntivi nel manuale PHP .

Librerie di terze parti (basate su libxml)

Se preferisci usare una lib di terze parti, ti suggerirei di usare una lib che effettivamente usi DOM / libxml sotto invece dell'analisi delle stringhe.

FluentDom - Repo

FluentDOM fornisce un'interfaccia XML fluida simile a jQuery per il DOMDocument in PHP. I selettori sono scritti in XPath o CSS (utilizzando un convertitore da CSS a XPath). Le versioni attuali estendono il DOM implementando le interfacce standard e aggiungono funzionalità dal DOM Living Standard. FluentDOM può caricare formati come JSON, CSV, JsonML, RabbitFish e altri. Può essere installato tramite Composer.

HtmlPageDom

Wa72 \ HtmlPageDom` è una libreria PHP per una facile manipolazione dei documenti HTML utilizzando richiede DomCrawler dai componenti Symfony2 per attraversare l'albero DOM e lo estende aggiungendo metodi per manipolare l'albero DOM dei documenti HTML.

phpQuery (non aggiornato da anni)

phpQuery è un'API DOM (Document Object Model) basata su selettore CSS3 pilotabile dal lato server, basata su jQuery JavaScript Library scritta in PHP5 e fornisce CLI (Command Line Interface) aggiuntiva.

Vedi anche: https://github.com/electrolinux/phpquery

Zend_Dom

Zend_Dom fornisce strumenti per lavorare con documenti e strutture DOM. Attualmente, offriamo Zend_Dom_Query, che fornisce un'interfaccia unificata per interrogare i documenti DOM utilizzando sia i selettori XPath che CSS.

QueryPath

QueryPath è una libreria PHP per manipolare XML e HTML. È progettato per funzionare non solo con file locali, ma anche con servizi Web e risorse di database. Implementa gran parte dell'interfaccia jQuery (compresi i selettori in stile CSS), ma è fortemente ottimizzata per l'utilizzo lato server. Può essere installato tramite Composer.

fDOMDocument

fDOMDocument estende il DOM standard per utilizzare le eccezioni in tutte le occasioni di errori anziché gli avvisi o le avvertenze PHP. Aggiungono anche vari metodi e scorciatoie personalizzati per comodità e per semplificare l'uso del DOM.

sabre/xml

sabre / xml è una libreria che avvolge ed estende le classi XMLReader e XMLWriter per creare un semplice sistema di mappatura e design pattern "xml to object / array". Scrivere e leggere XML è single-pass e può quindi essere veloce e richiedere poca memoria su file xml di grandi dimensioni.

FluidXML

FluidXML è una libreria PHP per manipolare XML con un'API concisa e fluente. Sfrutta XPath e il modello di programmazione fluente per essere divertente ed efficace.

3rd-Party (non basato su libxml)

Il vantaggio di creare su DOM / libxml è che si ottengono buone prestazioni out of the box perché si basa su un'estensione nativa. Tuttavia, non tutte le librerie di terze parti seguono questa rotta. Alcuni di quelli elencati di seguito

Parser DOM HTML HTML semplice

  • Un parser DOM HTML scritto in PHP5 + ti consente di manipolare l'HTML in un modo molto semplice!
  • Richiede PHP 5+.
  • Supporta HTML non valido.
  • Trova i tag su una pagina HTML con selettori come jQuery.
  • Estrai contenuti da HTML in una singola riga.

Generalmente non consiglio questo parser. Il codebase è orribile e lo stesso parser è piuttosto lento e ha fame di memoria. Non tutti i selettori jQuery (come i selettori figlio ) sono possibili. Qualsiasi libreria basata su libxml dovrebbe sovraperformare facilmente.

Parser HTML Html

PHPHtmlParser è un parser html semplice e flessibile che ti permette di selezionare tag usando qualsiasi selettore di CSS, come jQuery. L'obiettivo è quello di assisterti nello sviluppo di strumenti che richiedono un modo semplice e veloce per scartare l'html, che sia valido o no! Questo progetto era originale supportato da sunra / php-simple-html-dom-parser ma il supporto sembra essersi fermato, quindi questo progetto è il mio adattamento del suo lavoro precedente.

Ancora una volta, non consiglierei questo parser. È piuttosto lento con un elevato utilizzo della CPU. Non esiste inoltre alcuna funzione per cancellare la memoria degli oggetti DOM creati. Questi problemi si riducono in modo particolare con i cicli annidati. La documentazione stessa è inaccurata e errata, senza alcuna risposta alle correzioni dal 14 aprile 16.

Ganon

  • Un tokenizzatore universale e un parser DOM DOM per HTML / XML / RSS
    • Capacità di manipolare elementi e i loro attributi
    • Supporta HTML non valido e UTF8
  • Può eseguire query avanzate tipo CSS3 su elementi (come jQuery - namespace supportati)
  • Un beautifier HTML (come HTML Tidy)
    • Minimizza CSS e Javascript
    • Ordina attributi, cambia il carattere, il rientro corretto, ecc.
  • Estensibile
    • Analisi di documenti mediante callback basati sul personaggio / token corrente
    • Operazioni separate in funzioni più piccole per una facile sostituzione
  • Veloce e facile

Mai usato Non posso dire se va bene.

HTML 5

Puoi utilizzare quanto sopra per l'analisi di HTML5, ma possono esserci stranezze dovute al markup consentito da HTML5. Quindi per HTML5 si vuole considerare l'utilizzo di un parser dedicato, come

html5lib

Implementazioni Python e PHP di un parser HTML basato sulla specifica HTML5 WHATWG per la massima compatibilità con i principali browser Web desktop.

Potremmo vedere più parser dedicati una volta finalizzato HTML5. C'è anche un post sul blog dell'argomento intitolato How-To for html 5 che vale la pena di verificare.

Servizi web

Se non hai voglia di programmare PHP, puoi anche usare i servizi Web. In generale, ho trovato pochissima utilità per questi, ma sono solo io e i miei casi d'uso.

YQL

Il servizio Web YQL consente alle applicazioni di interrogare, filtrare e combinare dati provenienti da diverse fonti su Internet. Le istruzioni YQL hanno una sintassi simile a SQL, familiare a qualsiasi sviluppatore con esperienza nel database.

ScraperWiki .

L'interfaccia esterna di ScraperWiki consente di estrarre i dati nel modulo che si desidera utilizzare sul Web o nelle proprie applicazioni. È inoltre possibile estrarre informazioni sullo stato di qualsiasi raschiatore.

Espressioni regolari

Ultimo e meno consigliato , puoi estrarre dati da HTML con espressioni regolari . In generale, l'uso delle espressioni regolari su HTML è sconsigliato.

La maggior parte dei frammenti che troverai sul Web per trovare corrispondenza con il markup sono fragili. Nella maggior parte dei casi stanno lavorando solo per un pezzo di HTML molto particolare. Piccole modifiche al markup, come l'aggiunta di spazi bianchi da qualche parte, o l'aggiunta, o la modifica di attributi in un tag, possono fare in modo che la RegEx fallisca quando non è stata scritta correttamente. Dovresti sapere cosa stai facendo prima di usare RegEx su HTML.

I parser HTML conoscono già le regole sintattiche dell'HTML. Le espressioni regolari devono essere insegnate per ogni nuovo RegEx che scrivi. RegEx va bene in alcuni casi, ma in realtà dipende dal tuo caso d'uso.

È possibile scrivere parser più affidabili , ma la scrittura di un parser personalizzato completo e affidabile con espressioni regolari è una perdita di tempo quando le già citate librerie esistono e fanno un lavoro molto migliore su questo.

Vedi anche Parsing Html The Cthulhu Way

Libri

Se vuoi spendere un po 'di soldi, dai un'occhiata

Non sono affiliato con PHP Architect o gli autori.

Come si può analizzare HTML / XML ed estrarre informazioni da esso?


A proposito, questo è comunemente indicato come raschiatura dello schermo . La libreria che ho usato per questo è Simple HTML Dom Parser .



Basta usare DOMDocument->loadHTML() e farlo con esso. L'algoritmo di parsing HTML di libxml è abbastanza buono e veloce, e contrariamente alla credenza popolare, non soffoca l'HTML malformato.


Esistono diversi motivi per non analizzare l'HTML tramite espressioni regolari. Ma se hai il controllo totale su quale HTML verrà generato, allora puoi farlo con una semplice espressione regolare.

Sopra è una funzione che analizza l'HTML tramite l'espressione regolare. Nota che questa funzione è molto sensibile e richiede che l'HTML obbedisca a determinate regole, ma funziona molto bene in molti scenari. Se vuoi un parser semplice e non vuoi installare le librerie, dai uno sguardo a questo:

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/")));

Esistono molti modi per elaborare DOM HTML / XML di cui la maggior parte è già stata menzionata. Quindi, non farò alcun tentativo di elencare me stesso.

Voglio solo aggiungere che personalmente preferisco usare l'estensione DOM e perché:

  • iit fa un uso ottimale del vantaggio prestazionale del codice C sottostante
  • è OO PHP (e mi permette di creare una sottoclasse)
  • è un livello piuttosto basso (che mi permette di usarlo come base non gonfia per un comportamento più avanzato)
  • fornisce accesso a ogni parte del DOM (a differenza di SimpleXml, che ignora alcune delle funzionalità XML meno conosciute)
  • ha una sintassi utilizzata per la scansione DOM simile alla sintassi utilizzata in Javascript nativo.

E anche se mi manca la possibilità di usare selettori CSS per DOMDocument , c'è un modo piuttosto semplice e conveniente per aggiungere questa funzionalità: sottoclasse il DOMDocument e aggiungendo i metodi querySelectorAll e querySelector alla sottoclasse.

Per analizzare i selettori, consiglio di utilizzare il componente CssSelector molto minimalista del framework Symfony . Questo componente DOMXpath selettori CSS in selettori XPath, che possono quindi essere inseriti in un DOMXpath per recuperare il corrispondente Nodelist.

È quindi possibile utilizzare questa sottoclasse (ancora di livello molto basso) come base per più classi di alto livello, destinate ad es. analizza tipi di XML molto specifici o aggiungi un comportamento più simile a jQuery.

Il codice qui sotto esce direttamente dalla mia PHPPowertools/DOM-Query e utilizza la tecnica che ho descritto.

Per l'analisi 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);
                }
            }
        }
    }

    [...]
}

Vedi anche Analisi di documenti XML con selettori CSS del creatore di Symfony, Fabien Potencier, sulla sua decisione di creare il componente CssSelector per Symfony e su come usarlo.


Ho creato una libreria denominata PHPPowertools/DOM-Query , che consente di eseguire la scansione di documenti HTML5 e XML proprio come fa con jQuery.

Sotto il cofano, usa symfony / DomCrawler per convertire i selettori CSS in selettori XPath . Utilizza sempre lo stesso DomDocument, anche quando passa un oggetto a un altro, per garantire prestazioni decenti.

Esempio di utilizzo:

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>');

[...]

Metodi supportati:

  1. Rinominato 'select', per ovvi motivi
  2. Rinominato 'void', poiché 'empty' è una parola riservata in PHP

NOTA :

La libreria include anche il proprio autoloader di configurazione zero per le librerie compatibili con PSR-0. L'esempio incluso dovrebbe funzionare immediatamente senza alcuna configurazione aggiuntiva. In alternativa, puoi usarlo con il compositore.


Ho scritto un parser XML generico che può facilmente gestire i file GB. È basato su XMLReader ed è molto facile da usare:

$source = new XmlExtractor("path/to/tag", "/path/to/file.xml");
foreach ($source as $tag) {
    echo $tag->field1;
    echo $tag->field2->subfield1;
}

Ecco il repository XmlExtractor : XmlExtractor


JSON e array da XML in tre righe:

$xml = simplexml_load_string($xml_string);
$json = json_encode($xml);
$array = json_decode($json,TRUE);

Ta da!


Per 1a e 2: voterei per la nuova classe Component di Symfony DOMCrawler ( DomCrawler ). Questa classe consente query simili ai selettori CSS. Dai un'occhiata a questa presentazione per esempi del mondo reale: news-of-the-symfony2-world .

Il componente è progettato per funzionare autonomamente e può essere utilizzato senza Symfony.

L'unico inconveniente è che funzionerà solo con PHP 5.3 o versioni successive.


Potresti provare a usare qualcosa come HTML Tidy per ripulire qualsiasi HTML "spezzato" e convertire l'HTML in XHTML, che puoi poi analizzare con un parser XML.


Prova semplice parser HTML DOM

  • Un parser DOM HTML scritto in PHP 5+ che ti permette di manipolare l'HTML in un modo molto semplice!
  • Richiede PHP 5+.
  • Supporta HTML non valido.
  • Trova i tag su una pagina HTML con selettori come jQuery.
  • Estrai contenuti da HTML in una singola riga.
  • Download


Esempi:

Come ottenere elementi 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>';


Come modificare gli elementi 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;


Estrai contenuti da HTML:

// Dump contents (without tags) from HTML
echo file_get_html('http://www.google.com/')->plaintext;


Scraping 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);

Sì, puoi usare simple_html_dom per lo scopo. Tuttavia ho lavorato parecchio con il simple_html_dom, in particolare per il web scraping e ho trovato che fosse troppo vulnerabile. Fa il lavoro di base, ma non lo consiglierò comunque.

Non ho mai usato il ricciolo per lo scopo, ma quello che ho imparato è che il ricciolo può fare il lavoro in modo molto più efficiente ed è molto più solido.

Si prega di controllare questo link: scraping-websites-with-curl


Se hai familiarità con il selettore jQuery, puoi usare ScarletsQuery per 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);

Questa libreria richiede in genere meno di 1 secondo per elaborare html offline.
Accetta anche HTML non valido o preventivo mancante sugli attributi del tag.


Simple HTML DOM è un ottimo parser open source:

simplehtmldom.sourceforge

Tratta gli elementi DOM in modo orientato agli oggetti, e la nuova iterazione ha un sacco di copertura per il codice non conforme. Ci sono anche alcune grandi funzioni come quelle che vedresti in JavaScript, come la funzione "trova", che restituirà tutte le istanze di elementi di quel nome di tag.

Ho usato questo in un certo numero di strumenti, testandolo su molti diversi tipi di pagine web, e penso che funzioni alla grande.


Un approccio generale che non ho visto qui è quello di eseguire HTML attraverso Tidy , che può essere impostato per sputare fuori XHTML garantito-valido. Quindi puoi usare qualsiasi vecchia libreria XML su di esso.

Ma per il tuo problema specifico, dovresti dare un'occhiata a questo progetto: http://fivefilters.org/content-only/ - è una versione modificata dell'algoritmo di Readability , che è progettato per estrarre solo il contenuto testuale (non le intestazioni e piè di pagina) da una pagina.


phpQuery e QueryPath sono estremamente simili nella replica della fluente API jQuery. Questo è anche il motivo per cui sono due degli approcci più semplici per analizzare correttamente l' HTML in PHP.

Esempi per QueryPath

In pratica, per prima cosa crei un albero DOM interrogabile da una stringa HTML:

 $qp = qp("<html><body><h1>title</h1>..."); // or give filename or URL

L'oggetto risultante contiene una rappresentazione ad albero completa del documento HTML. Può essere attraversato usando i metodi DOM. Ma l'approccio comune è usare i selettori CSS come in jQuery:

 $qp->find("div.classname")->children()->...;

 foreach ($qp->find("p img") as $img) {
     print qp($img)->attr("src");
 }

Principalmente si desidera utilizzare semplici selettori di tag #id e .class o DIV per ->find() . Ma puoi anche usare le istruzioni XPath , che a volte sono più veloci. Anche i tipici metodi jQuery come ->children() e ->text() e in particolare ->attr() semplificano l'estrazione degli snippet HTML corretti. (E hanno già decodificato le loro entità SGML).

 $qp->xpath("//div/p[1]");  // get first paragraph in a div

QueryPath consente inoltre di iniettare nuovi tag nello stream ( ->append ), e successivamente di generare e migliorare un documento aggiornato ( ->writeHTML ). È in grado non solo di analizzare l'HTML malformato, ma anche vari dialetti XML (con namespace) e persino di estrarre i dati dai microformati HTML (XFN, vCard).

 $qp->find("a[target=_blank]")->toggleClass("usability-blunder");

.

phpQuery o QueryPath?

Generalmente QueryPath è più adatto per la manipolazione di documenti. Mentre phpQuery implementa anche alcuni metodi pseudo AJAX (solo richieste HTTP) per somigliare più da vicino a jQuery. Si dice che phpQuery sia spesso più veloce di QueryPath (a causa del minor numero di funzioni complessive).

Per ulteriori informazioni sulle differenze vedere questo confronto sulla macchina wayback da tagbyte.org . (La fonte originale è scomparsa, quindi ecco un link all'archivio Internet. Sì, puoi ancora individuare le pagine mancanti, le persone.)

Ed ecco una presentazione completa di QueryPath .

vantaggi

  • Semplicità e affidabilità
  • Alternative semplici da usare ->find("a img, a object, div a")
  • Dati corretti che non escono (in confronto all'espressione grepping regolare)

XML_HTMLSax è piuttosto stabile, anche se non è più mantenuto. Un'altra opzione potrebbe essere quella di reindirizzare l'HTML tramite Html Tidy e quindi analizzarlo con strumenti XML standard.


QueryPath è buono, ma fai attenzione allo "stato del monitoraggio", perché se non ti rendi conto di cosa significa, può significare perdere tempo nel debug cercando di scoprire cosa è successo e perché il codice non funziona.

Ciò che significa è che ogni chiamata sul set di risultati modifica il set di risultati nell'oggetto, non è concatenabile come in jquery dove ogni link è un nuovo set, hai un singolo set che è il risultato della query e ogni chiamata di funzione modifica quel singolo set.

per ottenere un comportamento simile a quello jQuery, devi diramarti prima di fare un filtro / modificare un'operazione simile, il che significa che rispecchierà molto più strettamente ciò che accade in jQuery.

$results = qp("div p");
$forename = $results->find("input[name='forename']");

$results ora contiene il set di risultati per l' input[name='forename'] NON la query originale "div p" questo mi ha fatto inciampare molto, quello che ho trovato è che QueryPath tiene traccia dei filtri e trova e tutto ciò che modifica i tuoi risultati e negozi loro nell'oggetto. è necessario farlo invece

$forename = $results->branch()->find("input[name='forname']")

quindi $results non saranno modificati e potrai riutilizzare il set di risultati ancora e ancora, forse qualcuno con molte più conoscenze può chiarire un po 'questo, ma è fondamentalmente simile a quello che ho trovato.


Perché non dovresti e quando dovresti usare le espressioni regolari?

Prima di tutto, un termine improprio comune: i regexps non servono per " analizzare " l' HTML. I regex possono comunque " estrarre " i dati. L'estrazione è ciò per cui sono fatti. Il principale svantaggio della regex dell'estrazione HTML rispetto ai corretti toolkit SGML o ai parser XML di base è il loro sforzo sintattico e la loro affidabilità variabile.

Considera che rendere un regex un'espulsione HTML piuttosto affidabile:

<a\s+class="?playbutton\d?[^>]+id="(\d+)".+?    <a\s+class="[\w\s]*title
[\w\s]*"[^>]+href="(http://[^">]+)"[^>]*>([^<>]+)</a>.+?

è molto meno leggibile di un semplice equivalente phpQuery o QueryPath:

$div->find(".stationcool a")->attr("title");

Esistono tuttavia casi d'uso specifici in cui possono aiutare.

  • Molti front-end DOM trasversali non rivelano commenti HTML <!-- , che tuttavia a volte sono gli ancoraggi più utili per l'estrazione. In particolare, le variazioni pseudo-HTML <$var> oi residui SGML sono facili da domare con espressioni regolari.
  • Spesso le espressioni regolari possono salvare la post-elaborazione. Tuttavia, le entità HTML spesso richiedono il controllo manuale.
  • Infine, per compiti estremamente semplici come l'estrazione di <img src = urls, sono in realtà uno strumento probabile. Il vantaggio in termini di velocità rispetto ai parser SGML / XML si limita principalmente a giocare per queste procedure di estrazione molto semplici.

A volte è anche consigliabile pre-estrarre uno snippet di HTML usando le espressioni regolari /<!--CONTENT-->(.+?)<!--END-->/ ed elaborare il resto usando i frontend del parser HTML più semplici.

Nota: in realtà ho questa app , dove utilizzo l'analisi XML e le espressioni regolari in alternativa. Proprio la scorsa settimana si è rotto l'analisi di PyQuery, e la regex ha funzionato ancora. Sì, strano, e non posso spiegarlo da solo. Ma così è successo.
Quindi, per favore, non votare le considerazioni del mondo reale, solo perché non corrisponde al meme regex = evil. Ma non votiamo troppo a questo. È solo un sidenote per questo argomento.





html-parsing