Finden Sie heraus, wie man HTML-Tabellen mit Golang scrapen kann

Andrei Ogiolan am 24. April 2023

Einführung

Web Scraping ist eine Technik zum Extrahieren von Daten aus Websites und kann ein leistungsfähiges Werkzeug zum Sammeln von Informationen aus dem Internet sein. Dieser Artikel befasst sich mit dem Scrapen von HTML-Tabellen mit Golang, einer beliebten Programmiersprache, die für ihre Einfachheit, Gleichzeitigkeitsunterstützung und robuste Standardbibliothek bekannt ist.

Was sind HTML-Tabellen?

HTML tables are a type of element in HTML (Hypertext Markup Language) that is used to represent tabular data on a web page. An HTML table consists of rows and columns of cells containing text, images, or other HTML elements. HTML tables are created using the table element, and are structured using the ‘<tr>’ (table row),‘<td>’ (table cell), ‘<th>’ (table header), ‘<caption>’, ‘<col>’, ‘<colgroup>’, ‘<tbody>’ (table body), ‘<thead>’ (table head) and ‘<tfoot>’ (table foot) elements. Now let’s go through each one and get into more detail:

• table-Element: Definiert den Anfang und das Ende einer HTML-Tabelle.
• tr (Tabellenzeile) Element: Definiert eine Zeile in einer HTML-Tabelle.
• td (Tabellenzelle) Element: Definiert eine Zelle in einer HTML-Tabelle.
• th (Tabellenkopf) Element: Definiert eine Kopfzelle in einer HTML-Tabelle. Kopfzellen werden standardmäßig fett und zentriert dargestellt und dienen zur Kennzeichnung der Zeilen oder Spalten der Tabelle.
• Beschriftungselement: Legt eine Beschriftung oder einen Titel für eine HTML-Tabelle fest. Die Beschriftung wird normalerweise über oder unter der Tabelle angezeigt.
• col und colgroup Elemente: Definieren Sie die Eigenschaften der Spalten in einer HTML-Tabelle, z. B. die Breite oder Ausrichtung.
• tbody-, thead- und tfoot-Elemente: Definieren die Abschnitte body, head bzw. foot 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, sehen wir uns an, wie eine HTML-Tabelle aussieht:

Auf den ersten Blick scheint es eine normale Tabelle zu sein, und wir können die Struktur mit den oben beschriebenen Elementen nicht sehen. Das bedeutet nicht, dass sie nicht vorhanden sind, sondern dass der Browser sie bereits für uns geparst hat. Um die HTML-Struktur sehen zu können, müssen Sie einen Schritt tiefer gehen und die Entwicklungswerkzeuge verwenden. Klicken Sie dazu mit der rechten Maustaste auf die Seite, klicken Sie auf "Überprüfen", klicken Sie auf "Element auswählen" und klicken Sie auf das Element (in diesem Fall eine Tabelle), für das Sie die HTML-Struktur anzeigen möchten. Wenn Sie diese Schritte befolgt haben, sollten Sie etwas wie dieses sehen:

HTML-Tabellen werden in der Regel verwendet, um Daten in einem strukturierten, tabellarischen Format darzustellen, z. B. für die tabellarische Auflistung von Ergebnissen oder die Anzeige des Inhalts einer Datenbank. Sie sind auf einer Vielzahl von Websites zu finden und sind ein wichtiges Element, das beim Scraping von Daten aus dem Web zu berücksichtigen ist.

Einrichten

Bevor wir mit dem Scraping beginnen, müssen wir unsere Golang-Umgebung einrichten und die notwendigen Abhängigkeiten installieren. Stellen Sie sicher, dass Golang auf Ihrem System installiert und konfiguriert ist. Erstellen Sie dann ein neues Projektverzeichnis und initialisieren Sie eine Datei "go.mod":

$ mkdir scraping-project

$ cd scraping-project

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

$ touch main.go

Als Nächstes müssen wir eine Bibliothek installieren, die HTTP-Anfragen stellt und HTML analysiert. Es gibt mehrere Optionen, aber für diesen Artikel werden wir das Paket `net/http` aus der Standardbibliothek und das Paket golang.org/x/net/html für das Parsen von HTML verwenden. Diese Pakete können durch Ausführen des folgenden Befehls installiert werden:

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

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

Fangen wir an zu kratzen

Nachdem wir nun unsere Umgebung eingerichtet haben, können wir mit der Erstellung eines Scrapers beginnen, der Daten aus einer HTML-Tabelle extrahiert. Der erste Schritt besteht darin, eine HTTP-Anfrage an die Webseite zu senden, die die HTML-Tabelle enthält, die wir auslesen wollen. 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 analysieren und die benötigten Daten zu extrahieren. Wie jedes andere Golang-Paket müssen Sie es zuerst wie folgt installieren:

$ go get github.com/PuerkitoBio/goquery 

Fügen Sie dann den folgenden Code ein, der den HTML-Code der Seite analysiert:

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

if err != nil {

    log.Fatal(err)

}

Jetzt, da wir einen Parser und einen Element-Extraktor für unser HTML haben, können wir die Funktionalität des Goquery-Pakets `doc.Find()` nutzen, die es uns ermöglicht, die spezifischen Elemente zu finden, nach denen wir suchen, 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, jetzt können Sie die Tabelle mit Golang scrapen und sollten sie so auf dem Bildschirm sehen können:

Wie Sie vielleicht feststellen, kann die Struktur ziemlich verwirrend und schwer zu lesen sein. Die gute Nachricht ist, dass Sie es besser machen können und die Daten in einem schönen, leicht lesbaren Tabellenformat darstellen 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 noch einige Anpassungen an unserem Code vornehmen, bevor wir unsere Informationen an einen Tablewriter weitergeben können, wie z.B. die Definition der Tabellenköpfe, Strukturen und deren Speicherung in einem Array. Es 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 die Daten in diesem Format sehen können:

Jetzt haben Sie es geschafft, einen Scraper in Golang zu erstellen, der eine Webseite ausliest und die Daten speichert und anschaulich anzeigt. Sie können den Code auch ändern, um eine Tabelle von einer anderen Website zu scrapen. Bitte bedenken Sie, dass nicht alle Webseiten im Internet so einfach zu scrapen sind. Viele von ihnen haben hochgradige Schutzmaßnahmen eingeführt, um Scraping zu verhindern, wie CAPTCHA und das Blockieren von IP-Adressen, aber glücklicherweise gibt es Dienste von Drittanbietern wie WebScrapingAPI, die IP-Rotation und CAPTCHA-Umgehung anbieten und es Ihnen ermöglichen, diese Ziele zu scrapen.

Tiefer tauchen

Obwohl die bisher beschriebene Technik für einfache HTML-Tabellen ausreichend ist, gibt es mehrere Möglichkeiten, sie zu verbessern.

Ein mögliches Problem besteht darin, dass die HTML-Tabellenstruktur nicht auf allen Webseiten einheitlich ist. Zum Beispiel kann die Tabelle eine unterschiedliche Anzahl von Spalten haben oder die Daten können in verschiedenen HTML-Elementen verschachtelt sein. In diesen Fällen können Sie erweiterte Techniken wie CSS-Selektoren oder XPath-Ausdrücke verwenden, um die zu extrahierenden Daten zu finden.

Ein weiteres Problem ist, dass Webseiten oft AJAX oder andere clientseitige Technologien verwenden, um zusätzliche Daten in die Seite zu laden, nachdem sie im Browser geladen wurde. Das bedeutet, dass die HTML-Tabelle, die Sie auslesen wollen, möglicherweise nicht alle benötigten Daten enthält. Um diese Art von Seiten zu scrapen, müssen Sie möglicherweise ein Tool wie einen Headless Browser verwenden, der JavaScript ausführen und die Seite wie ein normaler Webbrowser darstellen kann. Eine gute Alternative dazu ist unser Scraper, der die Daten zurückgeben kann, nachdem JavaScript auf der Seite gerendert wurde. Mehr darüber erfahren Sie in unseren Dokumenten.

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

Zusammenfassung

Ich hoffe, Sie haben diese Ressource als einen guten Ausgangspunkt für das Scraping von HTML-Tabellen mit Golang gefunden. Wir sind durch den Prozess des Scrapens von Daten aus einer HTML-Tabelle mit der Programmiersprache Go gegangen. Wir haben uns angesehen, wie man den HTML-Inhalt einer Webseite abruft, ihn auf dem Bildschirm ausgibt und ihn in einem für das menschliche Auge lesbaren Tabellenformat darstellt. Wir haben auch einige der Herausforderungen besprochen, auf die man beim Scraping von HTML-Tabellen stoßen kann, darunter inkonsistente Tabellenstrukturen, clientseitiges Laden von Daten sowie Leistungs- und Skalierbarkeitsprobleme.

Es ist zwar 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 in Anspruch zu nehmen. 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 besser strukturierten und bequemeren Format wie CSV oder JSON bereitstellen.

Zusammenfassend lässt sich sagen, dass das Scrapen von HTML-Tabellen eine nützliche Methode sein kann, um Daten aus dem Internet zu extrahieren, aber es ist wichtig, sorgfältig abzuwägen, ob man einen eigenen Scraper entwickelt oder einen professionellen Dienst in Anspruch nimmt.