Interfaces y Polimorfismo en TypeScript y Go

Clase 10 de 30 • Curso de Go Intermedio: Programación Orientada a Objetos y Concurrencia

Resumen

¿Cómo funcionan las interfaces en la programación orientada a objetos?

Las interfaces son una herramienta esencial para la programación orientada a objetos, ya que permiten la implementación del polimorfismo y diversos patrones de diseño. Consideradas como "contratos", obligan a las clases que deciden utilizarlas a implementar cada una de las funciones o métodos que estas definen. La importancia de las interfaces es evidente en su capacidad de simplificar procesos de codificación y gestionar de manera eficiente el comportamiento de diferentes clases.

¿Qué es una interfaz en programación?

Una interfaz en programación se define como un conjunto de métodos que una clase debe implementar para cumplir con un contrato particular. En este sentido:

Definición de contrato: Una interfaz asegura que cualquier clase que la implemente debe contener los métodos especificados.
Flexibilidad en la implementación: Aunque una interfaz estipula cuáles métodos deben existir, no dicta cómo estos deben ser implementados.

En TypeScript, por ejemplo, se puede encontrar una interfaz denominada printInfo, que requiere una función getMessage que devuelve un string. Sin entrar en detalles de implementación, cualquier clase que quiera "firmar" este contrato deberá asegurarse de que el método getMessage exista dentro de su estructura.

¿Cómo se implementan las interfaces en TypeScript y Go?

Uso de interfaces en TypeScript

Declaración: Utiliza la palabra clave interface para definir qué métodos deben estar presentes.
Implementación: Las clases usan la palabra clave implements para indicar que están adoptando la interfaz.

Un ejemplo en TypeScript muestra cómo una clase puede implementar diferentes interfaces mientras mantiene su propia lógica interna única. Esta flexibilidad permite a distintos desarrolladores implementar la funcionalidad necesaria de forma peculiar a la estructura de su aplicación, apoyando el comportamiento polimórfico.

Implementación implícita en Go

A diferencia de TypeScript, Go utiliza un enfoque implícito para la implementación de interfaces:

Declaración: Similar a otros lenguajes, Go permite definir un tipo de interfaz, pero aquí, las clases que coinciden con la interfaz se consideran que la implementan automáticamente.
Polimorfismo: Mediante métodos comunes en diferentes estructuras (struct), Go permite operaciones polimórficas utilizando las interfaces.

El siguiente código ilustra la creación de una interfaz printInfo en Go:

type printInfo interface {
    getMessage() string
}

Dos structs, TemporaryEmployee y FullTimeEmployee, pueden implementar implícitamente esta interfaz si definen un método getMessage() correctamente.

¿Por qué son importantes las interfaces?

El uso de interfaces en programación no solo fomenta un diseño más limpio y modular, sino que también reduce la duplicación de código. Al utilizar interfaces, no es necesario definir múltiples funciones printMessage para cada clase, sino que se puede trabajar con un solo método genérico que acepte cualquier objeto que implemente la interfaz. Esto:

Reduce la repetición: Evita crear funciones duplicadas para cada clase.
Facilita la extensión: Al añadir nuevas clases, solo se necesita implementar la interfaz sin cambiar el código existente.
Fomenta el polimorfismo: Permite que diferentes clases sean tratadas a través de una misma interfaz, expandiendo las posibilidades de reutilización y adaptación del código.

Reflexiones finales

Las interfaces son, sin duda, una joya en la corona de la programación orientada a objetos y en lenguajes como Go. Aunque su implementación pueda variar entre lenguajes, el concepto básico sigue siendo una pieza inquebrantable en la creación de códigos robustos, adaptables y eficientes. Alentamos a los desarrolladores a profundizar su comprensión y uso de estas potentes herramientas para maximizar la eficacia de sus proyectos. Y recuerda, el verdadero poder de la programación yace en la capacidad de seguir aprendiendo y adaptando diversas técnicas a tus necesidades de desarrollo. ¡Sigue explorando y codificando!

