HTML mit PHP parsen

Dieser Leitfaden untersucht drei Techniken zum Parsen von HTML in PHP und vergleicht deren Stärken und Unterschiede:

• HTML mit PHP parsen
• Warum HTML in PHP parsen?
• Voraussetzungen
• HTML-Abruf in PHP
• HTML-Parsing in PHP: 3 Ansätze
  • Ansatz #1: Mit Dom\HTMLDocument
  • Ansatz #2: Mit Simple HTML DOM Parser
  • Ansatz #3: Mit Symfonys DomCrawler-Komponente
• HTML-Parsing in PHP: Vergleichstabelle
• Fazit

Warum HTML in PHP parsen?

HTML-Parsing in PHP bedeutet, HTML-Inhalte in ihre DOM-Struktur (Document Object Model) zu konvertieren. Sobald das DOM-Format vorliegt, können Sie die HTML-Inhalte einfach navigieren und manipulieren.

Insbesondere sind die wichtigsten Gründe, HTML in PHP zu parsen:

• Datenextraktion: Abrufen spezifischer Inhalte von Webseiten, einschließlich Text oder Attributen aus HTML-Elementen.
• Automatisierung: Optimierung von Aufgaben wie Content-Scraping, Reporting und Datenaggregation aus HTML.
• Serverseitige HTML-Verarbeitung: Parsen und Manipulieren von HTML, um Webinhalte zu bereinigen, zu formatieren oder zu ändern, bevor sie in Ihrer Anwendung gerendert werden.

Voraussetzungen

Bevor Sie mit dem Programmieren beginnen, stellen Sie sicher, dass PHP 8.4+ auf Ihrem Rechner installiert ist. Sie können dies überprüfen, indem Sie den folgenden Befehl ausführen:

php -v

Die Ausgabe sollte in etwa so aussehen:

PHP 8.4.3 (cli) (built: Jan 19 2025 14:20:58) (NTS)
Copyright (c) The PHP Group
Zend Engine v4.4.3, Copyright (c) Zend Technologies
    with Zend OPcache v8.4.3, Copyright (c), by Zend Technologies

Initialisieren Sie als Nächstes ein Composer-Projekt, um das Dependency-Management zu erleichtern. Falls Composer nicht auf Ihrem System installiert ist, laden Sie es herunter und folgen Sie den Installationsanweisungen.

Erstellen Sie zunächst einen neuen Ordner für Ihr PHP-HTML-Projekt:

mkdir php-html-parser

Navigieren Sie im Terminal in den Ordner und initialisieren Sie darin ein Composer-Projekt mit dem Befehl composer init:

composer init

Während dieses Vorgangs werden Ihnen einige Fragen gestellt. Die Standardantworten sind ausreichend, Sie können aber bei Bedarf spezifischere Details angeben, um das Setup für Ihr PHP-HTML-Parsing-Projekt anzupassen.

Öffnen Sie anschließend den Projektordner in Ihrer bevorzugten IDE. Visual Studio Code mit der PHP-Erweiterung oder IntelliJ WebStorm sind gute Optionen für die PHP-Entwicklung.

Fügen Sie nun eine leere Datei index.php zum Projektordner hinzu. Ihre Projektstruktur sollte jetzt wie folgt aussehen:

php-html-parser/
  ├── vendor/
  ├── composer.json
  └── index.php

Öffnen Sie index.php und fügen Sie den folgenden Code hinzu, um Ihr Projekt zu initialisieren:

<?php

require_once __DIR__ . "/vendor/autoload.php";

// scraping logic...

Führen Sie Ihr Skript mit diesem Befehl aus:

php index.php

HTML-Abruf in PHP

Bevor Sie HTML in PHP parsen, benötigen Sie HTML zum Parsen. In diesem Abschnitt sehen wir zwei unterschiedliche Ansätze, um in PHP auf HTML-Inhalte zuzugreifen. Wir empfehlen Ihnen auch, unseren Leitfaden zum Web-Scraping mit PHP zu lesen.

Mit CURL

PHP unterstützt nativ cURL, einen beliebten HTTP-Client zum Ausführen von HTTP-Anfragen. Aktivieren Sie die cURL-Extension oder installieren Sie sie unter Ubuntu Linux mit:

sudo apt-get install php8.4-curl

Sie können cURL verwenden, um eine HTTP-GET-Anfrage an einen Online-Server zu senden und das vom Server zurückgegebene HTML-Dokument abzurufen. Dieses Beispielskript führt eine einfache GET-Anfrage aus und ruft HTML-Inhalte ab:

// initialize cURL session
$ch = curl_init();

// set the URL you want to make a GET request to
curl_setopt($ch, CURLOPT_URL, "https://www.scrapethissite.com/pages/forms/?per_page=100");

// return the response instead of outputting it
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

// execute the cURL request and store the result in $response
$html = curl_exec($ch);

// close the cURL session
curl_close($ch);

// output the HTML response
echo $html;

Fügen Sie das obige Code-Snippet zu index.php hinzu und starten Sie es. Es erzeugt den folgenden HTML-Code:

<!doctype html>
<html lang="en">
  <head>
    <meta charset="utf-8">
    <title>Hockey Teams: Forms, Searching and Pagination | Scrape This Site | A public sandbox for learning web scraping</title>
    <link rel="icon" type="image/png" href="/static/images/scraper-icon.png" />
    <!-- Omitted for brevity... -->
</html>

Aus einer Datei

Angenommen, Sie haben eine Datei namens index.html, die das HTML der Seite „Hockey Teams“ von Scrape This Site enthält, die zuvor mit cURL abgerufen wurde:

HTML-Parsing in PHP: 3 Ansätze

Dieser Abschnitt erläutert die Verwendung von drei verschiedenen Bibliotheken zum Parsen von HTML in PHP:

1. Verwendung von Dom\HTMLDocument für Vanilla-PHP
2. Verwendung der Bibliothek Simple HTML DOM Parser
3. Verwendung der Symfony-Komponente DomCrawler

In allen drei Fällen parsen Sie das HTML aus der lokalen Datei index.html, um alle Hockey-Team-Einträge auf der Seite auszuwählen und Daten daraus zu extrahieren:

Das Endergebnis ist eine Liste gescrapter Hockey-Team-Einträge mit den folgenden Details:

• Team Name
• Year
• Wins
• Losses
• Win %
• Goals For (GF)
• Goals Against (GA)
• Goal Difference

Sie können diese aus der HTML-Tabelle mit dieser Struktur extrahieren:

Jede Spalte in einer Tabellenzeile hat eine spezifische Klasse, sodass Sie Daten extrahieren können, indem Sie Elemente mit ihrer Klasse als CSS-Selektor auswählen und ihren Inhalt über ihren Text abrufen.

Ansatz #1: Mit Dom\HTMLDocument

PHP 8.4+ wird mit einer integrierten Klasse Dom\HTMLDocument ausgeliefert. Diese repräsentiert ein HTML-Dokument und ermöglicht es Ihnen, HTML-Inhalte zu parsen und durch den DOM-Baum zu navigieren.

Step #1: Installation und Setup

Dom\HTMLDocument ist Teil der Standard PHP Library. Dennoch müssen Sie die DOM-Extension aktivieren oder sie mit diesem Linux-Befehl installieren, um sie verwenden zu können:

sudo apt-get install php-dom

Step #2: HTML-Parsing

Sie können den HTML-String wie folgt parsen:

$dom = \DOM\HTMLDocument::createFromString($html);

Sie können die Datei index.html parsen mit:

$dom = \DOM\HTMLDocument::createFromFile("./index.html");

$dom ist ein Dom\HTMLDocument-Objekt, das die Methoden bereitstellt, die Sie für das Datenparsing benötigen.

Step #3: Datenparsing

Sie können alle Hockey-Team-Einträge mit \DOM\HTMLDocument mit folgendem Ansatz auswählen:

// select each row on the page
$table = $dom->getElementsByTagName("table")->item(0);
$rows = $table->getElementsByTagName("tr");

// iterate through each row and extract data
foreach ($rows as $row) {
  $cells = $row->getElementsByTagName("td");

  // extracting the data from each column
  $team = trim($cells->item(0)->textContent);
  $year = trim($cells->item(1)->textContent);
  $wins = trim($cells->item(2)->textContent);
  $losses = trim($cells->item(3)->textContent);
  $win_pct = trim($cells->item(5)->textContent);
  $goals_for = trim($cells->item(6)->textContent);
  $goals_against = trim($cells->item(7)->textContent);
  $goal_diff = trim($cells->item(8)->textContent);

  // create an array for the scraped team data
  $team_data = [
    "team" => $team,
    "year" => $year,
    "wins" => $wins,
    "losses" => $losses,
    "win_pct" => $win_pct,
    "goals_for" => $goals_for,
    "goals_against" => $goals_against,
    "goal_diff" => $goal_diff
  ];

  // print the scraped team data
  print_r($team_data);
  print ("\n");
}

