Introduction
Le web scraping est une technique permettant d'extraire des données de sites web et peut constituer un outil puissant pour collecter des informations sur Internet. Cet article explique comment extraire des tableaux HTML à l'aide de Golang, un langage de programmation populaire réputé pour sa simplicité, sa prise en charge de la concurrence et sa bibliothèque standard robuste.
Que sont les tableaux HTML ?
Les tableaux HTML sont un type d'élément en HTML (Hypertext Markup Language) utilisé pour représenter des données sous forme de tableau sur une page web. Un tableau HTML se compose de lignes et de colonnes de cellules contenant du texte, des images ou d'autres éléments HTML. Les tableaux HTML sont créés à l'aide de l'élément tr et sont structurés à l'aide des balises « <tr> » (ligne de tableau), «<td> (cellule de tableau), « <th> » (en-tête de tableau), « <caption> », « <col> », « <colgroup> », « <tbody> » (corps du tableau), « <thead> » (tête du tableau) et « <tfoot> » (pied du tableau). Passons maintenant en revue chacun d'entre eux pour entrer dans les détails :
- Élément table : définit le début et la fin d’un tableau HTML.
- Élément tr (ligne de tableau) : définit une ligne dans un tableau HTML.
- Élément td (cellule de tableau) : définit une cellule dans un tableau HTML.
- Élément th (en-tête de tableau) : définit une cellule d'en-tête dans un tableau HTML. Les cellules d'en-tête s'affichent en gras et centrées par défaut et servent à nommer les lignes ou les colonnes du tableau.
- Élément caption : définit une légende ou un titre pour un tableau HTML. La légende s'affiche généralement au-dessus ou en dessous du tableau.
- Éléments col et colgroup : définissent les propriétés des colonnes d'un tableau HTML, telles que la largeur ou l'alignement.
- Éléments tbody, thead et tfoot : définissent respectivement les sections corps, en-tête et pied de page d'un tableau HTML. Ces éléments peuvent être utilisés pour regrouper des lignes et appliquer des styles ou des attributs à une section spécifique du tableau.
Pour mieux comprendre ce concept, voyons à quoi ressemble un tableau HTML :
À première vue, cela ressemble à un tableau normal et nous ne pouvons pas voir la structure avec les éléments décrits ci-dessus. Cela ne signifie pas qu'ils ne sont pas présents, mais que le navigateur les a déjà analysés pour nous. Pour pouvoir voir la structure HTML, vous devez aller un peu plus loin et utiliser les outils de développement. Pour ce faire, cliquez avec le bouton droit de la souris sur la page, sélectionnez « Inspecter », cliquez sur l'outil « Sélectionner un élément », puis cliquez sur l'élément (dans ce cas, la table) dont vous souhaitez voir la structure HTML. Après avoir suivi ces étapes, vous devriez voir quelque chose comme ceci :
Les tableaux HTML sont couramment utilisés pour présenter des données sous un format structuré et tabulaire, par exemple pour présenter des résultats sous forme de tableau ou afficher le contenu d’une base de données. On les trouve sur une grande variété de sites web et ils constituent un élément important à prendre en compte lors de l’extraction de données sur le web.
Configuration
Avant de commencer l'extraction, nous devons configurer notre environnement Golang et installer les dépendances nécessaires. Assurez-vous que Golang est installé et configuré sur votre système, puis créez un nouveau répertoire de projet et initialisez un fichier `go.mod` :
$ mkdir scraping-project
$ cd scraping-project
$ go mod init <NAME-OF-YOUR-PROJECT>
$ touch main.goEnsuite, nous devons installer une bibliothèque permettant d'effectuer des requêtes HTTP et d'analyser le code HTML. Plusieurs options sont disponibles, mais pour cet article, nous utiliserons le paquet `net/http` de la bibliothèque standard et le paquet golang.org/x/net/html pour l'analyse du code HTML. Ces paquets peuvent être installés en exécutant la commande suivante :
$ go get -u net/http golang.org/x/net/htmlMaintenant que notre environnement est configuré, nous sommes prêts à commencer à créer notre scraper de tableaux HTML à l'aide de Golang.
Commençons le scraping
Maintenant que notre environnement est configuré, nous pouvons commencer à créer un scraper pour extraire les données d'un tableau HTML. La première étape consiste à envoyer une requête HTTP à la page web contenant le tableau HTML que nous voulons extraire. Nous pouvons utiliser la fonction `http.Get` du paquet `net/http` pour envoyer une requête GET et récupérer le contenu HTML :
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)
}Ensuite, nous pouvons utiliser la fonction `goquery.NewDocumentFromReader` du paquet goquery pour analyser le contenu HTML et extraire les données dont nous avons besoin. Comme pour tout autre paquet Golang, vous devez d'abord l'installer comme suit :
$ go get github.com/PuerkitoBio/goquery Puis ajoutez le code suivant qui analysera le code HTML de la page :
doc, err := goquery.NewDocumentFromReader(resp.Body)
if err != nil {
log.Fatal(err)
}Maintenant que nous disposons d'un analyseur et d'un extracteur d'éléments pour notre HTML, nous pouvons tirer parti de la fonctionnalité `doc.Find()` du paquet Goquery, qui nous permet de trouver les éléments spécifiques que nous recherchons, en l'occurrence un tableau. Nous pouvons l'utiliser comme suit :
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()
}
})
}
})Et voilà, vous êtes désormais en mesure d’extraire le tableau à l’aide de Golang et vous devriez pouvoir le voir s’afficher à l’écran comme ceci :
Comme vous pouvez le constater, la structure peut être assez confuse et difficile à lire. La bonne nouvelle, c’est que vous pouvez faire mieux que cela et afficher les données de manière claire dans un format tabulaire facile à lire. C’est le travail idéal pour le package tablewriter, que vous pouvez installer comme suit :
$ go get github.com/olekukonko/tablewriterNous devons maintenant apporter quelques modifications à notre code avant de transmettre nos informations à tablewriter, notamment en définissant les en-têtes du tableau, les structures et en les stockant dans un tableau. Cela devrait ressembler à ceci :
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()
}Vous devriez maintenant pouvoir voir les données s'afficher sous ce format :
À ce stade, vous avez réussi à créer un scraper en Golang qui extrait une page web, stocke et affiche les données de manière claire. Vous pouvez également modifier le code pour extraire un tableau d'un autre site web. Gardez à l'esprit que tous les sites web sur Internet ne sont pas aussi faciles à scraper. Beaucoup d'entre eux ont mis en place des mesures de protection de haut niveau conçues pour empêcher le scraping, telles que les CAPTCHA et le blocage des adresses IP, mais heureusement, il existe des services tiers tels que WebScrapingAPI qui proposent la rotation d'IP et le contournement des CAPTCHA, vous permettant ainsi de scraper ces cibles.
Aller plus loin
Bien que la technique que nous avons décrite jusqu'à présent soit suffisante pour les tableaux HTML simples, il existe plusieurs façons de l'améliorer.
Un problème potentiel réside dans le fait que la structure des tableaux HTML peut ne pas être cohérente d'une page Web à l'autre. Par exemple, le tableau peut comporter un nombre différent de colonnes ou les données peuvent être imbriquées dans différents éléments HTML. Pour gérer ces cas, vous pouvez utiliser des techniques plus avancées telles que les sélecteurs CSS ou les expressions XPath afin de localiser les données que vous souhaitez extraire.
Un autre problème réside dans le fait que les pages web utilisent souvent AJAX ou d'autres technologies côté client pour charger des données supplémentaires dans la page après son chargement dans le navigateur. Cela signifie que le tableau HTML que vous scrapez peut ne pas contenir toutes les données dont vous avez besoin. Pour extraire ce type de pages, vous devrez peut-être utiliser un outil tel qu'un navigateur sans interface graphique (headless browser), capable d'exécuter du JavaScript et d'afficher la page comme le ferait un navigateur web classique. Une bonne alternative consiste à utiliser notre outil d'extraction, qui peut renvoyer les données une fois que le JavaScript a été exécuté sur la page. Vous pouvez en savoir plus à ce sujet en consultant notre documentation.
Enfin, il est important de tenir compte des performances et de l'évolutivité de votre scraper. Si vous effectuez le scraping de grands tableaux ou de plusieurs pages, vous devrez peut-être utiliser des techniques telles que la concurrence ou la limitation de débit pour vous assurer que votre scraper peut gérer la charge.
Résumé
J'espère que vous avez trouvé cette ressource utile comme point de départ pour extraire des tableaux HTML avec Golang. Nous avons parcouru le processus d'extraction de données à partir d'un tableau HTML à l'aide du langage de programmation Go. Nous avons vu comment récupérer le contenu HTML d'une page web, l'afficher à l'écran et le présenter sous un format tabulaire lisible à l'œil nu. Nous avons également abordé certains des défis que vous pourriez rencontrer lors de l'extraction de tableaux HTML, notamment les structures de tableaux incohérentes, le chargement des données côté client, ainsi que les problèmes de performances et d'évolutivité.
Bien qu'il soit possible de créer votre propre scraper à l'aide des techniques décrites dans cet article, il est souvent plus efficace et plus fiable de recourir à un service de scraping professionnel. Ces services disposent de l'infrastructure, de l'expertise et des mesures de sécurité nécessaires pour traiter de grands volumes de données et des tâches de scraping complexes, et peuvent souvent fournir les données dans un format plus structuré et plus pratique, tel que CSV ou JSON.
En résumé, l'extraction de données à partir de tableaux HTML peut être un moyen utile d'extraire des données du Web, mais il est important d'évaluer soigneusement les avantages et les inconvénients entre la création de votre propre outil d'extraction et le recours à un service professionnel.
