我熟悉这样一个事实，即在 Go 中，接口定义功能，而不是数据。您将一组方法放入一个接口中，但您无法指定实现该接口的任何内容所需的任何字段。

例如：

// Interface
type Giver interface {
    Give() int64
}

// One implementation
type FiveGiver struct {}

func (fg *FiveGiver) Give() int64 {
    return 5
}

// Another implementation
type VarGiver struct {
    number int64
}

func (vg *VarGiver) Give() int64 {
    return vg.number
}

现在我们可以使用接口及其实现：

// A function that uses the interface
func GetSomething(aGiver Giver) {
    fmt.Println("The Giver gives: ", aGiver.Give())
}

// Bring it all together
func main() {
    fg := &FiveGiver{}
    vg := &VarGiver{3}
    GetSomething(fg)
    GetSomething(vg)
}

/*
Resulting output:
5
3
*/

现在，你不能做的是这样的事情：

type Person interface {
    Name string
    Age int64
}

type Bob struct implements Person { // Not Go syntax!
    ...
}

func PrintName(aPerson Person) {
    fmt.Println("Person's name is: ", aPerson.Name)
}

func main() {
    b := &Bob{"Bob", 23}
    PrintName(b)
}

然而，在玩弄接口和嵌入式结构之后，我发现了一种方法来做到这一点，以一种时尚的方式：

type PersonProvider interface {
    GetPerson() *Person
}

type Person struct {
    Name string
    Age  int64
}

func (p *Person) GetPerson() *Person {
    return p
}

type Bob struct {
    FavoriteNumber int64
    Person
}

由于嵌入了结构体，Bob 拥有 Person 的一切。它还实现了 PersonProvider 接口，因此我们可以将 Bob 传递给旨在使用该接口的函数。

func DoBirthday(pp PersonProvider) {
    pers := pp.GetPerson()
    pers.Age += 1
}

func SayHi(pp PersonProvider) {
    fmt.Printf("Hello, %v!\r", pp.GetPerson().Name)
}

func main() {
    b := &Bob{
        5,
        Person{"Bob", 23},
    }
    DoBirthday(b)
    SayHi(b)
    fmt.Printf("You're %v years old now!", b.Age)
}

使用这种方法，我可以创建一个定义数据而不是行为的接口，并且任何结构都可以通过嵌入该数据来实现该接口。您可以定义与嵌入数据显式交互并且不知道外部结构的性质的函数。并且在编译时检查一切！（我可以看到，唯一可能搞砸的方法是将接口嵌入到PersonProvider中Bob，而不是具体的 中Person。它会在运行时编译并失败。）

现在，这是我的问题：这是一个巧妙的技巧，还是我应该以不同的方式做？