Erfahren Sie, wie Sie HTML-Tabellen mit Golang auslesen

Web-Scraping ist eine Technik zum Extrahieren von Daten aus Websites und kann ein leistungsstarkes Werkzeug zum Sammeln von Informationen aus dem Internet sein. In diesem Artikel wird erläutert, wie man HTML-Tabellen mit Golang scrapt, einer beliebten Programmiersprache, die für ihre Einfachheit, ihre Unterstützung für Parallelität und ihre robuste Standardbibliothek bekannt ist.

HTML-Tabellen sind eine Art von Element in HTML (Hypertext Markup Language), das verwendet wird, um tabellarische Daten auf einer Webseite darzustellen. Eine HTML-Tabelle besteht aus Zeilen und Spalten von Zellen, die Text, Bilder oder andere HTML-Elemente enthalten. HTML-Tabellen werden mithilfe des table-Elements erstellt und sind wie folgt strukturiert: „<tr>“ (Tabellenzeile), „<td>“ (Tabellenzelle), „<th>“ (Tabellenkopf), „<caption>“, „<col>“, „<colgroup>“, „<tbody>“ (Tabellenkörper), „<thead>“ (Tabellenkopf) und „<tfoot>“ (Tabellenfuß). Sehen wir uns nun jedes einzelne genauer an:

• table-Element: Definiert den Anfang und das Ende einer HTML-Tabelle.
• tr-Element (Tabellenzeile): Definiert eine Zeile in einer HTML-Tabelle.
• td-Element (Tabellenzelle): Definiert eine Zelle in einer HTML-Tabelle.
• th-Element (Tabellenkopf): Definiert eine Kopfzelle in einer HTML-Tabelle. Kopfzellen werden standardmäßig fett und zentriert angezeigt und dienen zur Beschriftung der Zeilen oder Spalten der Tabelle.
• caption-Element: Definiert eine Beschriftung oder einen Titel für eine HTML-Tabelle. Die Beschriftung wird in der Regel über oder unter der Tabelle angezeigt.
• col- und colgroup-Elemente: Definieren die Eigenschaften der Spalten in einer HTML-Tabelle, wie z. B. die Breite oder die Ausrichtung.
• tbody-, thead- und tfoot-Elemente: Definieren jeweils den Hauptteil, den Kopf- und den Fußbereich einer HTML-Tabelle. Diese Elemente können verwendet werden, um Zeilen zu gruppieren und Stile oder Attribute auf einen bestimmten Abschnitt der Tabelle anzuwenden.

Um dieses Konzept besser zu verstehen, schauen wir uns an, wie eine HTML-Tabelle aussieht:

Auf den ersten Blick sieht es wie eine normale Tabelle aus, und wir können die Struktur mit den oben beschriebenen Elementen nicht erkennen. Das bedeutet nicht, dass sie nicht vorhanden sind, sondern dass der Browser dies bereits für uns parst. Um die HTML-Struktur sehen zu können, müssen Sie einen Schritt tiefer gehen und DevTools verwenden. Das geht so: Klicken Sie mit der rechten Maustaste auf die Seite, wählen Sie „Inspect“, klicken Sie auf das Werkzeug „Element auswählen“ und dann auf das Element (in diesem Fall die Tabelle), dessen HTML-Struktur Sie sehen möchten. Nach diesen Schritten sollten Sie etwa Folgendes sehen:

HTML-Tabellen werden häufig verwendet, um Daten in einem strukturierten, tabellarischen Format darzustellen, beispielsweise zur tabellarischen Aufbereitung von Ergebnissen oder zur Anzeige des Inhalts einer Datenbank. Sie sind auf einer Vielzahl von Websites zu finden und stellen ein wichtiges Element dar, das beim Scraping von Daten aus dem Web berücksichtigt werden muss.

Bevor wir mit dem Scraping beginnen, müssen wir unsere Golang-Umgebung einrichten und die erforderlichen Abhängigkeiten installieren. Stelle sicher, dass Golang auf deinem System installiert und konfiguriert ist, und erstelle dann ein neues Projektverzeichnis und initialisiere eine `go.mod`-Datei:

$ mkdir scraping-project

$ cd scraping-project

$ go mod init <NAME-OF-YOUR-PROJECT>

$ touch main.go

Als Nächstes müssen wir eine Bibliothek für HTTP-Anfragen und das Parsen von HTML installieren. Es stehen mehrere Optionen zur Verfügung, aber für diesen Artikel verwenden wir das `net/http`-Paket aus der Standardbibliothek und das Paket `golang.org/x/net/html` zum Parsen von HTML. Diese Pakete können mit dem folgenden Befehl installiert werden:

$ go get -u net/http golang.org/x/net/html

