Descubra como extrair tabelas HTML com Golang

Andrei Ogiolan em 24 de abril de 2023

Introdução

O Web scraping é uma técnica de extração de dados de sítios Web e pode ser uma ferramenta poderosa para recolher informações da Internet. Este artigo abordará como extrair tabelas HTML com Golang, uma linguagem de programação popular conhecida por sua simplicidade, suporte a concorrência e biblioteca padrão robusta.

O que são tabelas HTML?

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:

• elemento table: Define o início e o fim de uma tabela HTML.
• elemento tr (linha de tabela): Define uma linha numa tabela HTML.
• Elemento td (célula de tabela): Define uma célula numa tabela HTML.
• th (cabeçalho de tabela): Define uma célula de cabeçalho numa tabela HTML. As células de cabeçalho são apresentadas a negrito e centradas por predefinição e são utilizadas para identificar as linhas ou colunas da tabela.
• elemento caption: Define uma legenda ou título para uma tabela HTML. A legenda é normalmente apresentada por cima ou por baixo da tabela.
• elementos col e colgroup: Definem as propriedades das colunas numa tabela HTML, como a largura ou o alinhamento.
• Elementos tbody, thead e tfoot: Definem as secções de corpo, cabeça e pé de uma tabela HTML, respetivamente. Estes elementos podem ser utilizados para agrupar linhas e aplicar estilos ou atributos a uma secção específica da tabela.

Para compreender melhor este conceito, vejamos o aspeto de uma tabela HTML:

À primeira vista, parece uma tabela normal e não conseguimos ver a estrutura com os elementos acima descritos. Isso não significa que não estejam presentes, mas sim que o browser já os analisou por nós. Para poder ver a estrutura HTML, é necessário dar um passo em frente e utilizar as ferramentas de desenvolvimento. Pode fazê-lo clicando com o botão direito do rato na página, clicando em inspecionar, clicando na ferramenta selecionar elemento e clicando no elemento (neste caso, a tabela) cuja estrutura HTML pretende ver. Depois de seguir estes passos, deve ver algo como isto:

As tabelas HTML são normalmente utilizadas para apresentar dados num formato estruturado e tabular, por exemplo, para tabular resultados ou apresentar o conteúdo de uma base de dados. Podem ser encontradas numa grande variedade de sítios Web e são um elemento importante a ter em conta ao extrair dados da Web.

Configuração

Antes de começarmos a fazer scraping, precisamos configurar nosso ambiente Golang e instalar as dependências necessárias. Certifique-se de ter o Golang instalado e configurado em seu sistema, e então crie um novo diretório de projeto e inicialize um arquivo `go.mod`:

$ mkdir scraping-project

$ cd scraping-project

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

$ touch main.go

Em seguida, precisamos instalar uma biblioteca para fazer requisições HTTP e analisar HTML. Existem várias opções disponíveis, mas para este artigo vamos usar o pacote `net/http` da biblioteca padrão e o pacote golang.org/x/net/html para analisar o HTML. Esses pacotes podem ser instalados executando o seguinte comando:

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

Agora que nosso ambiente está configurado, estamos prontos para começar a construir nosso scraper de tabelas HTML usando Golang.

Vamos começar a raspar

Agora que temos o nosso ambiente configurado, podemos começar a criar um raspador para extrair dados de uma tabela HTML. O primeiro passo é enviar uma solicitação HTTP para a página web que contém a tabela HTML que queremos extrair. Podemos usar a função `http.Get` do pacote `net/http` para enviar uma solicitação GET e recuperar o conteúdo 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)

}

Em seguida, podemos usar a função `goquery.NewDocumentFromReader` do pacote goquery para analisar o conteúdo HTML e extrair os dados que precisamos. Como qualquer outro pacote Golang, você precisa instalá-lo primeiro como a seguir:

$ go get github.com/PuerkitoBio/goquery 

Em seguida, adicione o seguinte código que analisará o HTML da página:

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

if err != nil {

    log.Fatal(err)

}

Agora que temos um analisador e um extrator de elementos para o nosso HTML, podemos tirar partido da funcionalidade `doc.Find()` do pacote Goquery que nos permite encontrar os elementos específicos que estamos à procura, neste caso, uma tabela. Podemos utilizá-la da seguinte forma:

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()

            }

        })

    }

})

