反映接口列表

时间:2018-05-07 15:32:08

标签: go reflection interface

我已经阅读了几个关于Go反思的例子/问题,但是我仍然无法理解我应该对我的界面列表做些什么。

下面是真实用例的精简版。

我有几种符合给定界面的类型:

type Foo interface {
    Value() int
}

type bar struct {
    value int
}

func (b bar) Value() int {
    return b.value
}

type baz struct{}

func (b baz) Value() int {
    return 42
}

我有这样的人员名单

type Foos []Foo
var foos = Foos{
    bar{},
    baz{},
}

我希望通过更改具有value字段的成员的值来遍历此列表。

    for k := range foos {
        change(&foos[k])
    }

但我无法找到合适的路径

func change(g *Foo) {
    t := reflect.TypeOf(g).Elem()
    fmt.Printf("t: Kind %v, %#v\n", t.Kind(), t)
    v := reflect.ValueOf(g).Elem()
    fmt.Printf("v: Kind %v, %#v, %v\n", v.Kind(), v, v.CanAddr())
    if f, ok := t.FieldByName("value"); ok {
        fmt.Printf("f: %#v, OK: %v\n", f, ok)
        vf := v.FieldByName("value")
        fmt.Printf("vf: %#v: %v\n", vf, vf.CanAddr())
        vf.SetInt(51)
    }
}

正如您所看到的,我不确定如何将TypeOf和ValueOf位粘合在一起......

full example is on Go Playground

2 个答案:

答案 0 :(得分:3)

这里有几个问题。首先,无法设置unexported字段。这是对导出字段的更改:

type Foo interface {
    // Rename Value to GetValue to avoid clash with Value field in bar
    GetValue() int
}

type bar struct {
    // export the field by capitalizing the name
    Value int
}

func (b bar) GetValue() int {
    return b.Value
}

type baz struct{}

func (b baz) GetValue() int {
    return 42
}

下一个问题是bar接口值无法寻址。要解决此问题,请在切片中使用*bar而不是bar

func (b *bar) GetValue() int {
    return b.Value
}

...

var foos = Foos{
    &bar{},
    baz{},
}

通过这些更改,我们可以编写函数来设置值:

func change(g Foo) {
    v := reflect.ValueOf(g)

    // Return if not a pointer to a struct.

    if v.Kind() != reflect.Ptr {
        return
    }
    v = v.Elem()
    if v.Kind() != reflect.Struct {
        return
    }

    // Set the field Value if found.

    v = v.FieldByName("Value")
    if !v.IsValid() {
        return
    }
    v.SetInt(31)
}

Run it on the playground

以上回答了这个问题,但它可能不是实际问题的最佳解决方案。更好的解决方案可能是定义一个setter接口:

type ValueSetter interface {
    SetValue(i int)
}

func (b *bar) Value() int {
    return b.value
}

func (b *bar) SetValue(i int) {
    b.value = i
}

func change(g Foo) {
    if vs, ok := g.(ValueSetter); ok {
        vs.SetValue(31)
    }
}

Run it on the playground

答案 1 :(得分:2)

请不要使用您当前的方法。它有几个缺点。

  1. 令人困惑(正如你发现的那样)
  2. 速度慢。反思总是很慢。
  3. 它不灵活。您的循环而不是类型本身必须了解每种类型实现的功能。
  4. 相反,只需扩展您的界面以包含一个setter方法 - 可能是一个可选的setter方法。然后,您可以遍历项目并为支持它的那些设置值。例如:

    // FooSetter is an optional interface which allows a Foo to set its value.
    type FooSetter interface {
        SetValue(int)
    }
    
    // SetValue implements the optional FooSetter interface for type bar.
    func (b *bar) SetValue(v int) {
        b.value = v
    }
    

    然后让你的循环看起来像这样:

    for _, v := range foos {
        if setter, ok := v.(FooSetter); ok {
            setter.SetValue(51)
        }
    }
    

    现在,当您(或图书馆的第三方用户)添加满足Baz界面的FooSetter类型时,您根本不必修改您的循环。