Tan Zuñiga

student•

Les comparto mis implementaciones de getMessage para FullTimeEmployee y TemporaryEmployee 😃:

func (ftEmployee FullTimeEmployee) getMessage() string {
	return fmt.Sprintf("\nFull Time Employee\nid: %d name: %s age: %d endDate: %s",
		ftEmployee.id,
		ftEmployee.name,
		ftEmployee.age,
		ftEmployee.endDate)
}

func (tEmployee TemporaryEmployee) getMessage() string {
	return fmt.Sprintf("\nTemporary Employee\nid: %d name: %s age: %d taxRate: %d",
		tEmployee.id,
		tEmployee.name,
		tEmployee.age,
		tEmployee.taxRate)
}

Carlos Nexans

student•

El tipado de Go respecto de las interfaces es una especie de duck typing. Como regla nmemotécnica: si camina como un pato y hace cuác como un pato, entonces debe ser un pato. La diferencia entre duck typing y el tipado en Go, es que en Go el chequeo sucede en tiempo de compilación, es tipado estático. Es por esto que lo llaman "tipado estructural", el chequeo le da importancia a la estructura.

Platzi Team

student•

Excelente aporte compañero

Alejandro Alfredo Buezo

student•

En lenguajes como Typescript o Java es ++necesario++ definir los métodos de la interfaz para poder implementarla y la implementación es explícita. En cambio en Go, es ++suficiente++ definir los métodos para implementar la interfaz y la implementación es implícita. En el polimorfismo se utiliza una interfaz (o una clase base) para determinar en tiempo de ejecución el método a utilizar, accediéndolo por medio de la interfaz en vez de hacerlo a través de un objeto en particular, porque en este último caso el método se determina en tiempo de compilación (esto no es polimorfismo).

// no se conoce p hasta el momento en que 
// se ejecuta esta función
// podría ser un FullTimeEmployee
// o un TemporaryEmployee
func getMessage(p PrintInfo) {
  fmt.Println(p.getMessage)
}

// aquí ya se conoce el método a usar
// antes de compilar
ftEmployee.getMessage()

Entonces con polimorfismo, podrías por ejemplo, estar recibiendo desde una BD o un JSON desde un front, los datos de un empleado en tiempo de ejecución y determinar en ese momento cual es el método apropiado para ese empleado en particular.

Benjamin Eduardo De La Torre Rojas

student•

Apuntes y código:

Diferentes lenguajes de programación utilizan sintaxis explicita para decir que una clase implementa un interfaz
Go lo hace de manera implícita lo que permite la re utilización de código y polimorfismo

package main

import "fmt"

type Person struct {
	name string
	age  int
}

type Employee struct {
	id int
}

// De esta manera aplicamos la composicion sobre la herencia
type FullTimeEmployee struct {
	Person
	Employee
	endDate string
}

type TemporatyEmployee struct {
	Person
	Employee
	taxRate int
}
// Creamos la interfaz
type PrintInfo interface {
	getMessage() string
}
// Implementamos la interfaz
func (ftEmployee FullTimeEmployee) getMessage() string {
	return "Full Time Employee"
}

func (tEmployee TemporatyEmployee) getMessage() string {
	return "Temporary Employee"
}
// Creamos el metodo de la interfaz
func getMessage(p PrintInfo) {
	fmt.Println(p.getMessage())
}

func main() {
	ftEmployee := FullTimeEmployee{}
	ftEmployee.name = "Benjamin"
	ftEmployee.age = 20
	ftEmployee.id = 1
	fmt.Printf("%v\n", ftEmployee)
	tEmployee := TemporatyEmployee{}
	getMessage(tEmployee)
	getMessage(ftEmployee)
}

Sebastian Sansoni

student•

yo no conozco typescript, por lo que me perdi en esta explicación.