\DOM\HTMLDocument bietet keine erweiterten Abfragemethoden. Daher müssen Sie sich auf Methoden wie getElementsByTagName() und manuelle Iteration verlassen.

Hier ist eine Aufschlüsselung der verwendeten Methoden:

• getElementsByTagName(): Ruft alle Elemente eines bestimmten Tags (wie <table>, <tr> oder <td>) innerhalb des Dokuments ab.
• item(): Gibt ein einzelnes Element aus einer Liste von Elementen zurück, die von getElementsByTagName() zurückgegeben wird.
• textContent: Diese Eigenschaft liefert den rohen Textinhalt eines Elements, sodass Sie die sichtbaren Daten (wie Teamname, Jahr usw.) extrahieren können.

Wir haben außerdem trim() verwendet, um zusätzlichen Whitespace vor und nach dem Textinhalt zu entfernen und so sauberere Daten zu erhalten.

Wenn Sie das obige Snippet zu index.php hinzufügen, ergibt sich dieses Ergebnis:

Array
(
    [team] => Boston Bruins
    [year] => 1990
    [wins] => 44
    [losses] => 24
    [win_pct] => 0.55
    [goals_for] => 299
    [goals_against] => 264
    [goal_diff] => 35
)

// omitted for brevity...

Array
(
    [team] => Detroit Red Wings
    [year] => 1994
    [wins] => 33
    [losses] => 11
    [win_pct] => 0.688
    [goals_for] => 180
    [goals_against] => 117
    [goal_diff] => 63
) 

Ansatz #2: Mit Simple HTML DOM Parser

Simple HTML DOM Parser ist eine leichtgewichtige PHP-Bibliothek, die das Parsen und Manipulieren von HTML-Inhalten vereinfacht.

Step #1: Installation und Setup

Sie können Simple HTML Dom Parser über Composer mit diesem Befehl installieren:

composer require voku/simple_html_dom

Alternativ können Sie die Datei simple_html_dom.php manuell herunterladen und in Ihr Projekt einbinden.

Importieren Sie sie dann in index.php mit dieser Codezeile:

use voku\helper\HtmlDomParser;

Step #2: HTML-Parsing

Um einen HTML-String zu parsen, verwenden Sie die Methode file_get_html():

$dom = HtmlDomParser::str_get_html($html);

Zum Parsen von index.html schreiben Sie stattdessen file_get_html():

$dom = HtmlDomParser::file_get_html($str);

Dies lädt den HTML-Inhalt in ein $dom-Objekt, das Ihnen eine einfache Navigation im DOM ermöglicht.

Step #3: Datenparsing

Extrahieren Sie die Hockey-Team-Daten aus dem HTML mit Simple HTML DOM Parser:

// find all rows in the table
$rows = $dom->findMulti("table tr.team");

// loop through each row to extract the data
foreach ($rows as $row) {
  // extract data using CSS selectors
  $team_element = $row->findOne(".name");
  $team = trim($team_element->plaintext);

  $year_element = $row->findOne(".year");
  $year = trim($year_element->plaintext);

  $wins_element = $row->findOne(".wins");
  $wins = trim($wins_element->plaintext);

  $losses_element = $row->findOne(".losses");
  $losses = trim($losses_element->plaintext);

  $win_pct_element = $row->findOne(".pct");
  $win_pct = trim($win_pct_element->plaintext);

  $goals_for_element = $row->findOne(".gf");
  $goals_for = trim($goals_for_element->plaintext);

  $goals_against_element = $row->findOne(".ga");
  $goals_against = trim(string: $goals_against_element->plaintext);

  $goal_diff_element = $row->findOne(".diff");
  $goal_diff = trim(string: $goal_diff_element->plaintext);

  // create an array with the extracted team data
  $team_data = [
    "team" => $team,
    "year" => $year,
    "wins" => $wins,
    "losses" => $losses,
    "win_pct" => $win_pct,
    "goals_for" => $goals_for,
    "goals_against" => $goals_against,
    "goal_diff" => $goal_diff
  ];

  // print the scraped team data
  print_r($team_data);
  print("\n");
}

Die oben verwendeten Simple HTML DOM Parser-Funktionen sind:

• findMulti(): Wählt alle Elemente aus, die durch den angegebenen CSS-Selektor identifiziert werden.
• findOne(): Findet das erste Element, das dem angegebenen CSS-Selektor entspricht.
• plaintext: Ein Attribut, um den rohen Textinhalt innerhalb eines HTML-Elements abzurufen.

Dieses Mal haben wir CSS-Selektoren mit einer umfassenderen und robusteren Logik angewendet. Das Ergebnis bleibt jedoch dasselbe wie beim ursprünglichen PHP-HTML-Parsing-Ansatz.

