Iteruj przez pola struktury w Go

Zasadniczo jedyny sposób (jaki znam) na iterację wartości pól a structjest taki:

type Example struct {
    a_number uint32
    a_string string
}

//...

r := &Example{(2 << 31) - 1, "...."}:
for _, d:= range []interface{}{ r.a_number, r.a_string, } {
  //do something with the d
}

Zastanawiałem się, czy istnieje lepszy i bardziej wszechstronny sposób osiągnięcia tego celu []interface{}{ r.a_number, r.a_string, }, więc nie muszę osobno wymieniać każdego parametru, czy też alternatywnie, czy istnieje lepszy sposób na zapętlenie przez strukturę?

Próbowałem przejrzeć reflectpaczkę, ale uderzyłem w ścianę, ponieważ nie jestem pewien, co zrobić po odzyskaniu reflect.ValueOf(*r).Field(0).

Dzięki!

Po pobraniu reflect.Valuepola za pomocą Field(i)można uzyskać z niego wartość interfejsu, wywołując Interface(). Wspomniana wartość interfejsu reprezentuje wówczas wartość pola.

Nie ma funkcji do konwersji wartości pola na konkretny typ, ponieważ, jak być może wiesz, nie ma żadnych typów ogólnych. Tak więc, nie ma funkcji z podpisem GetValue() T z Tbycia typem tej dziedzinie (która zmienia się oczywiście w zależności od dziedziny).

Najbliższe jest GetValue() interface{}to, co możesz osiągnąć w ruchu i właśnie to reflect.Value.Interface() oferuje.

Poniższy kod ilustruje, jak uzyskać wartości każdego eksportowanego pola w strukturze przy użyciu refleksji ( odtwarzania ):

import (
    "fmt"
    "reflect"
)

func main() {
    x := struct{Foo string; Bar int }{"foo", 2}

    v := reflect.ValueOf(x)

    values := make([]interface{}, v.NumField())

    for i := 0; i < v.NumField(); i++ {
        values[i] = v.Field(i).Interface()
    }

    fmt.Println(values)
}

Jeśli chcesz iterować przez pola i wartości struktury, możesz użyć poniższego kodu Go jako odniesienia.

package main

import (
    "fmt"
    "reflect"
)

type Student struct {
    Fname  string
    Lname  string
    City   string
    Mobile int64
}

func main() {
    s := Student{"Chetan", "Kumar", "Bangalore", 7777777777}
    v := reflect.ValueOf(s)
    typeOfS := v.Type()

    for i := 0; i< v.NumField(); i++ {
        fmt.Printf("Field: %s\tValue: %v\n", typeOfS.Field(i).Name, v.Field(i).Interface())
    }
}

Biegnij na placu zabaw

Uwaga: Jeśli pola w twojej strukturze nie są eksportowane, v.Field(i).Interface()wywoła panikępanic: reflect.Value.Interface: cannot return value obtained from unexported field or method.

Przyjmowanie roztworu Chetan Kumar i na wypadek konieczności zastosowania się domap[string]int

package main

import (
    "fmt"
    "reflect"
)

type BaseStats struct {
    Hp           int
    HpMax        int
    Mp           int
    MpMax        int
    Strength     int
    Speed        int
    Intelligence int
}

type Stats struct {
    Base map[string]int
    Modifiers []string
}

func StatsCreate(stats BaseStats) Stats {
    s := Stats{
        Base: make(map[string]int),
    }

    //Iterate through the fields of a struct
    v := reflect.ValueOf(stats)
    typeOfS := v.Type()

    for i := 0; i< v.NumField(); i++ {
        val := v.Field(i).Interface().(int)
        s.Base[typeOfS.Field(i).Name] = val
    }
    return s
}

func (s Stats) GetBaseStat(id string) int {
    return s.Base[id]
}


func main() {
    m := StatsCreate(BaseStats{300, 300, 300, 300, 10, 10, 10})

    fmt.Println(m.GetBaseStat("Hp"))
}