Wie analysiert und verarbeitet man HTML / XML in PHP?

Versuchen Sie Simple HTML DOM Parser

• Ein in PHP 5+ geschriebener HTML-DOM-Parser, mit dem Sie HTML auf sehr einfache Weise bearbeiten können!
• Benötige PHP 5+.
• Unterstützt ungültiges HTML.
• Suchen Sie Tags auf einer HTML-Seite mit Selektoren wie jQuery.
• Extrahieren Sie Inhalte aus HTML in einer einzigen Zeile.
• Download

Beispiele:

So erhalten Sie HTML-Elemente:

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

So ändern Sie HTML-Elemente:

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

Inhalte aus HTML extrahieren:

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

Slashdot schaben:

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

Verwenden Sie einfach DOMDocument-> loadHTML () und fertig. Der HTML-Parsing-Algorithmus von libxml ist recht gut und schnell und verschluckt im Gegensatz zur landläufigen Meinung kein fehlerhaftes HTML.

Warum sollten Sie nicht und wann sollten Sie reguläre Ausdrücke verwenden?

Erstens eine häufige Fehlbezeichnung: Regexps sind nicht für " Parsing " HTML. Regexe können jedoch "" Daten extrahieren. Extrahieren ist das, wofür sie gemacht sind. Der Hauptnachteil der regex-HTML-Extraktion gegenüber geeigneten SGML-Toolkits oder XML-Grundparsern ist ihr syntaktischer Aufwand und ihre unterschiedliche Zuverlässigkeit.

Beachten Sie, dass Sie einen etwas verlässlichen regulären HTML-Extraktions-Ausdruck erstellen:

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

ist weitaus weniger lesbar als ein einfaches phpQuery- oder QueryPath-Äquivalent:

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

Es gibt jedoch spezielle Anwendungsfälle, bei denen sie helfen können.

• Viele DOM-Traversal-Frontends zeigen keine HTML-Kommentare <!-- an, die jedoch manchmal die nützlicheren Anker für die Extraktion sind. Insbesondere Pseudo-HTML-Variationen <$var> oder SGML-Reste lassen sich leicht mit regulären Ausdrücken zähmen.
• Häufig sparen reguläre Ausdrücke die Nachbearbeitung. HTML-Entitäten erfordern jedoch häufig eine manuelle Pflege.
• Und schließlich sind e extrem einfache Aufgaben wie das Extrahieren von <img src = urls ein wahrscheinliches Werkzeug. Der Geschwindigkeitsvorteil gegenüber SGML/XML-Parsern kommt meist nur bei diesen sehr einfachen Extraktionsverfahren zum Tragen.

Manchmal ist es sogar ratsam, ein HTML-Snippet mit regulären Ausdrücken /<!--CONTENT-->(.+?)<!--END-->/ vorab zu extrahieren und den Rest mit den einfacheren HTML-Parser-Frontends zu verarbeiten.

Hinweis: Ich habe tatsächlich diese App , bei der ich alternativ XML-Parsing und reguläre Ausdrücke verwende. Erst letzte Woche brach das PyQuery-Parsing ab und der reguläre Ausdruck funktionierte immer noch. Ja komisch, und ich kann es mir nicht erklären. Aber so ist es passiert.
Also bitte stimmen Sie die realen Überlegungen nicht ab, nur weil sie nicht mit dem Regex = böse Mem übereinstimmen. Aber lassen Sie uns auch nicht zu viel darüber abstimmen. Es ist nur eine Randnotiz für dieses Thema.

phpQuery und QueryPath sind sich beim Replizieren der flüssigen jQuery-API sehr ähnlich. Das ist auch der Grund, warum sie zwei der einfachsten Methoden sind, umrichtigHTML in PHP zu analysieren.

Beispiele für QueryPath

Grundsätzlich erstellen Sie zunächst einen abfragbaren DOM-Baum aus einer HTML-Zeichenfolge:

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

Das resultierende Objekt enthält eine vollständige Baumdarstellung des HTML-Dokuments. Es kann mit DOM-Methoden durchlaufen werden. Der übliche Ansatz ist jedoch die Verwendung von CSS-Selektoren wie in jQuery:

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

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

Meistens möchten Sie einfache #id und .class oder DIV Tag-Selektoren für ->find() verwenden. Sie können aber auch XPath Anweisungen verwenden, die manchmal schneller sind. Auch typische jQuery-Methoden wie ->children() und ->text() und insbesondere ->attr() vereinfachen das Extrahieren der richtigen HTML-Schnipsel. (Und haben bereits ihre SGML-Entitäten dekodiert.)

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