David Palacio

student•

siento que deberia solo explicar en el lenguaje, ya que hace comparacion de 3 lenguajes a la vez, y uno se enrreda.

Oscar Jaramillo

student•

Go no implementa interfaces de manera explicita sino de manera implícita.

Gregori Piñeres

student•

¿Los structs podrían ser inmutables?

Jorge Miguel Anaya León

student•

Puedes crear la struct vacía y crear FunctionsReceivers de solo lectura asociadas al struct. No sé si sea buena practica, pero es la que se me ocurre y creo haría lo que necesitas.

Guillermo Leonardo Rossi

student•

para q los ejemplos de ts? por q no directamente vemos go?

Carlos Nassif Trejo Garcia

student•

package main

import "fmt"

type Person struct {
	name string
	age  int
}

type Employee struct {
	id int
}

// Inheritance tipo anonimo
type FullTimeEmployee struct {
	Person
	Employee
	endDate string
}

type TemproaryEmployee struct {
	Person
	Employee
	taxRate float64
}

type PrintInfo interface {
	getMessage() string
}

// Composicion sobre herencia
func (ft FullTimeEmployee) getMessage() string {
	return fmt.Sprintf("Hi %s, you are %d years old. And you are a full time employee", ft.name, ft.age)
}

func (te TemproaryEmployee) getMessage() string {
	return fmt.Sprintf("Hi %s, you are %d years old. And you are a temprary employee", te.name, te.age)
}

func GetMessage(pi PrintInfo) {
	fmt.Println(pi.getMessage())
}

func main() {
	f := FullTimeEmployee{}
	f.name = "John"
	f.age = 30
	f.id = 1
	f.endDate = "2019-01-01"
	fmt.Printf("%+v\n", f)

	t := TemproaryEmployee{}
	t.name = "Mary"
	t.age = 25
	t.id = 2
	t.taxRate = 0.25
	fmt.Printf("%+v\n", t)

	GetMessage(f)
	GetMessage(t)
}

Juan Castellanos

student•

Dado que las interfaces en Go son implicitas, existe alguna recomendación o buena práctica que permita facilitar el mantenimiento de código. Al ser implicitas no es fácil a simple vista determinar qué interfaces implementa una estructura lo cual dificulta el mantenimiento de código (en especial cuando uno realizar mantenimiento de código de un tercero).

Aaron Contreras Garibay

student•

Siento muy forzado go para la OOP, pero siento que se puede mantener la limpieza si todo lo llevamos a un archivo aparte.

William Rodriguez

student•

Al revés. La OOP es muy forzada, he tiene muchas partes ineficientes en el libro de Golang Programming language explican por qué quitaron tantas cosas de OOP y de resultado salió un lenguaje mucho más rápido y eficiente con sintaxis más simple. En golang puedes usar paquetes para agrupar el código es diferente a Java o C# que es cada clase por archivo, el peor error es tratar de usar Golang como java o C#.

Gregori Piñeres

student•

¿Cómo podemos implementar visibilidad de propiedades y métodos en los structs?

Jorge Miguel Anaya León

student•

Solo haz que la primera letra del nombre del método o la propiedad del struct inicien con mayúscula.

fabio andres zamora osorio

student•

¿No he entendido bien cual es el beneficio de usar interfaces, no seria mejor simplemente ejecutar el metodo de cada objeto para asi no tener que escribir la interface ni el metodo que recibe como parametro la interface y asi usar menos codigo, osea no seria mas facil poner obj1.getMessage() y obj2.getMessage()?

Misael Mondragón Lenis

student•

Imagina que actualizas obj2.getMessage() y quedas con una implementación que te retorne un tipo de dato diferente como un byte, un objeto clase Message, o una dirección en memoria, corres el riesgo de tener un resultado no deseado y romper tu código. La idea de la interfaz es organizar el código para evitar algún comportamiento no esperado.

