Introducción
El web scraping es una técnica para extraer datos de sitios web y puede ser una herramienta muy útil para recopilar información de Internet. En este artículo veremos cómo extraer datos de tablas HTML con Golang, un lenguaje de programación muy popular conocido por su sencillez, su compatibilidad con la programación concurrente y su sólida biblioteca estándar.
¿Qué son las tablas 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 el inicio y el final de una tabla HTML.
- elemento tr (fila de tabla): Define una fila en una tabla HTML.
- Elemento td (celda de tabla): Define una celda en una tabla HTML.
- Elemento (encabezado de tabla): Define una celda de encabezado en una tabla HTML. Las celdas de encabezado se muestran en negrita y centradas de forma predeterminada, y se utilizan para etiquetar las filas o columnas de la tabla.
- elemento caption: Define un título para una tabla HTML. El título suele aparecer encima o debajo de la tabla.
- elementos col y colgroup: Definen las propiedades de las columnas de una tabla HTML, como la anchura o la alineación.
- Elementos tbody, thead y tfoot: Definen las secciones body, head y foot de una tabla HTML, respectivamente. Estos elementos pueden utilizarse para agrupar filas y aplicar estilos o atributos a una sección específica de la tabla.
Para entender mejor este concepto, veamos cómo es una tabla HTML:
A primera vista, parece una tabla normal y no podemos ver la estructura con los elementos descritos anteriormente. Esto no significa que no estén presentes, sino que el navegador ya los ha analizado por nosotros. Para poder ver la estructura HTML, hay que ir un paso más allá y utilizar las herramientas de desarrollo. Para ello, haz clic con el botón derecho del ratón en la página, selecciona «Inspeccionar», haz clic en la herramienta «Seleccionar elemento» y, a continuación, haz clic en el elemento (en este caso, la tabla) del que quieras ver la estructura HTML. Tras seguir estos pasos, deberías ver algo como esto:
Las tablas HTML se utilizan habitualmente para presentar datos en un formato tabular estructurado, por ejemplo para tabular resultados o mostrar el contenido de una base de datos. Se pueden encontrar en una gran variedad de sitios web y son un elemento importante a tener en cuenta a la hora de escrapear datos de la web.
Puesta en marcha
Antes de empezar a extraer datos, debemos configurar nuestro entorno de Golang e instalar las dependencias necesarias. Asegúrate de que tienes Golang instalado y configurado en tu sistema; a continuación, crea un nuevo directorio de proyecto e inicializa un archivo `go.mod`:
$ mkdir scraping-project
$ cd scraping-project
$ go mod init <NAME-OF-YOUR-PROJECT>
$ touch main.goA continuación, debemos instalar una biblioteca para realizar solicitudes HTTP y analizar código HTML. Hay varias opciones disponibles, pero para este artículo utilizaremos el paquete `net/http` de la biblioteca estándar y el paquete golang.org/x/net/html para analizar código HTML. Estos paquetes se pueden instalar ejecutando el siguiente comando:
$ go get -u net/http golang.org/x/net/htmlAhora que ya tenemos todo el entorno preparado, estamos listos para empezar a crear nuestro rastreador de tablas HTML con Golang.
Empecemos a raspar
Ahora que ya tenemos el entorno configurado, podemos empezar a crear un rastreador para extraer datos de una tabla HTML. El primer paso es enviar una solicitud HTTP a la página web que contiene la tabla HTML que queremos rastrear. Podemos utilizar la función `http.Get` del paquete `net/http` para enviar una solicitud GET y recuperar el contenido 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)
}A continuación, podemos utilizar la función `goquery.NewDocumentFromReader` del paquete goquery para analizar el contenido HTML y extraer los datos que necesitamos. Al igual que con cualquier otro paquete de Golang, primero hay que instalarlo de la siguiente manera:
$ go get github.com/PuerkitoBio/goquery A continuación, añade el siguiente código, que analizará el código HTML de la página:
doc, err := goquery.NewDocumentFromReader(resp.Body)
if err != nil {
log.Fatal(err)
}Ahora que contamos con un analizador sintáctico y un extractor de elementos para nuestro código HTML, podemos aprovechar la funcionalidad `doc.Find()` del paquete Goquery, que nos permite localizar los elementos específicos que buscamos; en este caso, una tabla. Podemos utilizarla de la siguiente manera:
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()
}
})
}
})Ya está, ahora ya puedes extraer los datos de la tabla con Golang y deberías poder verlos en pantalla así:
Como habrás podido observar, la estructura puede resultar bastante confusa y difícil de leer. La buena noticia es que puedes mejorar el resultado y presentar los datos de forma clara en un formato tabular que resulte fácil de leer. Esta es una tarea perfecta para el paquete tablewriter, que puedes instalar de la siguiente manera:
$ go get github.com/olekukonko/tablewriterAhora tenemos que hacer algunos ajustes en nuestro código antes de pasar la información a un generador de tablas, como definir los encabezados de las tablas y las estructuras, y almacenarlos en una matriz. Debería quedar algo así:
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()
}Ahora deberías poder ver los datos mostrados en este formato:
En este punto, ya has conseguido crear un rastreador en Golang que extrae datos de una página web y los almacena y muestra correctamente. También puedes modificar el código para extraer datos de una tabla de otra página web. Ten en cuenta que no todos los sitios web de Internet permiten extraer datos con tanta facilidad. Muchos de ellos han implementado medidas de protección de alto nivel diseñadas para impedir el scraping, como CAPTCHA y el bloqueo de direcciones IP, pero, afortunadamente, existen servicios de terceros, como WebScrapingAPI, que ofrecen rotación de IP y eludir CAPTCHA, lo que te permite extraer datos de esos sitios.
Profundizar
Aunque la técnica que hemos descrito hasta ahora es suficiente para tablas HTML sencillas, hay varias formas de mejorarla.
Un posible problema es que la estructura de la tabla HTML puede no ser uniforme en todas las páginas web. Por ejemplo, la tabla puede tener un número diferente de columnas o los datos pueden estar anidados en distintos elementos HTML. Para gestionar estos casos, puedes utilizar técnicas más avanzadas, como selectores CSS o expresiones XPath, para localizar los datos que deseas extraer.
Otro problema es que las páginas web suelen utilizar AJAX u otras tecnologías del lado del cliente para cargar datos adicionales en la página una vez que esta se ha cargado en el navegador. Esto significa que es posible que la tabla HTML que estás extrayendo no contenga todos los datos que necesitas. Para extraer datos de este tipo de páginas, es posible que tengas que utilizar una herramienta como un navegador sin interfaz gráfica, que puede ejecutar JavaScript y renderizar la página igual que un navegador web normal. Una buena alternativa es utilizar nuestro extractor, que puede devolver los datos una vez que JavaScript se ha renderizado en la página. Puedes obtener más información al respecto consultando nuestra documentación.
Por último, es importante tener en cuenta el rendimiento y la escalabilidad de tu rastreador. Si vas a rastrear tablas de gran tamaño o varias páginas, es posible que tengas que recurrir a técnicas como la concurrencia o la limitación de la frecuencia de solicitudes para garantizar que tu rastreador pueda soportar la carga.
Resumen
Espero que este recurso te haya servido como un buen punto de partida para extraer datos de tablas HTML con Golang. Hemos repasado el proceso de extracción de datos de una tabla HTML utilizando el lenguaje de programación Go. Hemos visto cómo recuperar el contenido HTML de una página web, imprimirlo en pantalla y mostrarlo en un formato tabular legible a simple vista. También hemos abordado algunos de los retos a los que te puedes enfrentar al extraer datos de tablas HTML, como las estructuras de tabla inconsistentes, la carga de datos del lado del cliente y los problemas de rendimiento y escalabilidad.
Aunque es posible crear tu propio rastreador utilizando las técnicas descritas en este artículo, suele ser más eficaz y fiable recurrir a un servicio profesional de rastreo. Estos servicios cuentan con la infraestructura, la experiencia y las medidas de seguridad necesarias para gestionar grandes volúmenes de datos y tareas de rastreo complejas, y a menudo pueden proporcionar los datos en un formato más estructurado y práctico, como CSV o JSON.
En resumen, el rastreo de tablas HTML puede ser una forma útil de extraer datos de la web, pero es importante sopesar cuidadosamente las ventajas y desventajas entre crear tu propio rastreador y recurrir a un servicio profesional.