Ansatz #3: Mit Symfonys DomCrawler-Komponente

Symfonys DomCrawler-Komponente bietet eine einfache Möglichkeit, HTML-Dokumente zu parsen und Daten daraus zu extrahieren.

Hinweis: Die Komponente ist Teil des Symfony-Frameworks, kann aber auch standalone verwendet werden, wie wir es in diesem Abschnitt tun.

Step #1: Installation und Setup

Installieren Sie Symfonys DomCrawler-Komponente mit diesem Composer-Befehl:

composer require symfony/dom-crawler

Importieren Sie sie dann in der Datei index.php:

use Symfony\Component\DomCrawler\Crawler;

Step #2: HTML-Parsing

Um einen HTML-String zu parsen, erstellen Sie eine Crawler-Instanz mit der Methode html():

$crawler = new Crawler($html);

Zum Parsen einer Datei verwenden Sie file_get_contents() und erstellen die Crawler-Instanz:

$crawler = new Crawler(file_get_contents("./index.html"));

Die obigen Zeilen laden den HTML-Inhalt in das $crawler-Objekt, das einfache Methoden zum Traversieren und Extrahieren von Daten bereitstellt.

Step #3: Datenparsing

Extrahieren Sie die Hockey-Team-Daten mit der DomCrawler-Komponente:

// select all rows within the table
$rows = $crawler->filter("table tr.team");

// loop through each row to extract the data
$rows->each(function ($row, $i) {
  // extract data using CSS selectors
  $team_element = $row->filter(".name");
  $team = trim($team_element->text());

  $year_element = $row->filter(".year");
  $year = trim($year_element->text());

  $wins_element = $row->filter(".wins");
  $wins = trim($wins_element->text());

  $losses_element = $row->filter(".losses");
  $losses = trim($losses_element->text());

  $win_pct_element = $row->filter(".pct");
  $win_pct = trim($win_pct_element->text());

  $goals_for_element = $row->filter(".gf");
  $goals_for = trim($goals_for_element->text());

  $goals_against_element = $row->filter(".ga");
  $goals_against = trim($goals_against_element->text());

  $goal_diff_element = $row->filter(".diff");
  $goal_diff = trim($goal_diff_element->text());

  // create an array with the extracted team data
  $team_data = [
    "team" => $team,
    "year" => $year,
    "wins" => $wins,
    "losses" => $losses,
    "win_pct" => $win_pct,
    "goals_for" => $goals_for,
    "goals_against" => $goals_against,
    "goal_diff" => $goal_diff
  ];

  // print the scraped team data
  print_r($team_data);
  print ("\n");
});

Die verwendeten DomCrawler-Methoden sind:

• each(): Zum Iterieren über eine Liste ausgewählter Elemente.
• filter(): Wählt Elemente basierend auf CSS-Selektoren aus.
• text(): Extrahiert den Textinhalt der ausgewählten Elemente.

HTML-Parsing in PHP: Vergleichstabelle

Sie können die drei hier untersuchten Ansätze zum Parsen von HTML in PHP in der folgenden Übersichtstabelle vergleichen:

	\DOM\HTMLDocument	Simple HTML DOM Parser	Symfony’s DomCrawler
Typ	Native PHP-Komponente	Externe Bibliothek	Symfony-Komponente
GitHub Stars	—	880+	4,000+
XPath-Unterstützung	❌	✔️	✔️
CSS-Selektor-Unterstützung	❌	✔️	✔️
Lernkurve	Niedrig	Niedrig bis mittel	Mittel
Einfachheit der Nutzung	Mittel	Hoch	Hoch
API	Basis	Umfangreich	Umfangreich

Fazit

Auch wenn diese Lösungen funktionieren, sind sie nicht effektiv, wenn die Ziel-Webseiten für das Rendering auf JavaScript angewiesen sind. In solchen Fällen reichen einfache HTML-Parsing-Ansätze wie die oben genannten nicht aus. Stattdessen benötigen Sie einen voll ausgestatteten Scraping-Browser mit erweiterten HTML-Parsing-Funktionen, wie z. B. Scraping Browser.

Wenn Sie HTML-Parsing umgehen und sofort auf strukturierte Daten zugreifen möchten, entdecken Sie unsere einsatzbereiten Datensätze, die Hunderte von Websites abdecken!

Erstellen Sie noch heute ein Bright Data-Konto und beginnen Sie, unsere Daten- und Scraping-Lösungen mit einer kostenlosen Testversion zu testen!