El beneficio de la interfaz se ve a medida que aumenta la complejidad de la aplicación, ya que no solo te dice el nombre del método, sino también que tipos de datos tomar como entrada y como salida. (Esto es lo que llaman la firma de un método)

Esto te ayuda en temas de abstracción y polimorfismo, por ejemplo si quieres subir el volumen a una película o música, puedes definir una "interfaz de audio" con un método "subirVolumen" que como entradas tenga un array de bytes con un entero y como salida un array bytes ( que va a estar multiplicado o dividido, por decir cualquier cosa). El comportamiento será el esperado para ambos objetos porque te aseguraste de que implementan esta interfaz y se puede usar con confianza en otros lugares del código.

También te ayuda a que otros desarrolladores no utilicen esto en objetos que no cumplen esta interfaz por ejemplo algo como una Imagen o un pdf pero si en futuros objetos como una grabacion o una llamada de telefono.

Juan David Mantilla López

student•

Comparto este pequeño ejemplo un poco más simple pero consistente del polimorfismo. Espero les ayude :)

package main

import "fmt"

// Definimos la interfaz con la declaración del método que deben implementarlo
// el struct que lo necesite
type MakeSound interface {
	makeSound() string
}

// Función que, dependiendo de la interfaz implementada ejecutará un método u otro
func makeSound(makeSound MakeSound) {
	fmt.Print("\n", makeSound.makeSound())
}

type Cat struct {
	color string
}

// Implementa interfaz para struct de Cat
func (cat Cat) makeSound() string {
	return "Meow"
}

type Tiger struct {
	color string
}

// Implementa interfaz para struct de Tiger.
func (tiger Tiger) makeSound() string {
	return "Roughh!"
}

