Clase 21 de 34 • Curso de Programación en Go 2016
Contenido del curso
Luis Quintanilla
Elvis Sánchez
Cristian Orlando Rincon Bonilla
Equipo Mecubro
Dayana Morente
Mario Menjívar
Iván Toro
Qenta SAS
Oscar Alejandro Becerra Cervantes
Edgar de Jesus Mendoza Ortegon
Miguel ANGEL CULEBRAS MOSET
Paolo Donato Torregrosa Navarro
Daniel Zambrano
Sergio Alexander Florez Galeano
Jose L. Figueroa
Juanse Calviño
Juanse Calviño
Diego Forero
Mario Ruíz
David Arce
Joshua Mora
William Martinez
Alexander Armúa Abregu
No dudo que sepa mucho el lenguaje go, pero metologia de enseñanza les falta platzi, buenos programadores en sus cursoso pocos profesores que sepan enseñar con metodologia la programacion. Saludos.
Muuuuuuuy cierto.
Es bien confusa su forma de explicar
El código desprolijo y los ejemplos super confusos, da la impresión que ni siquiera sabe lo que está explicando.
+1
Creo que provoca confusión la creación del método callSuscribe() para explicar que son realmente las interfaces.
Cómo se menciona en el video, se utilizan para una especie de “normalización” de tus estructuras.
Chequen mi código:
Y pueden darle un vistazo a esto por si a más de alguno no le termino de cuadrar:
package structs type Platzi interface { Subscribe(name string) } func Interfaces(){ course := Course{name: "Go", class: 50, skills: []string{"Backend"}} carrer := new(Carrer) carrer.name = "Go carrer" carrer.class = 150 name := "Ivan" callSubscribe(carrer, name) callSubscribe(course, name) } func callSubscribe(duck Platzi, name string){ duck.Subscribe(name) }
package estructuras // Platzi es una interfaz para subscribe type Platzi interface { Subscribe(name string) } // InterfaceTest recibe los metodos "Estudio" y "Carrera" para hacer una estructura independiente de cada uno func InterfaceTest() { ObjetoInterface := new(Estudio) ObjetoInterface.Name = "Interfaces" ObjetoInterface.Persona = "Zerofelx" ObjetoInterface.Skills = []string{"Probando", "Esta", "Wea"} objetoCurso3 := new(Carrera) objetoCurso3.Name = "Interfaces" objetoCurso3.Slug = "Interfaces" objetoCurso3.Url = "www.youtube.com" callSubscribe(ObjetoInterface) callSubscribe(objetoCurso3) } func callSubscribe(p Platzi) { p.Subscribe("Zerofelx") }
De acuerdo, según lo que nos va explicando, Go no funciona como debería funcionar un lenguaje orientado a objetos (POO)
Un ejemplo claro es el Interfaz. A diferencia de otros lenguajes que si son POO, aquí no se usa el keyword "implement". Las estructuras nunca se va a juntar con las interfaces, lo que las une son las funciones. ¿Como funciona?
package main import "fmt" //Creamos dos estructuras type Perro struct { Nombre string } type Gato struct { Nombre string } /*Ambos pueden saludar porque son Animales asi que las funciones estaran en la interface Animal */ type Animal interface{ Saludar() } /*Como ya tenemos la funcion vacia lo que haremos es "llenarla" o escribir como funcionara para cada animal (el Gato y el Perro)*/ func (g Gato) Saludar(){ fmt.Printf("Hola yo soy %s \n", g.Nombre) } func (p Perro) Saludar(){ fmt.Printf("Hola yo soy %s \n", p.Nombre) } /* Ahora la interface ya esta conectada con cada estructura por medio de estas funciones, por lo que puedes crear una funcion para aquellas estructuras que sean de interface Animal, (Gato y Perro) */ func Presentarse (a Animal){ a.Saludar() //Recuerden que Saludar pertenece a Animal } //Ahora ya podemos darle uso en main func main(){ gato := Gato{ Nombre: "Susan" } perro := Perro { Nombre: "Chester" } Presentarse(perro) Presentarse(gato) /*Salida: Hola yo soy Susan Hola yo soy Chester */ }
Espero haberme explicado, de cualquier manera le dejo el link que un usuario llamado PaoloTorregrosa: Go interfaces by GoByExample
Esta un poco confuso este tema
Un poco confuso.
Este tema puede resultar un poco comlejo pero aqui hay una info interesante En resumen una interfas es un conjunto de metodos que se pueden implementar de maneras diferentes dependiendo el struct, algo similar al polimorfismo de la POO
Hola Paolo,
Agregando mi granito de arena, no considero que el ejemplo de polimofirsmo sea adecuado en este caso.
Basado en lo que es SOLID. Polimorfismo viene siendo el principio de sustitución de liskov, dígase, si tu método recibe un objeto Animal Puedes usar como parámetro cualquier instancia que sea hijo de Animal
,
Lo que esta explicando aquí con interfaces, viene siendo Dependency Inversion Principle, tus argumentos NO tienen que estas relacionados con la herencia. Pero aun puede ser usados como parámetros. Ejemplo: Una interfaz “Medible” con Peso, y un objeto “Silla” y otro “Perro” podrías decir que tienes
CostoDeEnvio(obj Medible)
Si aun hay alguna duda con esto, mas que feliz de desarrollar mas la idea
Comparto el código de mi ejercicio:
package main import ( "fmt" ) type Course struct { Name string Slug string Skills [] string } func (p Course) Subscribe (name string) { fmt.Printf("La persona %s se ha registrado al curso %s\n", name, p.Name) } type Carrer struct { Course } func (p Carrer) Subscribe (name string) { fmt.Printf("La persona %s se ha registrado a la carrera %s\n", name, p.Name) } // An interface for Course and Carrer type Organization interface { Subscribe(name string) } func callSubscribe(p Organization) { p.Subscribe("XergioAleX") } func main() { goCourse := Course{ Name: "Go", Slug: "go", Skills: [] string { "1", "2" } } goCarrer := new(Carrer) goCarrer.Name = "GoCarrer" goCarrer.Slug = "go" callSubscribe(goCourse) callSubscribe(goCarrer) }
Todo el código del curso aquí:
Comparto mi ejercicio:
// ------------- main.go func main() { structs.InterfaceTest() } // -------------- interface.go package structs //Paltzi es una interface de PlatziCourse y PlatziCareer type Platzi interface { Subscribe(name string) } func InterfaceTest() { platziCareer := PlatziCareer{ Career: "Desarrollador GO", Course: PlatziCourse{Name: "Go", Slug: "/cursos/go", Teacher: PlatziInstructor{Name: "Yohan Graterol", ProfilePicture: "yohan-graterol.jpg", TeachesCourses: []string{"Intruducción a Go", "Go", "Bases de Datos con MongoDB"}}, Skills: []string{"Desarrollo Backend", "Desarrollo Templates"}}, } platziCourse := PlatziCourse{Name: "Go", Slug: "/cursos/go", Teacher: PlatziInstructor{Name: "Yohan Graterol", ProfilePicture: "yohan-graterol.jpg", TeachesCourses: []string{"Intruducción a Go", "Go", "Bases de Datos con MongoDB"}}, Skills: []string{"Desarrollo Backend", "Desarrollo Templates"}} //platziCareer.Subscribe("JoseL") callSuscribe(platziCareer) callSuscribe(platziCourse) //fmt.Println(platziCareer) } func callSuscribe(p Platzi) { p.Subscribe("JoseL") } // ---------------- structs.go //Struct PlatziCourse type PlatziCourse struct { Name string Slug string Teacher PlatziInstructor Skills []string } //Struct PlatziInstructor type PlatziInstructor struct { Name string ProfilePicture string TeachesCourses []string } //Subscribe es un método de PlatziCareer func (p PlatziCourse) Subscribe(name string) { fmt.Printf("La persona %s se ha registrado al curso %s:\n", name, p.Name) } //Struct PlatziCareer es una estructura type PlatziCareer struct { Career string Course PlatziCourse } //Subscribe es un método de PlatziCareer func (p PlatziCareer) Subscribe(name string) { fmt.Printf("La persona %s se ha registrado a la carrera %s:\n", name, p.Career) }
Hola Yohan, intenté replicar el ejercicio del video, pero en el archivo interface.go me dice que no reconoce las structs platziCourse y platziCareer. En qué parte del programa hay que decirles que pertenecen a la interface?
Saludos!
interface.go
package structs // -- Interface Platzi para PlatziCourse y PlatziCareer type Platzi interface { Suscribe(name string) } func InterfaceTest() { platziCourse := PlatziCourse{Name: "Go", Slug: "go", Skills: []string{"backend"}} platziCareer := new(PlatziCareer) platziCareer.Name = "Carrera Go" platziCareer.Slug = "go" callSuscribe(platziCareer) callSuscribe(platziCourse) } func callSuscribe(p Platzi) { p.Suscribe("Juan Sebastián Calviño") }
structs.go
package structs import "fmt" // -- STRUCTS -- type PlatziCourse struct { Name string Slug string // url del curso Skills []string } type PlatziCareer struct { PlatziCourse // -> De esta manera decimos que PlatziCareer va a tomar todos los valores de PlatziCourse, como una herencia } // -- MÉTODO -- func (p PlatziCourse) Subscribe(name string) { fmt.Printf("El usuario %s, se ha inscripto al curso de %s\n", name, p.Name) } func (p PlatziCareer) Subscribe(name string) { fmt.Printf("El usuario %s, se ha inscripto a la carrera de %s\n", name, p.Name) }
Este el error:
structs\interface.go:14: cannot use platziCareer (type *PlatziCareer) as type Platzi in argument to callSuscribe:
*PlatziCareer does not implement Platzi (missing Suscribe method)
structs\interface.go:15: cannot use platziCourse (type PlatziCourse) as type Platzi in argument to callSuscribe:
PlatziCourse does not implement Platzi (missing Suscribe method)
Tienes un error de digitación. es Subscribe y estas llamando como Suscribe
tranquilos es lo mas confuso de todos los lenguajes es normal
Muy confusa esta clase, el problema para mí es que se tomó muy mal un ejemplo base para explicar cómo es el funcionamiento de las interfaces.
En resumen y para que quede claro una interface en la mayoría de los lenguajes nos sirve como un contrato en el cual objetos o en este caso structs pueden implementarla según su propia lógica o comportamiento.
El ejemplo práctico en go es la interface geometry que define una firma de métodos que se pueden implementar en figuras como circle o rect
type geometry interface { area() float64 perim() float64 }
Luego podemos implementar estos métodos:
type rect struct { width, height float64 } type circle struct { radius float64 } // implement geometry on rects. func (r rect) area() float64 { return r.width * r.height } func (r rect) perim() float64 { return 2*r.width + 2*r.height } //The implementation for circles. func (c circle) area() float64 { return math.Pi * c.radius * c.radius } func (c circle) perim() float64 { return 2 * math.Pi * c.radius }
Y podemos definir una función que sirva para ambas structs
func measure(g geometry) { fmt.Println(g) fmt.Println(g.area()) fmt.Println(g.perim()) } func main() { r := rect{width: 3, height: 4} c := circle{radius: 5} measure(r) measure(c) }
No entiendo nada estoy muy confundido, y con sus ejemplos en mi codigo tengo errores que no se solucionar
Puede ser un tema muy dificil sobre todo si el lenguaje no es orientado a objetos. Pero hay que entender que las interfaces nos pueden ayudar a definir un comportamiento en comun que puedan tener diferentes structs. Como por ejemplo lo siguiente:
package main import "fmt" // Song struct type Song struct { Name string Artist string } // Video struct type Video struct { Name string Duration int } // Media interface type Media interface { Play() } // Play function to play the song func (s Song) Play() { fmt.Printf("Playing song %s... \n", s.Name) } // Play function to play the video func (m Video) Play() { fmt.Printf("Playing video %s... \n", m.Name) } // PlayMedia the media content func PlayMedia(m Media) { m.Play() } func main() { song := Song{Name: "La cancion", Artist: "Bad Bunny"} video := Video{Name: "Top lenguajes de programacion", Duration: 830} PlayMedia(song) PlayMedia(video) }
Tanto la estructura Song como Video tienen una funcion en comun que es Play, entonces podemos usar una interface llamada Media que agrupe las funciones en comun y la utilicemos con structs que tengan esa funcion (como Song y Video).
Por si les interesa modificar un valor dentro de la estructura, Tienen que hacerlo haciendo uso de punteros. Ejemplo:
type Heroe struct { Nombre string Clase string Skills []string } func (p *Heroe) NewSkill(skill string) { p.Skills = append(p.Skills, skill) fmt.Printf("El heroe %s ha aprendido la skill %s\n", p.Nombre, skill) }
