Imprimiendo el contenido de una Página Web usando Interfaces

https://golang.org/pkg/io/#Copy
https://golang.org/pkg/io/#Writer
https://golang.org/pkg/io/#ReadCloser

Es muy interesante como ver el contenido de una web usando interfaces, se entiende su importancia.
Aqui dejo otro ejemplo de como ver el contenido de una pagina web.

package main
 
import (
	"fmt"
	"io/ioutil"
	"log"
	"net/http"
)
 
func main() {
 
	// Basic HTTP GET request
	resp, err := http.Get("http://www.google.com")
	if err != nil {
		log.Fatal("Error getting response. ", err)
	}
	defer resp.Body.Close()
 
	// Read body from response
	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		log.Fatal("Error reading response. ", err)
	}
 
	fmt.Printf("%s\n", body)
}```

Go tiene varios paquetes útiles y poderosos built-in dentro de su librería estándar. Entre ellos el paquete http que sirve para hacer clientes, servidores o simples request.

// request sin modificaciones, argumentos, protocolo, etc.
// hay que usar la URL de manera completa incluyendo el protocolo
response, err := http.Get("http://www.google.com")
fmt.Println(response.Body)

La función retorna la variable response que no es directamente un string HTML, sino toda la respuesta del request. Quiere decir que dentro sus propiedades contiene los headers, status, cuerpo, etc.

response.Body es un lector y no un string por lo que necesitamos utilizar alguna función que nos permita leer esto, por ejemplo la función Copy pertenenciente al paquete io de Go.

// tiene como parámetros dos interfaces: un Writer y un Reader
func Copy(dst Writer, src Reader) (written int64, err error)

type Writer interface {
    Write(p []byte) (n int, err error)
}

type Reader interface {
    Read(p []byte) (n int, err error)
}

Para implementar la función Copy se necesitan 2 estructuras que sean de estos tipos de interfaces. Tenemor ya un Reader a través del lector que nos regresa response.Body y hace falta un Writer.

type WebWriter struct{}

func (WebWriter) Write(p []byte) (int, error) {
	fmt.Println(string(p)) // se transforma de bytes a string
	return len(p), nil // se regresa la cantidad de bytes, definido por la interfaz original
}

io.Copy(ww, response.Body)

Esta función hace la lógica de leer el contenido del Reader y pasar la información en bytes al Writer. Nuestro Writer lo único que hace es imprimir, pero puede escalarse diferentes casos de uso.

Wow! 🤯

Este es un ejemplo para imprimir el cuerpo de request de manera más práctica (aunque pierde la práctica de la clase de implementar interfaces).

bodyBytes, err := ioutil.ReadAll(response.Body)
if err != nil {
	log.Fatal(err)
}
bodyString := string(bodyBytes)
fmt.Println(bodyString)

package main

import (
	"fmt"
	"io"
	"net/http"
)

type escritorWeb struct {
}

func (escritorWeb) Write(p []byte) (int, error) {
	fmt.Println(string(p))
	return len(p), nil
}

func main() {
	respuesta, _ := http.Get("h t t p : / / g o  o gl e . c o m " )

	e := escritorWeb{}
	i o . C o py(e, respuest a . B o d y)
}

resp, err := http.get(url), nos regresa una respuesta o un error

¿Esto podría servir como para hacer webscrapping, cierto?

Que pasa si hay dos interfaces con el mismo nombre para su metodo?
Cual interface implementa?

El título se debería cambiar a imprimiendo el código de una página web usando interfaces.

Hola chicos, por qué ponen el método Write con mayúscula? yo entiendo que eso lo hace un método publico, pero por qué tiene que ser publico?
Gracias!

if err != nil -> esto es que si es ditinto de vacio, es que hay un error

al hacer println de nuestra resp nos regresa algo no entendible

al cambiar el nombre de Writer no estamos cumpliendo con el contrato y nos da un error

Esta parte de Http nos va servir entenderlo para la parte de el servidor web

Para convertir un flujo de byte a un String, se hace precisamente con string() para imprimirlo

con fmt.Println(string§) nos muestra estructuras legibles

Las interfase de tipo hadler que nos permites guardar, actualizar data y demas

Por fin un tema interesante!

Copy y Wriet son interfaces, ya entiendo por se le dedico un modulo completo de explicacion de interfaces, ya que golang se implementa mucho las interfases

este funciones de string que nos regresan la data legible son en base de interfaces, si se implementan interfaces podemos sacarle mas funcionalidad a Golang

Lo único que no me deja tan contento es que si no fuera mi codigo y si no conociera el requerimiento de io.Copy, no fuera tan claro que nuestra función Write está implementando un interfaz. Sin comentarios del equipo yo necesitaria ir a la documentación para averiguarlo.

Cuales son algunos de los packages más usados o recomendados de saber? (fmt, io, etc…)

funciono…no tuve problemas 😃 se ve que se puede reutilizar cogido con las interfaces en Go. 😃

para imprimir el resultado de verdad, tenemos que usar Copy, con un escritor y un lector

Excelente clase!

Muy util