Quali sono alcuni esempi di interfacce Go?

Question

Ho trovato an interesting blog post su Go.

Sto cercando di capire il concetto di interfacce, ma trovo molto difficile farlo dal frammento di codice nel post del blog, e quasi impossibile da the language specification.

Qualcuno può indicare un semplice esempio delle interfacce di Go in un programma funzionante?

Answer 1

È un esercizio di apprendimento in corso, e certamente un cattivo esempio di stile, ma here you go (spec).

Inoltre, come un esempio più esotico, ho fatto a post sulla mailing list go-dadi per quanto riguarda utilizzando l'interfaccia {} per le funzioni di costruzione che lavorano con dati anonimi (in questo caso, una funzione di "operazione ternario"):

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

Il concetto di base delle interfacce in Go, è che qualsiasi oggetto che implementa un metodo definito un'interfaccia, può essere una parte di tale interfaccia.

L'esempio migliore è l'interfaccia di Writer. Rob Pike ne ha un esempio nel suo discorso introduttivo a Google Tech Talk (http://www.youtube.com/watch?v=rKnDgT73v8s) - scorrere fino a 33:25 nel discorso per la sua spiegazione.

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

il tutorial "Interfaces in Go - Part 2: Aiding adaptable, evolutionary design" (gennaio 2012, dalle Sathish VJ) menziona chiaramente il vantaggio principale per le interfacce a Go:

interfac Go non sono una variante su interfacce Java o C#, sono molto di più.
Sono una chiave per la programmazione su larga scala e adattabile, design evolutivo.

Guarda questo esempio, dal medesimo articolo, sulla prospettiva diversa (interfaccia) per un autobus:

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()) 
} 

Sembra essere dati centric - definire i dati prima e costruire le vostre astrazioni di interfaccia mentre vai avanti.
La gerarchia qui è di tipo "costruita" senza specificarlo esplicitamente - a seconda delle firme del metodo associate al tipo, si intende l'implementazione di interfacce specifiche. Supponiamo ora che, col passare del tempo, alcuni dei requisiti del progetto per il nostro Bus siano cambiati - ora c'è una nuova legge che dice che ogni passeggero dovrebbe avere almeno una certa quantità minima di volume cubico.
nostro bus ha ora ora aderire a una nuova interfaccia denominata PersonalSpaceLaw che è distinto da una qualsiasi delle altre interfacce che implementa già

//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 funzionalità è stata estesa senza modificare le classi principali o core gerarchie. Questa implementazione è molto più pulita, facilmente estendibile e può adattarsi meglio alle mutevoli esigenze dei requisiti del progetto.

Ecco la full working program in Go Playground

L'articolo termina con la citazione di John Asmuth dal dal thread sulla produttività delle interfacce in Go:

"E 'il fatto che non lo faccio passare del tempo a progettare una sorta di gerarchia di tipi e poi riorganizzarla due o tre volte prima di finire.
Non è nemmeno il fatto che sia facile farlo bene -
è il fatto che non devo preoccuparmene e posso andare avanti con l'algoritmo attuale. "

Answer 5

Wikipedia spiega anatra tipizzazione e ha un esempio in Go http://en.wikipedia.org/wiki/Duck_typing