Dominar las interfaces en Go es un paso fundamental para escribir código más limpio, reutilizable y eficiente. Cuando múltiples structs comparten un mismo método, las interfaces permiten crear un punto de entrada único que simplifica la interacción con todas esas estructuras de datos. Además, existe una técnica avanzada que permite simular listas con múltiples tipos de datos mediante listas de interfaces, algo que en Go no es posible de forma nativa con slices convencionales.

¿Cómo se definen structs y métodos para figuras geométricas en Go?

El punto de partida consiste en declarar los structs que representan las figuras. En este caso, se trabaja con un cuadrado y un rectángulo [01:12].

• El struct cuadrado tiene un solo campo: base de tipo float64.
• El struct rectángulo tiene dos campos: base y altura, ambos de tipo float64.

Cada struct necesita su propia función de área. Para el cuadrado, el área se calcula multiplicando la base por sí misma (c.base * c.base). Para el rectángulo, se multiplica base por altura (r.base * r.altura) [02:08].

Una vez creados los structs, se instancian con valores concretos. Por ejemplo, un cuadrado con base 2 y un rectángulo con base 2 y altura 4.

¿Por qué no basta con llamar cada método por separado?

Sin interfaces, para conocer el área de cada figura habría que invocar directamente miCuadrado.area() y miRectangulo.area() [04:18]. Esto funciona con dos figuras, pero cuando tienes muchas más estructuras de datos que comparten la misma función, el código se vuelve repetitivo y difícil de mantener.

¿Qué es una interfaz y cómo se implementa en Go?

Una interfaz en Go es un tipo que agrupa métodos compartidos por distintos structs. Se declara con type seguido del nombre y la palabra clave interface [02:50].

go type figuras2D interface { area() float64 }

Esta interfaz establece que cualquier struct que tenga un método area() retornando float64 cumple automáticamente con la interfaz figuras2D. No hace falta declarar explícitamente que un struct implementa la interfaz; Go lo resuelve de forma implícita.

Después se crea una función llamada calcular que recibe como parámetro la interfaz [03:12]:

go func calcular(f figuras2D) { fmt.Println("Area:", f.area()) }

¿Cómo se ejecuta la interfaz con diferentes structs?

Simplemente se pasa cada instancia a la función calcular [04:30]:

go calcular(miCuadrado) calcular(miRectangulo)

Al ejecutar, el cuadrado con base 2 muestra un área de 4, mientras que el rectángulo con base 2 y altura 4 muestra un área de 8. Aunque ambos llaman al mismo método area(), la interfaz selecciona automáticamente la implementación correspondiente al struct que recibe. Esto hace el código mucho más eficiente y legible a gran escala [05:05].

¿Cómo crear una lista de interfaces con múltiples tipos de datos?

En lenguajes más flexibles, una misma lista puede contener valores de distintos tipos: textos, números, booleanos. En Go, al crear un slice o array, es obligatorio indicar el tipo de dato. Sin embargo, existe una forma de simular ese comportamiento usando una lista de interfaces vacías [05:38].

go myInterface := []interface{}{"hola", 12, 4.5} fmt.Println(myInterface...)

• Se declara un slice de tipo interface{}.
• La primera llave queda en blanco y en la segunda se agregan los datos.
• Los tres puntos (...) al imprimir indican que cada elemento se muestra de forma individual.

Al ejecutar, la consola muestra los resultados de las áreas calculadas previamente y la lista de interfaces con sus distintos tipos de datos: un string, un entero y un decimal [06:22].

Esta técnica es especialmente útil cuando necesitas manejar colecciones heterogéneas sin perder la seguridad de tipos que caracteriza a Go.

Si quieres practicar, un buen reto es crear interfaces para distintas figuras geométricas, organizar los structs en paquetes separados y definir métodos privados y públicos según corresponda. Comparte tu solución en los comentarios.