Mit QueryPath können Sie auch neue Tags in den Stream einfügen (->append) und später ein aktualisiertes Dokument ausgeben und verschönern (->writeHTML). Es kann nicht nur fehlerhaftes HTML, sondern auch verschiedene XML-Dialekte (mit Namespaces) analysieren und sogar Daten aus HTML-Mikroformaten (XFN, vCard) extrahieren.

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

.

phpQuery oder QueryPath?

Im Allgemeinen eignet sich QueryPath besser zur Bearbeitung von Dokumenten. Während phpQuery auch einige Pseudo-AJAX -Methoden implementiert (nur HTTP-Anforderungen), um jQuery näher zu kommen. Es wird gesagt, dass phpQuery oft schneller als QueryPath ist (wegen der geringeren Gesamtfeatures).

Weitere Informationen zu den Unterschieden finden Sie unter dieser Vergleich auf der Wayback-Maschine von tagbyte.org . (Die ursprüngliche Quelle ist verschwunden. Hier ist also ein Link zum Internetarchiv. Ja, Sie können immer noch fehlende Seiten und Personen finden.)

Und hier ist eine umfassende QueryPath-Einführung .

Vorteile

• Einfachheit und Zuverlässigkeit
• Einfach zu verwendende Alternativen ->find("a img, a object, div a")
• Ordnungsgemäße Datenentnahme (im Vergleich zum Greppen mit regulären Ausdrücken)

Simple HTML DOM ist ein großartiger Open-Source-Parser:

simplehtmldom.sourceforge

DOM-Elemente werden objektorientiert behandelt, und die neue Iteration deckt häufig nicht kompatiblen Code ab. Es gibt auch einige großartige Funktionen, wie Sie sie in JavaScript sehen würden, wie zum Beispiel die "find" -Funktion, die alle Instanzen von Elementen dieses Tag-Namens zurückgibt.

Ich habe dies in einer Reihe von Tools verwendet und es auf vielen verschiedenen Arten von Webseiten getestet, und ich denke, es funktioniert großartig.

Ein allgemeiner Ansatz, den ich hier nicht gesehen habe, ist das Ausführen von HTML durch Tidy , das so eingestellt werden kann, dass garantiert gültiges XHTML ausgespuckt wird. Dann können Sie eine beliebige alte XML-Bibliothek verwenden.

Aber für Ihr spezielles Problem sollten Sie sich dieses Projekt ansehen: http://fivefilters.org/content-only/ - Es ist eine modifizierte Version von Readability Algorithmus, mit dem nur der Textinhalt (nicht Kopf- und Fußzeilen) einer Seite extrahiert wird.

Zu 1a und 2: Ich würde für die neue Symfony Componet-Klasse DOMCrawler stimmen ( DomCrawler ). Diese Klasse ermöglicht Abfragen, die CSS-Selektoren ähneln. Schauen Sie sich diese Präsentation an, um Beispiele aus der Praxis zu sehen: news-of-the-symfony2-world .

Die Komponente ist eigenständig und kann ohne Symfony verwendet werden.

Der einzige Nachteil ist, dass es nur mit PHP 5.3 oder neuer funktioniert.

Dies wird im Allgemeinen als Screen Scraping bezeichnet. Die Bibliothek, die ich dafür verwendet habe, ist Simple HTML Dom Parser .

Wir haben schon einige Crawler für unsere Bedürfnisse erstellt. Letztendlich sind es meist einfache reguläre Ausdrücke, die das Beste ausmachen. Die oben aufgelisteten Bibliotheken sind zwar gut für den Grund, warum sie erstellt wurden. Wenn Sie jedoch wissen, wonach Sie suchen, sind reguläre Ausdrücke ein sicherer Weg, da Sie auch ungültige HTML /verarbeiten können. XHTML Strukturen, die fehlschlagen würden, wenn sie über die meisten Parser geladen würden.

Ich empfehle PHP Simple HTML DOM Parser .

Es hat wirklich nette Funktionen, wie:

foreach($html->find('img') as $element)
       echo $element->src . '<br>';

Dies klingt nach einer guten Aufgabenbeschreibung der W3C XPath -Technologie. Es ist einfach, Abfragen wie "Alle href Attribute in img Tags zurückgeben, die in <foo><bar><baz> elements verschachtelt sind." Da ich kein PHP-Fan bin, kann ich Ihnen nicht sagen, in welcher Form XPath verfügbar ist. Wenn Sie ein externes Programm zum Verarbeiten der HTML-Datei aufrufen können, sollten Sie eine Befehlszeilenversion von XPath verwenden können. Eine kurze Einführung finden Sie unter http://en.wikipedia.org/wiki/XPath .

Alternativen von Drittanbietern zu SimpleHtmlDom, die DOM anstelle von String Parsing verwenden: phpQuery , Zend_Dom , QueryPath und FluentDom .