func main() {

	cat := Cat{}
	tiger := Tiger{}

	makeSound(cat)   // Aquí deberá ejecutar la función de makeSound de Cat.
	makeSound(tiger) // Aquí deberá ejecutar la función de makeSound de Tiger.
}
```package main import "fmt" // Definimos la interfaz con la declaración del método que deben implementarlo // el struct que lo necesite type MakeSound interface { makeSound() string } // Función que, dependiendo de la interfaz implementada ejecutará un método u otro func makeSound(makeSound MakeSound) { fmt.Print("\n", makeSound.makeSound()) } type Cat struct { color string } // Implementa interfaz para struct de Cat func (cat Cat) makeSound() string { return "Meow" } type Tiger struct { color string } // Implementa interfaz para struct de Tiger. func (tiger Tiger) makeSound() string { return "Roughh!" } func main() { cat := Cat{} tiger := Tiger{} makeSound(cat) // Aquí deberá ejecutar la función de makeSound de Cat. makeSound(tiger) // Aquí deberá ejecutar la función de makeSound de Tiger. }

Willem Franco

student•

Si no queda muy claro lo de interfaces, básicamente es un plano, igual que los structs pero en lugar de enfocarse en los datos (estructura), se enfoca en las acciones (métodos). Ya que no existe implementación en go, al utilizar la interface como parámetro (como el caso de getMessage), validará cualquier estructura que cumpla con el plano, es decir, que contenga todos los métodos de la interface.

Axel Bau

student•

Comparto mi codigo

package main

import "fmt"

type Person struct {
	name string
	age  int
}

type Employee struct {
	id int
}

// Composicion de herencia, se agrega el tipo de objeto
type FullTimeEmployee struct {
	Person
	Employee
	yearsExperience int
}
type HalfTimeEmployee struct {
	Person
	Employee
	internship bool
}

//Constructores

func NewFullTimeEmployee(name string, age int, id int, yearExperience int) *FullTimeEmployee {
	return &FullTimeEmployee{
		Person: Person{
			name: name,
			age:  age,
		},
		Employee: Employee{
			id: id,
		},
		yearsExperience: yearExperience,
	}
}

func (ftEmployee *FullTimeEmployee) GetMesagge() {
	fmt.Printf("FullTimeEmployee's Name :%s  with a age %d and him/her id is %d with %d years of experience\n", ftEmployee.name, ftEmployee.age, ftEmployee.id, ftEmployee.yearsExperience)
}

func NewHalfTimeEmployee(name string, age int, id int, internship bool) *HalfTimeEmployee {
	return &HalfTimeEmployee{
		Person: Person{
			name: name,
			age:  age,
		},
		Employee: Employee{
			id: id,
		},
		internship: internship,
	}
}

func (htEmployee *HalfTimeEmployee) GetMesagge() {
	fmt.Printf("HalfTimeEmployee's Name: %s, Age: %d, ID: %d, Internship: %t\n", htEmployee.name, htEmployee.age, htEmployee.id, htEmployee.internship)
}

type PrintInfo interface {
	GetMesagge()
}

func PrintData(p PrintInfo) {
	p.GetMesagge()
}

func main() {
	ft := NewFullTimeEmployee("Axel", 22, 1, 2)
	ht := NewHalfTimeEmployee("Alexis", 22, 2, true)
	PrintData(ft)
	PrintData(ht)
}

Axel Bau

student•

Comparto mi codigo con implemetacion de constructores con interfacespackage main import "fmt" type Person struct { name string age int} type Employee struct { id int} // Composicion de herencia, se agrega el tipo de objetotype FullTimeEmployee struct { Person Employee yearsExperience int}type HalfTimeEmployee struct { Person Employee internship bool} //Constructores func NewFullTimeEmployee(name string, age int, id int, yearExperience int) *FullTimeEmployee { return &FullTimeEmployee{ Person: Person{ name: name, age: age, }, Employee: Employee{ id: id, }, yearsExperience: yearExperience, }} func (ftEmployee *FullTimeEmployee) GetMesagge() { fmt.Printf("FullTimeEmployee's Name :%s with a age %d and him/her id is %d with %d years of experience\n", ftEmployee.name, ftEmployee.age, ftEmployee.id, ftEmployee.yearsExperience)} func NewHalfTimeEmployee(name string, age int, id int, internship bool) *HalfTimeEmployee { return &HalfTimeEmployee{ Person: Person{ name: name, age: age, }, Employee: Employee{ id: id, }, internship: internship, }} func (htEmployee *HalfTimeEmployee) GetMesagge() { fmt.Printf("HalfTimeEmployee's Name: %s, Age: %d, ID: %d, Internship: %t\n", htEmployee.name, htEmployee.age, htEmployee.id, htEmployee.internship)} type PrintInfo interface { GetMesagge()} func PrintData(p PrintInfo) { p.GetMesagge()} func main() { ft := NewFullTimeEmployee("Axel", 22, 1, 2) ht := NewHalfTimeEmployee("Alexis", 22, 2, true) PrintData(ft) PrintData(ht)}

package main

import "fmt"

type Person struct {
	name string
	age  int
}

type Employee struct {
	id int
}

// Composicion de herencia, se agrega el tipo de objeto
type FullTimeEmployee struct {
	Person
	Employee
	yearsExperience int
}
type HalfTimeEmployee struct {
	Person
	Employee
	internship bool
}

//Constructores

func NewFullTimeEmployee(name string, age int, id int, yearExperience int) *FullTimeEmployee {
	return &FullTimeEmployee{
		Person: Person{
			name: name,
			age:  age,
		},
		Employee: Employee{
			id: id,
		},
		yearsExperience: yearExperience,
	}
}

func (ftEmployee *FullTimeEmployee) GetMesagge() {
	fmt.Printf("FullTimeEmployee's Name :%s  with a age %d and him/her id is %d with %d years of experience\n", ftEmployee.name, ftEmployee.age, ftEmployee.id, ftEmployee.yearsExperience)
}

func NewHalfTimeEmployee(name string, age int, id int, internship bool) *HalfTimeEmployee {
	return &HalfTimeEmployee{
		Person: Person{
			name: name,
			age:  age,
		},
		Employee: Employee{
			id: id,
		},
		internship: internship,
	}
}

func (htEmployee *HalfTimeEmployee) GetMesagge() {
	fmt.Printf("HalfTimeEmployee's Name: %s, Age: %d, ID: %d, Internship: %t\n", htEmployee.name, htEmployee.age, htEmployee.id, htEmployee.internship)
}

type PrintInfo interface {
	GetMesagge()
}

func PrintData(p PrintInfo) {
	p.GetMesagge()
}

func main() {
	ft := NewFullTimeEmployee("Axel", 22, 1, 2)
	ht := NewHalfTimeEmployee("Alexis", 22, 2, true)
	PrintData(ft)
	PrintData(ht)
}

Francisco Alejandro Gutierrez Flores

student•

Hola! Los invito a "jugar" con el siguiente código, ver cómo se comporta solo con el primer método (comentando los últimos 2 SIN comentar las correspondientes llamadas) antes de pasar a interfaces. (Go 1.22.1)

package main

import "fmt"

type Person struct {
	Name string
	Age  int
}

type Employee struct {
	Person // Embedding
	id     int
}

type Developer struct {
	Employee // Embedding
	Language string
}

func (p *Person) GetBdayMsj() string {
	return fmt.Sprintf("Hi %s. Congratulations! on your %dth birthday", p.Name, p.Age)
}

func (e *Employee) GetBdayMsj() string {
	return fmt.Sprintf("Hi %s. Congratulations! on your %dth birthday. Your employee id is %d", e.Name, e.Age, e.id)
}

func (d *Developer) GetBdayMsj() string {
	return fmt.Sprintf("Hi %s. Congratulations! on your %dth birthday. I see you are a %s developer", d.Name, d.Age, d.Language)
}

func main() {
	dev := Developer{
		Employee: Employee{
			Person: Person{
				Name: "John",
				Age:  25,
			},
			id: 1,
		},
		Language: "Go",
	}

	fmt.Println(dev.Person.GetBdayMsj())
	fmt.Println(dev.Employee.GetBdayMsj())
	fmt.Println(dev.GetBdayMsj())
}

Francisco Alejandro Gutierrez Flores

student•

se puede deducir que Developer SI es un Employee y SI es un Person, y además puede crearse el override del método

Johan Andrés Sabino Castro

student•

Genial lo que he podido recordar de TS., pero para quienes no conocen de JS o TS, siento podría ser un poco engorroso tener que ver media clase de un lenguaje al cual no le están apuntando. Por lo demás, muy bien explicado.

Victor Hugo Cruz Carballo

student•

package main

import "fmt"

type Person struct {
	name string
	age  uint8
	sex  string
}

type PrintInfo interface {
	getMessage() string
}
type Employee struct {
	id uint64
}

type FullTimeEmployee struct {
	Person
	Employee
	endTime int
}

func (ftEmployee FullTimeEmployee) getMessage() string {
	return "Este es un fulltimeEmployee"
}

type TemporaryEmployee struct {
	Person
	Employee
	taxRate string
}

func (tEmployee TemporaryEmployee) getMessage() string {
	return "Este es un TemporaryEmployee"
}

func getMessage(p PrintInfo) {
	fmt.Printf("%+v\n", p.getMessage())
}

func main() {
	ftEmployee := FullTimeEmployee{}
	ftEmployee.name = "Carlos"
	ftEmployee.age = 25
	ftEmployee.id = 1
	ftEmployee.sex = "hombre"
	fmt.Printf("%+v\n", ftEmployee)

	tEmployee := TemporaryEmployee{}
	fmt.Printf("%+v\n", tEmployee)

	getMessage(ftEmployee)
	getMessage(tEmployee)

}