Nachdem unsere Umgebung nun eingerichtet ist, können wir mit der Erstellung unseres HTML-Tabellen-Scrapers mit Golang beginnen.

Nachdem wir unsere Umgebung eingerichtet haben, können wir mit der Erstellung eines Scrapers beginnen, um Daten aus einer HTML-Tabelle zu extrahieren. Der erste Schritt besteht darin, eine HTTP-Anfrage an die Webseite zu senden, die die HTML-Tabelle enthält, die wir scrapen möchten. Wir können die Funktion `http.Get` aus dem Paket `net/http` verwenden, um eine GET-Anfrage zu senden und den HTML-Inhalt abzurufen:

package main

import (

	"fmt"

	"io/ioutil"

	"log"

	"net/http"

)

func main() {

	resp, err := http.Get("https://www.w3schools.com/html/html_tables.asp")

	if err != nil {

		log.Fatal(err)

	}

	defer resp.Body.Close()

	// Read the response body and convert it to a string

	body, err := ioutil.ReadAll(resp.Body)

	if err != nil {

		log.Fatal(err)

	}

	html := string(body)

	fmt.Println(html)

}

Als Nächstes können wir die Funktion `goquery.NewDocumentFromReader` aus dem goquery-Paket verwenden, um den HTML-Inhalt zu parsen und die benötigten Daten zu extrahieren. Wie jedes andere Golang-Paket muss auch dieses zunächst wie folgt installiert werden:

$ go get github.com/PuerkitoBio/goquery

Fügen Sie anschließend den folgenden Code hinzu, der den HTML-Code der Seite parst:

doc, err := goquery.NewDocumentFromReader(resp.Body)

if err != nil {

    log.Fatal(err)

}

Da wir nun über einen Parser und einen Element-Extractor für unser HTML verfügen, können wir die Funktion `doc.Find()` des Goquery-Pakets nutzen, mit der wir die gesuchten Elemente finden können – in diesem Fall eine Tabelle. Wir können sie wie folgt verwenden:

doc.Find("table").Each(func(i int, sel * goquery.Selection) {

    // For sake of simplicity taking the first table of the page

    if i == 0 {

        // Looping through headers

        headers: = sel.Find("th").Each(func(_ int, sel * goquery.Selection) {

            if sel != nil {

                fmt.Print(sel.Text())

                fmt.Print(" ")

            }

        })

        fmt.Println()

        // Looping through cells

        sel.Find("td").Each(func(index int, sel * goquery.Selection) {

            if sel != nil {

                fmt.Print(sel.Text())

                fmt.Print(" ")

            }

            // Printing columns nicely

            if (index + 1) % headers.Size() == 0 {

                fmt.Println()

            }

        })

    }

})

Das war’s schon – Sie können die Tabelle nun mit Golang scrapen und sollten sie auf dem Bildschirm wie folgt sehen:

Wie Sie vielleicht bemerken, kann die Struktur ziemlich verwirrend und schwer lesbar sein. Die gute Nachricht ist, dass Sie das besser machen und die Daten übersichtlich in einem leicht lesbaren Tabellenformat anzeigen können. Dies ist eine perfekte Aufgabe für das tablewriter-Paket, das Sie wie folgt installieren können:

$ go get github.com/olekukonko/tablewriter

Nun müssen wir einige Anpassungen an unserem Code vornehmen, bevor wir unsere Informationen an „tablewriter“ übergeben, z. B. die Definition der Tabellenüberschriften und Strukturen sowie deren Speicherung in einem Array. Das sollte in etwa so aussehen:

package main

import (

	"log"

	"net/http"

	"os"

	"github.com/PuerkitoBio/goquery"

	"github.com/olekukonko/tablewriter"

)

type Company struct {

	Company string

	Contact string

	Country string

}

func main() {

	resp, err := http.Get("https://www.w3schools.com/html/html_tables.asp")

	if err != nil {

		log.Fatal(err)

	}

	defer resp.Body.Close()

	// Read the response body and convert it to a string

	doc, err := goquery.NewDocumentFromReader(resp.Body)

	if err != nil {

		log.Fatal(err)

	}

	var companies []Company

	doc.Find("table").Each(func(i int, sel *goquery.Selection) {

		if i == 0 {

			e := Company{}

			sel.Find("td").Each(func(index int, sel *goquery.Selection) {

				if index%3 == 0 {

					e.Company = sel.Text()

				}

				if index%3 == 1 {

					e.Contact = sel.Text()

				}

				if index%3 == 2 {

					e.Country = sel.Text()

				}

                        // Add the element to our array

				if index != 0 && (index+1)%3 == 0 {

					companies = append(companies, e)

				}

			})

		}

	})

	table := tablewriter.NewWriter(os.Stdout)

	// Setting our headers

	table.SetHeader([]string{"Company", "Contact", "Country"})

	for _, Company := range companies {

		s := []string{

			Company.Company,

			Company.Contact,

			Company.Country,

		}

		table.Append(s)

	}

	table.Render()

}

