Scrapper-Konkurrent

Programmziel

Greifen Sie gleichzeitig auf Webseiten zu, um den Titel jeder Seite zu extrahieren und diese Titel im Terminal anzuzeigen. Dies geschieht mithilfe der Parallelität in Go, die Ihnen den gleichzeitigen Zugriff auf mehrere Seiten ermöglicht und so Zeit spart.

Erläuterung des Kodex

Verwendete Pakete

import (
    "fmt"
    "net/http"
    "sync"
    "github.com/PuerkitoBio/goquery"
)

fetchTitle-Funktion

Diese Rolle ist verantwortlich für:

• Zugriff auf eine Webseite (URL)
• Seitentitel extrahieren
• Übertragen Sie das Ergebnis auf einen Kanal

func fetchTitle(url string, wg *sync.WaitGroup, results chan<- string) {
    defer wg.Done() // Marca a goroutine como concluída no WaitGroup

Funktionsparameter:

• URL-Zeichenfolge: Stellt die Adresse der Webseite (URL) dar, auf die wir zugreifen, um den Titel zu erhalten
• wg *sync.WaitGroup: Zeiger auf eine WaitGroup, die wir verwenden, um den Abschluss aller gleichzeitig laufenden Aufgaben (Goroutinen) zu synchronisieren. Das * zeigt an, dass wir eine „Adresse“ an WaitGroup übergeben und keine Kopie davon.
• Ergebnisse chan<- string: Dies ist ein Einwegkanal, der es Ihnen ermöglicht, Strings an einen anderen Teil des Programms zu senden. Es wird verwendet, um Ergebnisse (Titel oder Fehlermeldungen) an die Hauptfunktion zu übergeben

Die Zeile „defer wg.Done()“ weist das Programm an, diese Aufgabe (Goroutine) als abgeschlossen zu markieren, wenn die fetchTitle-Funktion beendet ist. Dies ist wichtig, damit main weiß, wann alle Aufgaben erledigt sind.

HTTP-Anfrage

req, err := http.Get(url)
if err != nil {
Ergebnisse <- fmt.Sprintf("Fehler beim Zugriff auf %s: %v", url, err)
zurück
}
defer req.Body.Close()

• http.Get(url): Diese Zeile stellt eine HTTP GET-Anfrage an die URL. Das bedeutet, dass wir auf die Seite zugreifen und den Server nach ihrem Inhalt fragen.
• err != nil: Hier prüfen wir, ob beim Zugriff auf die Seite ein Fehler aufgetreten ist (z. B. wenn die Seite nicht existiert oder der Server nicht antwortet). Im Fehlerfall senden wir eine Nachricht an den Ergebniskanal und beenden die Funktion mit return.
• defer req.Body.Close(): Dies stellt sicher, dass wir, nachdem wir mit der Verwendung des Seiteninhalts fertig sind, den für die Speicherung zugewiesenen Speicher freigeben.

Statusprüfung

wenn req.StatusCode != 200 {
Ergebnisse <- fmt.Sprintf("Fehler beim Zugriff auf %s: Status %d %s", url, req.StatusCode, req.Status)
zurück
}

• req.StatusCode != 200: Wir prüfen, ob der Server mit dem Code 200 OK geantwortet hat (zeigt Erfolg an). Wenn es nicht 200 ist, bedeutet das, dass die Seite nicht richtig geladen wurde. Anschließend senden wir eine Fehlermeldung an den Ergebniskanal und beenden die Funktion.

Laden und Suchen von Titeln

doc, err := goquery.NewDocumentFromReader(req.Body)
if err != nil {
Ergebnisse <- fmt.Sprintf("Fehler beim Laden des Dokuments von %s: %v", url, err)
zurück
}
title := doc.Find("title").Text()
Ergebnisse <- fmt.Sprintf("Titel von %s: %s", URL, Titel)
}

• goquery.NewDocumentFromReader(req.Body): Wir laden den HTML-Inhalt der Seite (bereitgestellt durch req.Body) in goquery, wodurch Sie durch bestimmte Teile des HTML navigieren und diese durchsuchen können.
• doc.Find("title").Text(): Wir suchen nach dem Tag