Ja, Sie können simple_html_dom für diesen Zweck verwenden. Ich habe jedoch ziemlich viel mit der simple_html_dom gearbeitet, insbesondere beim Web-Scrapping, und fand sie zu anfällig. Es macht die grundlegende Arbeit, aber ich werde es sowieso nicht empfehlen.

Ich habe Curl nie für diesen Zweck verwendet, aber was ich gelernt habe, ist, dass Curl die Arbeit viel effizienter erledigen kann und viel solider ist.

Bitte überprüfen Sie diesen Link: Scraping-Websites-with-Curl

QueryPath ist gut, aber achten Sie auf den "Verfolgungsstatus", denn wenn Sie nicht wissen, was dies bedeutet, können Sie viel Debugging verschwenden Zeit, um herauszufinden, was passiert ist und warum der Code nicht funktioniert.

Das bedeutet, dass jeder Aufruf der Ergebnismenge die Ergebnismenge im Objekt ändert. Es ist nicht verkettbar wie in jquery, wo jede Verknüpfung eine neue Menge ist. Sie haben eine einzige Menge, die das Ergebnis Ihrer Abfrage ist, und jeder Funktionsaufruf ändert sich dieser einzige Satz.

um ein jQuery-ähnliches Verhalten zu erhalten, müssen Sie verzweigen, bevor Sie eine Filter-/Änderungsoperation ausführen. Dies bedeutet, dass das, was in JQuery geschieht, viel genauer gespiegelt wird.

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

$results enthält jetzt die Ergebnismenge für input[name='forename'] NICHT die ursprüngliche Abfrage "div p" dies hat mich sehr gestört, was ich fand war, dass QueryPath verfolgt die Filter und findet und alles, was Ihre Ergebnisse ändert und speichert sie im Objekt. Sie müssen dies stattdessen tun

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

dann wird $results nicht geändert, und Sie können die Ergebnismenge immer wieder verwenden. Vielleicht kann jemand mit viel mehr Wissen dies ein wenig aufklären, aber es ist im Grunde so, wie ich es gefunden habe.

Advanced Html Dom ist eine einfache HTML DOM - Ersetzung, die dieselbe Schnittstelle bietet, jedoch DOM-basiert ist, was bedeutet, dass keines der damit verbundenen Speicherprobleme auftritt.

Es hat auch volle CSS-Unterstützung, einschließlich jQuery Erweiterungen.

Für HTML5 wurde die HTML5-Bibliothek seit Jahren aufgegeben. Die einzige HTML5-Bibliothek, die ich mit den neuesten Aktualisierungs- und Wartungsaufzeichnungen finden kann, ist html5-php , die erst vor etwas mehr als einer Woche auf Beta 1.0 gebracht wurde.

Ich habe einen XML-Parser für allgemeine Zwecke geschrieben, der problemlos mit GB-Dateien umgehen kann. Es basiert auf XMLReader und ist sehr einfach zu bedienen:

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

Hier ist das Github-Repo: XmlExtractor

Ich habe eine Bibliothek mit dem Namen PHPPowertools/DOM-Query erstellt, mit der Sie HTML5- und XML-Dokumente wie gewohnt crawlen können jQuery.

Unter der Haube verwendet es symfony/DomCrawler für die Konvertierung von CSS-Selektoren in XPath Selektoren. Es wird immer dasselbe DomDocument verwendet, auch wenn ein Objekt an ein anderes übergeben wird, um eine angemessene Leistung sicherzustellen.

Beispiel Verwendung:

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

[...]

Unterstützte Methoden:

• [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

1. Aus offensichtlichen Gründen umbenannt in 'select'
2. Umbenannt in 'void', da 'empty' in PHP ein reserviertes Wort ist

HINWEIS :

Die Bibliothek enthält auch einen eigenen Autoloader mit Null-Konfiguration für PSR-0-kompatible Bibliotheken. Das mitgelieferte Beispiel sollte ohne zusätzliche Konfiguration funktionieren. Alternativ können Sie es auch mit dem Komponisten verwenden.

Sie könnten versuchen, etwas wie HTML Tidy zu verwenden, um "defektes" HTML zu bereinigen und das HTML in XHTML zu konvertieren, das Sie dann mit einem XML-Parser analysieren können.

Eine andere Option, die Sie ausprobieren können, ist QueryPath . Es ist von jQuery inspiriert, wird jedoch auf dem Server in PHP und in Drupal verwendet.

XML_HTMLSax ist ziemlich stabil - auch wenn es nicht mehr gepflegt wird. Eine andere Möglichkeit wäre, HTML durch Html ​​Tidy zu leiten und es dann mit Standard-XML-Tools zu analysieren.

Das Symfony -Framework verfügt über Bundles, die den HTML-Code analysieren können, und Sie können den CSS-Stil verwenden, um DOMs auszuwählen, anstatt XPath zu verwenden.

Es gibt viele Möglichkeiten, HTML/XML-DOM zu verarbeiten, von denen die meisten bereits erwähnt wurden. Daher werde ich nicht versuchen, diese selbst aufzulisten.

Ich möchte nur hinzufügen, dass ich persönlich die DOM-Erweiterung bevorzuge und warum:

• iit nutzt den Leistungsvorteil des zugrunde liegenden C-Codes optimal aus
• es ist OO PHP (und erlaubt mir, es zu unterklassifizieren)
• es ist ziemlich niedrig (was mir erlaubt, es als nicht aufgeblähte Grundlage für fortgeschritteneres Verhalten zu verwenden)
• es bietet Zugriff auf jeden Teil des DOM (im Gegensatz zu zB SimpleXml, das einige der weniger bekannten XML-Funktionen ignoriert).
• es hat eine Syntax für das DOM-Crawlen, die der in nativem Javascript verwendeten Syntax ähnelt.

Und obwohl ich die Möglichkeit vermisse, CSS-Selektoren für DOMDocument zu verwenden, gibt es eine ziemlich einfache und bequeme Möglichkeit, diese Funktion hinzuzufügen: das DOMDocument unterzuordnen und JS-ähnliche querySelectorAll und querySelector Methoden zu Ihrer Unterklasse.

Zum Parsen der Selektoren empfehle ich die Verwendung des sehr minimalistischen CssSelector-Komponente aus dem Symfony-Framework . Diese Komponente übersetzt nur CSS-Selektoren in XPath-Selektoren, die dann in ein DOMXpath eingegeben werden können, um die entsprechende Knotenliste abzurufen.

Sie können diese (noch sehr niedrige) Unterklasse dann als Grundlage für höhere Klassen verwenden, um z. Analysieren Sie ganz bestimmte XML-Typen oder fügen Sie mehr jQuery-ähnliches Verhalten hinzu.

Der folgende Code kommt direkt aus meiner DOM-Query-Bibliothek und verwendet die von mir beschriebene Technik.

Für das HTML-Parsen:

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

    [...]
}

Siehe auch Analysieren von XML-Dokumenten mit CSS-Selektoren von Fabien Potencier, dem Schöpfer von Symfony, zu seiner Entscheidung, die CssSelector-Komponente für Symfony zu erstellen, und deren Verwendung.

Mit FluidXML können Sie XML mit XPath und CSS abfragen und iterieren Selektoren .

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

https://github.com/servo-php/fluidxml

JSON und Array aus XML in drei Zeilen:

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

Ta da!

Es gibt mehrere Gründe, HTML nicht mit regulären Ausdrücken zu analysieren. Wenn Sie jedoch die vollständige Kontrolle darüber haben, welcher HTML-Code generiert wird, können Sie mit einfachen regulären Ausdrücken vorgehen.

Darüber befindet sich eine Funktion, die HTML mit regulären Ausdrücken analysiert. Beachten Sie, dass diese Funktion sehr empfindlich ist und erfordert, dass der HTML-Code bestimmte Regeln einhält, sie funktioniert jedoch in vielen Szenarien sehr gut. Wenn Sie einen einfachen Parser benötigen und keine Bibliotheken installieren möchten, versuchen Sie Folgendes:

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

Ich habe eine Bibliothek namens HTML5DOMDocument erstellt, die unter https://github.com/ivopetkov/html5-dom-document-php frei verfügbar ist

Es unterstützt auch Abfrageselektoren, von denen ich denke, dass sie in Ihrem Fall äußerst hilfreich sind. Hier ist ein Beispielcode:

$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;

Wenn Sie mit jQuery Selector vertraut sind, können Sie ScarletsQuery für PHP verwenden

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

Diese Bibliothek benötigt normalerweise weniger als 1 Sekunde, um Offline-HTML zu verarbeiten.
Es akzeptiert auch ungültiges HTML oder fehlende Anführungszeichen für Tag-Attribute.

Die beste Methode zum Parsen von XML:

$xml='http://www.example.com/rss.xml';
$rss = simplexml_load_string($xml);
$i = 0;
foreach ($rss->channel->item as $feedItem) {
$i++;
echo $title=$feedItem->title;
echo '<br>';
echo $link=$feedItem->link;
echo '<br>';
if($feedItem->description !='') {$des=$feedItem->description;} else {$des='';}
echo $des;
echo '<br>';
if($i>5) break;
}