Wie man HTML-Tabellen in Golang mit Colly scrappt: End-to-End-Anleitung

Tabellarische Daten tauchen überall auf: auf Preisseiten, in Sportstatistiken, in Finanzberichten, in öffentlichen Datensätzen, die nie eine richtige API bekommen haben. Wenn Ihre Pipeline mit <table> Markup beginnt und in einem Warehouse oder einem Notebook endet, benötigen Sie eine zuverlässige Methode, um diese Daten zu extrahieren. Go kompiliert zu einer einzigen Binärdatei, bewältigt Parallelität gut und bietet vorhersehbare Leistung bei Skalierung. Zu wissen, wie man HTML-Tabellen in Golang scrapt, bedeutet, diese Pipeline als einen eigenständigen Dienst bereitzustellen, ohne dass eine Python-Laufzeitumgebung erforderlich ist.

Wählen Sie die falsche Bibliothek, und Sie werden mehr Zeit damit verbringen, mit der API zu kämpfen, als Zeilen zu parsen. Hier ist eine kurze Entscheidungsmatrix.

Der seit langem laufende Stack-Overflow-Thread zum Parsen von HTML-Tabellen in Go rangiert immer noch bei dieser Suchanfrage ganz oben, und die Top-Antworten verweisen auf goquery und x/net/html. Beide sind solide. Colly bündelt sie mit Crawler-Funktionen, die du nutzen möchtest, sobald du mehr als eine Seite abfragen musst.

Erstellen Sie ein Modul und laden Sie Colly v2 herunter:

mkdir html-golang-scraper && cd html-golang-scraper
go mod init github.com/yourname/html-golang-scraper
go get github.com/gocolly/colly/v2

Beachten Sie das /v2 Suffix. Der ursprüngliche github.com/gocolly/colly Import ist die v1-Zeile, und die meisten älteren Tutorials beziehen sich noch darauf. Neue Projekte sollten v2 verwenden, um von aktuellen Fehlerbehebungen und der Unterstützung für Go-Module zu profitieren.

Fügen Sie eine Plausibilitätsprüfung hinzu main.go:

package main

import "fmt"

func main() {
    fmt.Println("scraper booted")
}

Führen Sie go run main.go. Wenn Sie scraper booted, ist die Toolchain eingerichtet und Colly ist go.sum. Von hier aus ersetzt jedes Snippet den Hauptteil von main oder fügt einen Typ auf Paketebene hinzu.

Bevor Sie Go-Code schreiben, öffnen Sie die Zielseite in Ihrem Browser und wählen Sie die gewünschte Tabelle aus. Wir verwenden die DataTables-Demo unter https://datatables.net/examples/styling/display.html als Beispiel. Klicken Sie mit der rechten Maustaste auf die Tabelle, wählen Sie „Inspect“ und überprüfen Sie drei Dinge:

1. Der Selektor. Suchen Sie nach einem stabilen id (die Demo verwendet #example) oder eindeutige Klasse. Vermeiden Sie table allein, da Seiten das Layout oft in verschachtelte Tabellenelemente einbinden.
2. Kopfzeilenstruktur. Überprüfen Sie <thead> und <tbody> getrennt sind. Ist dies nicht der Fall, überspringen Sie die erste Zeile im Code.
3. Statisch vs. dynamisch. Deaktivieren Sie JavaScript und laden Sie die Seite neu. Wenn die Zeilen verschwinden, wird die Tabelle clientseitig gerendert. Auf diesen Fall gehen wir später ein.

Fünf Minuten in DevTools sind besser als eine Stunde Debugging eines leeren Ausschnitts. Unser CSS-Selektor-Spickzettel listet die Muster auf, die Tabellenscraper am häufigsten verwenden.

Collys Collector ist das zentrale Objekt: Es sendet Anfragen und löst Lebenszyklus-Callbacks aus. Betrachte die vier unten aufgeführten Callbacks als Boilerplate, das du in jedes Projekt kopieren kannst.

package main

import (
    "fmt"
    "log"

    "github.com/gocolly/colly/v2"
)

func main() {
    c := colly.NewCollector()

    c.OnRequest(func(r *colly.Request) {
        fmt.Println("visiting:", r.URL.String())
    })

    c.OnResponse(func(r *colly.Response) {
        fmt.Println("status:", r.StatusCode)
    })

    c.OnError(func(r *colly.Response, err error) {
        log.Printf("failed %s: %v", r.Request.URL, err)
    })

    if err := c.Visit("https://datatables.net/examples/styling/display.html"); err != nil {
        log.Fatal(err)
    }
}

OnRequest wird vor jedem Netzwerkaufruf ausgelöst OnResponse wenn der Server antwortet, und OnError fängt Nicht-2xx-Antworten und Transportfehler ab – genau hier scheitern die meisten Produktions-Scraper stillschweigend. Als Nächstes fügen wir OnHTML als Nächstes den Callback hinzu, in dem die eigentliche Tabellenanalyse stattfindet.

In der DataTables-Demo liefert die Ausführung von document.querySelectorAll('table') in der Browserkonsole mehr als eine Übereinstimmung zurück, da auch an anderer Stelle im Layout-Markup Tabellenelemente verwendet werden. Würde man table allein würde die falschen Zeilen scrapen, daher sollten Sie Selektoren immer in der Konsole validieren, bevor Sie Go schreiben.

Der zuverlässige Selektor lautet hier table#example > tbody. Er grenzt die Auswahl auf eine einzige Tabelle ein, indem id und überspringt den <thead> Block, sodass du die Kopfzeile nicht manuell entfernen musst. Das DataTables-Widget fügt zudem gespiegelte Kopf- und Fußzeilen ein; durch die Einschränkung auf > tbody hält diese aus Ihrem Datensatz heraus.

c.OnHTML("table#example > tbody", func(h *colly.HTMLElement) {
    // row loop goes here
})

OnHTML gleicht Elemente über den CSS-Selektor ab und ruft den Handler für jede Übereinstimmung auf. Ersetzen Sie #example durch das, was DevTools Ihnen anzeigt. Wenn Sie CSS und XPath gegeneinander abwägen, behandelt unser Vergleich von XPath- und CSS-Selektoren die Vor- und Nachteile.

Innerhalb des OnHTML Handler h.ForEach("tr", ...) und extrahieren Sie jede Zelle mit el.ChildText("td:nth-child(N)"):

c.OnHTML("table#example > tbody", func(h *colly.HTMLElement) {
    h.ForEach("tr", func(_ int, el *colly.HTMLElement) {
        row := tableData{
            Name:      strings.TrimSpace(el.ChildText("td:nth-child(1)")),
            Position:  strings.TrimSpace(el.ChildText("td:nth-child(2)")),
            Office:    strings.TrimSpace(el.ChildText("td:nth-child(3)")),
            Age:       strings.TrimSpace(el.ChildText("td:nth-child(4)")),
            StartDate: strings.TrimSpace(el.ChildText("td:nth-child(5)")),
            Salary:    strings.TrimSpace(el.ChildText("td:nth-child(6)")),
        }
        employeeData = append(employeeData, row)
    })
})

HTML-Tabellenzellen enthalten fast nie stabile class oder id , daher nth-child(n) ist der sauberste Weg, Spalten zu adressieren. Wenn die Seite die Spalten neu anordnet, ändern Sie eine Zahl pro Feld, anstatt Ihren Parser neu zu schreiben.

Ein robusteres Muster ist es, <thead> zu lesen, einen map[string]int Index aus Spaltennamen zu erstellen und Zellen anhand der Kopfzeilenbezeichnung nachzuschlagen. Der zusätzliche Code lohnt sich, wenn die Quelle die Spalten neu anordnet. Umschließen Sie Text immer mit strings.TrimSpace und analysieren Sie Währungs- oder Datumsspalten mit strconv und time.Parse vor der Serialisierung, damit die Verbraucher keine Zeichenfolgen wie "$320,800" erhalten, wenn sie Zahlen erwartet haben.

Definieren Sie den Zeilentyp auf Paketebene, damit JSON-Tags mit ihm übertragen werden:

type tableData struct {
    Name      string `json:"name"`
    Position  string `json:"position"`
    Office    string `json:"office"`
    Age       string `json:"age"`
    StartDate string `json:"start_date"`
    Salary    string `json:"salary"`
}

var employeeData []tableData

Warum eine typisierte Struktur statt map[string]string? Drei Gründe:

1. Stabile JSON-Schlüssel. Struct-Tags steuern Feldnamen und Groß-/Kleinschreibung in der Ausgabe, anstatt das zu übernehmen, was Sie beim Parsen eingegeben haben.
2. Sicherheit zur Kompilierungszeit. Tippfehler führen zu einem Fehlschlag beim Erstellen und nicht stillschweigend zu leeren Werten, die Ihnen in der Staging-Umgebung Probleme bereiten.
3. Einfache Refactorings. Wenn Sie Zahlen und Datumsangaben parsen, tauschen Sie Age zu int oder StartDate zu time.Time , und der Compiler führt Sie durch jede Korrektur.

Fügen Sie jedes analysierte Element row innerhalb employeeData innerhalb der Zeilenschleife an. Der Slice ist bereit für das Marshaling, sobald c.Visit zurückgegeben wird.

JSON ist der richtige Standard für APIs und nachgelagerte Dienste; CSV ist das, was BI-Tools und Analysten benötigen. Beide Formate zu exportieren erfordert etwa zehn zusätzliche Zeilen.

import (
    "encoding/csv"
    "encoding/json"
    "log"
    "os"
)

content, err := json.MarshalIndent(employeeData, "", "  ")
if err != nil {
    log.Fatal(err)
}
if err := os.WriteFile("employees.json", content, 0644); err != nil {
    log.Fatal(err)
}

f, err := os.Create("employees.csv")
if err != nil {
    log.Fatal(err)
}
defer f.Close()
w := csv.NewWriter(f)
defer w.Flush()
_ = w.Write([]string{"Name", "Position", "Office", "Age", "StartDate", "Salary"})
for _, r := range employeeData {
    _ = w.Write([]string{r.Name, r.Position, r.Office, r.Age, r.StartDate, r.Salary})
}

Beide Dateien landen in Ihrem Arbeitsverzeichnis. Beide Formate für nachgelagerte Pipelines offen zu halten, ist eine der nützlichsten Gewohnheiten, wenn man lernt, wie man HTML-Tabellen in Golang scrapt.

Die meisten Seiten mit Tabellen passen nicht auf einen Bildschirm. Zwei Muster decken die meisten Fälle ab.

Muster A: Dem nächsten Link folgen.

c.OnHTML("a.next", func(e *colly.HTMLElement) {
    if next := e.Request.AbsoluteURL(e.Attr("href")); next != "" {
        _ = e.Request.Visit(next)
    }
})

Muster B: Durchlaufen Sie eine URL-Vorlage mit Seitennummern.

for page := 1; page <= 20; page++ {
    _ = c.Visit(fmt.Sprintf("https://example.com/data?page=%d", page))
}

Kombiniere eines der beiden Muster mit colly.LimitRule , um Anfragen zu drosseln und eine Überlastung des Ursprungsservers zu vermeiden:

_ = c.Limit(&colly.LimitRule{
    DomainGlob:  "*example.com*",
    Parallelism: 2,
    RandomDelay: 1500 * time.Millisecond,
})

Das sorgt für einen höflichen Datenverkehr und senkt die Wahrscheinlichkeit eines 429-Fehlers auf Seite sieben.

Sobald die Anzahl der Anfragen einige Hundert übersteigt, greifen grundlegende Anti-Bot-Maßnahmen. Eine herstellerunabhängige Checkliste für das Skalieren von HTML-Tabellen-Scraping in Golang:

1. Wechseln Sie die User-Agents. extensions.RandomUserAgent(c) Füge bei jeder Anfrage einen neuen User-Agent ein.
2. Drosseln. colly.LimitRule mit RandomDelay lässt den Datenverkehr weniger roboterhaft erscheinen.
3. Bei vorübergehenden Fehlern erneut versuchen. Überprüfe OnError, überprüfe den Statuscode und rufe r.Request.Retry() bei 5xx- und 429-Antworten auf.
4. Wechseln Sie die Proxys. Übergeben Sie eine Liste an proxy.RoundRobinProxySwitcher und fügen Sie sie über c.SetProxyFunc(...). IP-Pools für Privathaushalte fügen sich besser ein als Rechenzentrumsbereiche.
5. Optimieren Sie den Transport. Eine benutzerdefinierte http.Transport mit einem Timeout von 60–90 Sekunden DialContext Timeout und optimiertem MaxIdleConns verringert die Verbindungsfluktuation bei unzuverlässigen Zielen.
6. Lagern Sie es aus, wenn es keinen Spaß mehr macht. Eine verwaltete Scraping-API ist effizienter als Entwicklungsarbeit, sobald CAPTCHAs und Fingerprinting zum Projekt werden. Unser Leitfaden mit Tipps, wie Sie beim Web-Scraping nicht blockiert werden, geht aus einer sprachunabhängigen Perspektive näher darauf ein.

Öffne die Seite mit deaktiviertem JavaScript. Wenn <tbody> in der rohen HTML-Antwort leer ist, werden die Zeilen durch clientseitiges JS eingefügt und Colly allein sieht sie nicht. Zwei Optionen:

1. Headless-Browser im Prozess. chromedp steuert eine echte Chrome-Instanz von Go aus an, wartet auf das Rendern der Tabelle und übergibt dir das gerenderte DOM.
2. Headless-Rendering-API. Lagern Sie die Browserverarbeitung an einen verwalteten Endpunkt aus, der HTML nach der JS-Verarbeitung zurückgibt, und leiten Sie dieses HTML dann wie gewohnt an Colly oder goquery weiter.

Die minimal lauffähige Version, bereit für ein neues Modul:

package main

import (
    "encoding/csv"
    "encoding/json"
    "fmt"
    "log"
    "os"
    "strings"

    "github.com/gocolly/colly/v2"
)

type tableData struct {
    Name, Position, Office, Age, StartDate, Salary string
}

func main() {
    var rows []tableData
    c := colly.NewCollector()

    c.OnHTML("table#example > tbody", func(h *colly.HTMLElement) {
        h.ForEach("tr", func(_ int, el *colly.HTMLElement) {
            rows = append(rows, tableData{
                Name:      strings.TrimSpace(el.ChildText("td:nth-child(1)")),
                Position:  strings.TrimSpace(el.ChildText("td:nth-child(2)")),
                Office:    strings.TrimSpace(el.ChildText("td:nth-child(3)")),
                Age:       strings.TrimSpace(el.ChildText("td:nth-child(4)")),
                StartDate: strings.TrimSpace(el.ChildText("td:nth-child(5)")),
                Salary:    strings.TrimSpace(el.ChildText("td:nth-child(6)")),
            })
        })
    })

    if err := c.Visit("https://datatables.net/examples/styling/display.html"); err != nil {
        log.Fatal(err)
    }

    j, _ := json.MarshalIndent(rows, "", "  ")
    _ = os.WriteFile("employees.json", j, 0644)

    f, _ := os.Create("employees.csv")
    defer f.Close()
    w := csv.NewWriter(f)
    defer w.Flush()
    _ = w.Write([]string{"Name", "Position", "Office", "Age", "StartDate", "Salary"})
    for _, r := range rows {
        _ = w.Write([]string{r.Name, r.Position, r.Office, r.Age, r.StartDate, r.Salary})
    }
    fmt.Println("scraped:", len(rows), "rows")
}

Zum Zeitpunkt der Erstellung getestet mit Go 1.22 und Colly v2. Fügen Sie die Ratenbegrenzung, den Proxy-Switcher und die User-Agent-Erweiterung hinzu, sobald Sie über die Demo-URL hinausgehen. Unser umfassenderer Leitfaden zum Web-Scraping mit Go behandelt die Toolchain.

Sie verfügen nun über das vollständige Muster zum Scrapen von HTML-Tabellen in Golang: Wählen Sie die richtige Bibliothek, legen Sie einen präzisen Selektor fest, modellieren Sie Zeilen als Struktur, exportieren Sie in JSON und CSV und greifen Sie nur dann auf chromedp oder Proxy-Rotation zurück, wenn die Seite dies erfordert.

Der logische nächste Schritt ist Parallelität. Schalten Sie Ihren Collector mit c.Async = true, löse Parallelism in Ihrem colly.LimitRuleund rufen Sie c.Wait() nach dem letzten c.Visit() auf, um die Verarbeitung auf viele Seiten zu verteilen.

Wenn das Ziel aggressiv blockiert und Sie lieber die Pipeline bereitstellen möchten, anstatt die Proxy-Infrastruktur zu warten, gibt unsere Scraper-API bei WebScrapingAPI gerenderten HTML-Code hinter einem Endpunkt zurück, sodass der Colly-Parsing-Code, den Sie heute geschrieben haben, weiterhin funktioniert.

• Wählen Sie das richtige Tool für die jeweilige Aufgabe. Colly v2 ist die erste Wahl für Crawling und Callbacks, goquery ist die leichteste Lösung, wenn Sie bereits HTML im Speicher haben, und golang.org/x/net/html ist der Low-Level-Fallback.
• Schränken Sie Ihren Selektor immer auf ein <tbody>. Ein reiner table Selektor erfasst in der Regel Layout-Markup; table#id > tbody ist die sichere Standardeinstellung.
• Modellieren Sie Zeilen als typisierte Struktur, nicht als Map. Struktur-Tags liefern Ihnen stabile JSON-Schlüssel und ermöglichen es dem Compiler, Tippfehler vor der Produktion zu erkennen.
• Liefern Sie JSON und CSV gemeinsam aus. Beide Formate erfordern etwa zehn zusätzliche Zeilen und ermöglichen sowohl API- als auch Analysten-Workflows.
• Planen Sie frühzeitig für Ausfälle. Wechseln Sie User-Agents, drosseln Sie die Anfragerate, versuchen Sie es bei 5xx- und 429-Fehlern erneut und greifen Sie auf Proxys oder eine verwaltete API zurück, sobald das Zielsystem zurückweist.

Nein, Colly ist nicht erforderlich. Verwenden Sie goquery, wenn Sie den HTML-Code bereits haben und lediglich eine CSS-Auswahl im jQuery-Stil benötigen *goquery.Document. Greifen Sie auf golang.org/x/net/html , wenn du Kontrolle auf Token-Ebene benötigst. Entscheide dich für Colly, wenn Crawling, Drosselung, Cookies und Proxy-Hooks dich andernfalls zwingen würden, diese Funktionen neu zu entwickeln.

Verwende das encoding/csv . Öffne eine Datei mit os.Create, umschließen Sie sie mit csv.NewWriter, schreiben Sie einen Header mit w.Write([]string{...}), durchlaufe dann deine Zeilenstrukturen und rufe w.Write pro Zeile auf. Immer defer w.Flush() und defer f.Close() damit die Datei auf der Festplatte gespeichert wird.

Zwei Muster decken die meisten Fälle ab. Wenn die Seite einen „Weiter“-Link anzeigt, registriere einen OnHTML Handler für ihren Selektor und rufen Sie e.Request.Visit(e.Request.AbsoluteURL(e.Attr("href"))). Wenn Seiten einem numerischen Abfrageparameter folgen, baue die URL mit fmt.Sprintf und durchlaufe c.Visit. Kombinieren Sie eines der beiden Muster mit colly.LimitRule und RandomDelay , damit parallele Abrufe höflich bleiben.

Rendern Sie die Seite zuerst und parsen Sie sie dann. chromedp steuert ein echtes Headless Chrome von Go aus an, ermöglicht es dir, WaitVisible auf den Zielselektor anwenden und gibt das Post-JS-DOM zurück, das du in goquery einspeisen kannst. Wenn du die Browseroperationen lieber überspringen möchtest, sende die URL an eine Headless-Rendering-API und parse das zurückgegebene HTML mit Colly, als wäre es eine beliebige statische Seite.

Stufen Sie Ihre Abwehrmaßnahmen. Randomisieren Sie User-Agents mit extensions.RandomUserAgent, drosseln Sie die Anrufe über colly.LimitRule mit RandomDelay, wiederholen Sie vorübergehende 5xx- und 429-Antworten innerhalb von OnErrorund wechseln Sie die Residential-Proxys über proxy.RoundRobinProxySwitcher. Speichern Sie Antworten während der Entwicklung im Cache, damit Sie nicht erneut gegen den Live-Ursprung testen. Wenn CAPTCHAs zur Routine werden, lagern Sie die Anforderungsschicht an einen verwalteten Scraping-Endpunkt aus.