É isso, agora é capaz de raspar a tabela usando Golang e deve ser capaz de a ver no ecrã assim:

Como se pode verificar, a estrutura pode ser bastante confusa e difícil de ler. A boa notícia é que pode fazer melhor do que isso e apresentar os dados num formato tabular que seja fácil de ler. Esta é uma tarefa perfeita para o pacote tablewriter, que pode instalar da seguinte forma:

$ go get github.com/olekukonko/tablewriter

Agora precisamos de fazer alguns ajustes ao nosso código antes de passar a nossa informação para um tablewriter, como definir os cabeçalhos da tabela, structs e armazená-los num array. O código deve ser mais ou menos assim:

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()

}

Os dados devem agora ser apresentados neste formato:

Neste ponto, conseguiu construir um raspador em Golang que raspa uma página web e armazena e apresenta os dados de forma agradável. Também pode modificar o código para extrair uma tabela de outro site. Tenha em mente que nem todos os sítios Web na Internet são tão fáceis de extrair dados. Muitos deles implementaram medidas de proteção de alto nível concebidas para impedir a recolha de dados, como o CAPTCHA e o bloqueio dos endereços IP, mas felizmente existem serviços de terceiros, como o WebScrapingAPI, que oferecem a rotação de IP e o desvio do CAPTCHA, permitindo-lhe recolher dados desses alvos.

Mergulhar mais fundo

Embora a técnica que descrevemos até agora seja suficiente para tabelas HTML simples, existem várias formas de a melhorar.

Um problema potencial é que a estrutura da tabela HTML pode não ser consistente em todas as páginas Web. Por exemplo, a tabela pode ter um número diferente de colunas ou os dados podem estar aninhados em diferentes elementos HTML. Para lidar com estes casos, pode utilizar técnicas mais avançadas, como selectores CSS ou expressões XPath, para localizar os dados que pretende extrair.

Outro problema é que as páginas Web utilizam frequentemente AJAX ou outras tecnologias do lado do cliente para carregar dados adicionais na página depois de esta ter sido carregada no browser. Isto significa que a tabela HTML que está a extrair pode não conter todos os dados de que necessita. Para extrair estes tipos de páginas, pode ser necessário utilizar uma ferramenta como um navegador sem cabeça, que pode executar JavaScript e renderizar a página tal como um navegador Web normal. Uma boa alternativa é utilizar o nosso raspador, que pode devolver os dados depois de o JavaScript ser processado na página. Pode saber mais sobre isto consultando os nossos documentos.

Finalmente, é importante considerar o desempenho e a escalabilidade do seu raspador. Se estiver a fazer scraping de tabelas grandes ou de várias páginas, poderá ter de utilizar técnicas como a concorrência ou a limitação da taxa para garantir que o seu scraper consegue suportar a carga.

Resumo

Espero que tenha encontrado este recurso como um bom ponto de partida para a extração de tabelas HTML com Golang. Percorremos o processo de extração de dados de uma tabela HTML usando a linguagem de programação Go. Vimos como recuperar o conteúdo HTML de uma página da Web, imprimi-lo na tela e exibi-lo em um formato tabular legível aos olhos humanos. Também discutimos alguns dos desafios que você pode encontrar ao extrair tabelas HTML, incluindo estruturas de tabela inconsistentes, carregamento de dados do lado do cliente e problemas de desempenho e escalabilidade.

Embora seja possível criar o seu próprio raspador utilizando as técnicas descritas neste artigo, é frequentemente mais eficiente e fiável utilizar um serviço de raspagem profissional. Estes serviços têm a infraestrutura, a experiência e as medidas de segurança necessárias para lidar com grandes volumes de dados e tarefas de raspagem complexas, e podem frequentemente fornecer dados num formato mais estruturado e conveniente, como CSV ou JSON.

Em resumo, a recolha de dados de tabelas HTML pode ser uma forma útil de extrair dados da Web, mas é importante considerar cuidadosamente as vantagens e desvantagens entre criar o seu próprio ficheiro de recolha de dados e utilizar um serviço profissional.