¿Cuáles son algunos ejemplos de interfaces Go?

Question

Encontré an interesting blog post sobre Go.

Estoy tratando de entender el concepto de interfaces, pero me resulta muy difícil hacerlo desde el fragmento de código en la publicación del blog, y casi imposible desde the language specification.

¿Alguien puede señalar un ejemplo simple de las interfaces de Go en un programa en funcionamiento?

Answer 1

Es un ejercicio de aprendizaje de trabajo en progreso, y ciertamente un pobre ejemplo de buen estilo, pero here you go (spec).

Además, como un ejemplo más exótico, hice a post en la lista de correo Ir-tuercas en relación con el uso de la interfaz {} para las funciones de construcción que trabajan con datos anónimos (en este caso, una función "operación ternaria"):

package main 
import "fmt"; 
func Tern(exp bool, a interface{}, b interface{}) (interface{}) { 
    if exp { return a } 
    return b 
} 
func main() { 
    a := 7; b := 1; 
    result := Tern(a > b, a, b); 
    fmt.Printf("%d\n", result); 
} 

Answer 2

El concepto base de interfaces en Go, es que cualquier objeto que implemente un método definido como una interfaz, puede ser parte de esa interfaz.

El mejor ejemplo es la interfaz Writer. Rob Pike tiene un ejemplo de esto en su discurso introductorio en Google Tech Talk (http://www.youtube.com/watch?v=rKnDgT73v8s) - desplácese a 33:25 en el discurso para su explicación.

Answer 3

package main 

type Stringer interface { 
    String() string 
} 

type pie int 
type pizza string 

func (p pie) String() string{ 
    return "pie" 
} 

func (p pizza) String() string{ 
    return "pizza" 
} 

func main(){ 
    var a pie 
    var b pizza 
    fmt.Println(a,b) //fmt.Println() will look for Stringers and call their String() method. 
} 

Answer 4

el tutorial "Interfaces in Go - Part 2: Aiding adaptable, evolutionary design" (enero de 2012, de Sathish VJ) menciona claramente la principal ventaja para las interfaces en Ir:

interfac de Go No son una variante de las interfaces Java o C#, son mucho más.
Son una clave para la programación a gran escala y adaptable, diseño evolutivo.

Ver este ejemplo, a partir del mismo artículo, sobre perspectiva diferente (interfaz) para un autobús:

package main 

import "fmt" 

//Go Step 1: Define your data structures 
type Bus struct { 
    l, b, h int 
    rows, seatsPerRow int 
} 

//Go Step 2: Define a real world abstraction that could use the data we structure we have 
type Cuboider interface { 
    CubicVolume() int 
} 

//Go Step 3: Implement methods to work on data 
func (bus Bus) CubicVolume() int { 
    return bus.l * bus.b * bus.h 
} 

//Go step - repeat 2 & 3 for any other interfaces 
type PublicTransporter interface { 
    PassengerCapacity() int 
} 

func (bus Bus) PassengerCapacity() int { 
    return bus.rows * bus.seatsPerRow 
} 

func main() { 
    b := Bus{ 
      l:10, b:6, h:3, 
      rows:10, seatsPerRow:5} 

    fmt.Println("Cubic volume of bus:", b.CubicVolume()) 
    fmt.Println("Maximum number of passengers:", b.PassengerCapacity()) 
} 

Parece ser datos céntricas - definir sus datos primero y construir sus abstracciones de interfaz a medida que avanza.
La jerarquía aquí se construye "en el camino" sin indicarlo explícitamente; según las firmas de método asociadas con el tipo, se entiende que implementa interfaces específicas.

Supongamos ahora que a medida que el tiempo evolucionó, algunos de los requisitos del proyecto para nuestro autobús cambiaron: ahora hay una nueva ley que establece que cada pasajero debe tener al menos una cierta cantidad mínima de volumen cúbico.
Nuestro autobús ahora ahora tiene que adherirse a una nueva interfaz llamada PersonalSpaceLaw que es distinto de cualquiera de las otras interfaces que ya implementa

//new requirement that the Bus must be compatible with 
type PersonalSpaceLaw interface { 
    IsCompliantWithLaw() bool 
} 

func (b Bus) IsCompliantWithLaw() bool { 
    return (b.l * b.b * b.h)/(b.rows * b.seatsPerRow) >= 3 
} 

La funcionalidad se ha extendido sin ningún cambio en las clases básicas o jerarquías centrales. Esta implementación es mucho más limpia, fácilmente extensible y puede escalarse mejor con las necesidades cambiantes de los requisitos del proyecto.

Aquí es el full working program in Go Playground

El artículo termina con la cita de John Asmuth a partir del hilo sobre la productividad de las interfaces en Ir:

"Es el hecho de que no lo hago Tengo que pasar tiempo diseñando una especie de jerarquía de tipos y reorganizándola dos o tres veces antes de terminar.
Ni siquiera es fácil de hacerlo bien -
es el hecho de que simplemente no tengo que preocuparme por eso y puedo seguir con el algoritmo real. "

Answer 5

Wikipedia explica pato-escribir y tiene un ejemplo en el Go http://en.wikipedia.org/wiki/Duck_typing