Отразить в списке интерфейсов

Question

Я прочитал несколько примеров / вопросов об отражении в 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 ...

Полный пример на Go Playground .

Answer 1

Пожалуйста, не используйте ваш текущий подход. У него есть несколько недостатков.

1. Это сбивает с толку (как вы обнаружили)
2. Это медленно. Отражение всегда медленное.
3. Это негибко. Ваш цикл, а не сам тип, должен понимать возможности реализации каждого типа.

Вместо этого просто расширьте свой интерфейс, включив в него метод установки - возможно, дополнительный метод установки. Затем вы можете перебирать элементы и устанавливать значения для тех, кто их поддерживает. Пример:

// 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, вам совсем не нужно изменять цикл.

Answer 2

Здесь есть несколько проблем. Во-первых, невозможно установить неэкспортированное поле. Вот изменение для экспорта поля:

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

Запустите его на детской площадке

Вышеприведенное отвечает на вопрос, но, возможно, это не лучшее решение для реальной проблемы. Лучшим решением может быть определение интерфейса установки:

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

Запустите его на детской площадке