Sie sollten nun in der Lage sein, die Daten in diesem Format angezeigt zu sehen:

An dieser Stelle ist es Ihnen gelungen, einen Scraper in Golang zu erstellen, der eine Webseite scrapt und die Daten übersichtlich speichert und anzeigt. Sie können den Code auch so anpassen, dass er eine Tabelle von einer anderen Website scrapt. Bitte bedenke, dass es nicht bei allen Websites im Internet so einfach ist, Daten zu scrapen. Viele von ihnen haben hochgradige Schutzmaßnahmen implementiert, die das Scraping verhindern sollen, wie z. B. CAPTCHA und das Blockieren von IP-Adressen. Glücklicherweise gibt es jedoch Dienste von Drittanbietern wie WebScrapingAPI, die IP-Rotation und CAPTCHA-Umgehung anbieten, sodass du diese Ziele scrapen kannst.

Die bisher beschriebene Technik reicht zwar für einfache HTML-Tabellen aus, lässt sich jedoch auf verschiedene Weise verbessern.

Ein potenzielles Problem besteht darin, dass die Struktur der HTML-Tabelle nicht auf allen Webseiten einheitlich ist. Beispielsweise kann die Tabelle eine unterschiedliche Anzahl von Spalten aufweisen oder die Daten können in verschiedenen HTML-Elementen verschachtelt sein. Um diese Fälle zu bewältigen, können Sie fortgeschrittenere Techniken wie CSS-Selektoren oder XPath-Ausdrücke verwenden, um die Daten zu lokalisieren, die Sie extrahieren möchten.

Ein weiteres Problem besteht darin, dass Webseiten häufig AJAX oder andere clientseitige Technologien verwenden, um zusätzliche Daten in die Seite zu laden, nachdem diese im Browser geladen wurde. Das bedeutet, dass die HTML-Tabelle, die Sie scrapen, möglicherweise nicht alle benötigten Daten enthält. Um diese Art von Seiten zu scrapen, benötigen Sie möglicherweise ein Tool wie einen Headless-Browser, der JavaScript ausführen und die Seite genau wie ein normaler Webbrowser rendern kann. Eine gute Alternative dazu ist die Verwendung unseres Scrapers, der die Daten zurückgeben kann, nachdem JavaScript auf der Seite gerendert wurde. Mehr dazu erfahren Sie in unserer Dokumentation.

Schließlich ist es wichtig, die Leistung und Skalierbarkeit Ihres Scrapers zu berücksichtigen. Wenn Sie große Tabellen oder mehrere Seiten scrapen, müssen Sie möglicherweise Techniken wie Parallelität oder Ratenbegrenzung einsetzen, um sicherzustellen, dass Ihr Scraper die Last bewältigen kann.

Ich hoffe, Sie fanden diesen Leitfaden als guten Ausgangspunkt für das Scraping von HTML-Tabellen mit Golang. Wir haben den Prozess des Scrapings von Daten aus einer HTML-Tabelle unter Verwendung der Programmiersprache Go durchlaufen. Wir haben uns angesehen, wie man den HTML-Inhalt einer Webseite abruft, ihn auf dem Bildschirm ausgibt und in einem für das menschliche Auge lesbaren tabellarischen Format anzeigt. Außerdem haben wir einige der Herausforderungen besprochen, auf die Sie beim Scraping von HTML-Tabellen stoßen können, darunter inkonsistente Tabellenstrukturen, clientseitiges Laden von Daten sowie Probleme mit der Leistung und Skalierbarkeit.

Zwar ist es möglich, mit den in diesem Artikel beschriebenen Techniken einen eigenen Scraper zu erstellen, doch ist es oft effizienter und zuverlässiger, einen professionellen Scraping-Dienst zu nutzen. Diese Dienste verfügen über die Infrastruktur, das Fachwissen und die Sicherheitsmaßnahmen, um große Datenmengen und komplexe Scraping-Aufgaben zu bewältigen, und können Daten oft in einem strukturierteren und benutzerfreundlicheren Format wie CSV oder JSON bereitstellen.

Zusammenfassend lässt sich sagen, dass das Scraping von HTML-Tabellen eine nützliche Methode sein kann, um Daten aus dem Web zu extrahieren, aber es ist wichtig, die Vor- und Nachteile zwischen der Entwicklung eines eigenen Scrapers und der Nutzung eines professionellen Dienstes sorgfältig abzuwägen.