¿Qué son las interfaces en el lenguaje Go?

La interfaz en Go es una colección de firmas de métodos. Define el comportamiento de un objeto: qué "puede hacer". La interfaz no contiene datos ni implementaciones de métodos.

Características clave:

1. Implementación implícita: Un tipo implementa una interfaz implícitamente si proporciona todos los métodos declarados en la interfaz. No es necesario declarar explícitamente que un tipo implementa la interfaz.
2. "Tipificación de pato" (Duck Typing): "Si hace quack como un pato y camina como un pato, entonces es un pato". En Go, no importa el tipo del objeto, sino si implementa el conjunto requerido de métodos.
3. Valor cero: El valor cero de una interfaz es nil. El valor de interfaz puede ser nil si tanto el tipo como el valor dentro de ella son nil.
4. Interfaz vacía (interface{} o any): Puede contener un valor de cualquier tipo. Se usa a menudo para trabajar con datos de tipos desconocidos o en contenedores genéricos.

Ejemplo de definición y uso:

// Definimos la interfaz Greeter
type Greeter interface {
	Greet() string // Método Greet que devuelve una cadena
}

// Definimos el tipo Person
type Person struct {
	Name string
}

// Person implementa la interfaz Greeter, proporcionando el método Greet
func (p Person) Greet() string {
	return "Hola, " + p.Name
}

// Definimos el tipo Robot
type Robot struct {
	Model string
}

// Robot también implementa la interfaz Greeter
func (r Robot) Greet() string {
	return "Saludos, modelo " + r.Model
}

// La función recibe una interfaz Greeter
func SayHello(g Greeter) {
	fmt.Println(g.Greet()) // Llamamos al método Greet a través de la interfaz
}

func main() {
	person := Person{Name: "Alicia"}
	robot := Robot{Model: "RX-800"}

	SayHello(person) // Pasamos un Person que implementa Greeter
	SayHello(robot)  // Pasamos un Robot que implementa Greeter
}

Las interfaces fomentan un diseño flexible y desacoplado, permitiendo escribir funciones que trabajan con diferentes tipos de datos, siempre que estos tipos implementen la interfaz necesaria. Se usan para crear código genérico y en la biblioteca estándar de Go (por ejemplo, io.Reader, io.Writer, fmt.Stringer).