Iterate through the fields of a struct in Go

huangapple
go评论110阅读模式
英文:

Iterate through the fields of a struct in Go

问题

基本上，我所知道的遍历struct字段值的唯一方法是这样的：

  1. type Example struct {
  2.     a_number uint32
  3.     a_string string
  4. }
  6. //...
  8. r := &Example{(2 << 31) - 1, "...."}
  9. for _, d := range []interface{}{r.a_number, r.a_string} {
  10.   //对d进行一些操作
  11. }

我想知道是否有更好、更灵活的方法来实现[]interface{}{r.a_number, r.a_string}，这样我就不需要逐个列出每个参数，或者是否有更好的方法来遍历一个struct？

我尝试查看了reflect包，但我遇到了困难，因为我不确定一旦我获取了reflect.ValueOf(*r).Field(0)后该怎么做。

谢谢！

英文:

Basically, the only way (that I know of) to iterate through the values of the fields of a struct is like this:

  1. type Example struct {
  2.     a_number uint32
  3.     a_string string
  4. }
  6. //...
  8. r := &amp;Example{(2 &lt;&lt; 31) - 1, &quot;....&quot;}:
  9. for _, d:= range []interface{}{ r.a_number, r.a_string, } {
  10.   //do something with the d
  11. }

I was wondering, if there's a better and more versatile way of achieving []interface{}{ r.a_number, r.a_string, }, so I don't need to list each parameter individually, or alternatively, is there a better way to loop through a struct?

I tried to look through the reflect package, but I hit a wall, because I'm not sure what to do once I retrieve reflect.ValueOf(*r).Field(0).

Thanks!

答案1

得分: 180

在使用Field(i)获取字段的reflect.Value之后，你可以通过调用Interface()方法从中获取一个接口值。该接口值表示字段的值。

由于Go语言中没有泛型，所以没有将字段的值转换为具体类型的函数。因此，没有带有签名GetValue() T的函数，其中T是字段的类型（当然，这取决于字段）。

在Go语言中，你可以最接近实现的是GetValue() interface{}，而这正是reflect.Value.Interface()提供的功能。

以下代码演示了如何使用反射获取结构体中每个导出字段的值（play链接）：

  1. import (
  2. 	"fmt"
  3. 	"reflect"
  4. )
  6. func main() {
  7. 	x := struct{ Foo string; Bar int }{"foo", 2}
  9. 	v := reflect.ValueOf(x)
  11. 	values := make([]interface{}, v.NumField())
  13. 	for i := 0; i < v.NumField(); i++ {
  14. 		values[i] = v.Field(i).Interface()
  15. 	}
  17. 	fmt.Println(values)
  18. }
英文:

After you've retrieved the reflect.Value of the field by using Field(i) you can get a
interface value from it by calling Interface(). Said interface value then represents the
value of the field.

There is no function to convert the value of the field to a concrete type as there are,
as you may know, no generics in go. Thus, there is no function with the signature GetValue() T
with T being the type of that field (which changes of course, depending on the field).

The closest you can achieve in go is GetValue() interface{} and this is exactly what reflect.Value.Interface()
offers.

The following code illustrates how to get the values of each exported field in a struct
using reflection (play):

  1. import (
  2. 	&quot;fmt&quot;
  3. 	&quot;reflect&quot;
  4. )
  6. func main() {
  7. 	x := struct{Foo string; Bar int }{&quot;foo&quot;, 2}
  9. 	v := reflect.ValueOf(x)
  11. 	values := make([]interface{}, v.NumField())
  13. 	for i := 0; i &lt; v.NumField(); i++ {
  14. 		values[i] = v.Field(i).Interface()
  15. 	}
  17. 	fmt.Println(values)
  18. }

答案2

得分: 103

如果你想遍历结构体的字段和值，你可以参考以下的Go代码：

  1. package main
  3. import (
  4.     "fmt"
  5.     "reflect"
  6. )
  8. type Student struct {
  9.     Fname  string
  10.     Lname  string
  11.     City   string
  12.     Mobile int64
  13. }
  15. func main() {
  16.     s := Student{"Chetan", "Kumar", "Bangalore", 7777777777}
  17.     v := reflect.ValueOf(s)
  18.     typeOfS := v.Type()
  20.     for i := 0; i < v.NumField(); i++ {
  21.         fmt.Printf("Field: %s\tValue: %v\n", typeOfS.Field(i).Name, v.Field(i).Interface())
  22.     }
  23. }

在playground上运行。

注意：如果你的结构体字段没有被导出，那么v.Field(i).Interface()会引发恐慌panic: reflect.Value.Interface: cannot return value obtained from unexported field or method.

英文:

If you want to Iterate through the Fields and Values of a struct then you can use the below Go code as a reference.

  1. package main
  3. import (
  4.     &quot;fmt&quot;
  5.     &quot;reflect&quot;
  6. )
  8. type Student struct {
  9.     Fname  string
  10.     Lname  string
  11.     City   string
  12.     Mobile int64
  13. }
  15. func main() {
  16.     s := Student{&quot;Chetan&quot;, &quot;Kumar&quot;, &quot;Bangalore&quot;, 7777777777}
  17.     v := reflect.ValueOf(s)
  18.     typeOfS := v.Type()
  20.     for i := 0; i&lt; v.NumField(); i++ {
  21.         fmt.Printf(&quot;Field: %s\tValue: %v\n&quot;, typeOfS.Field(i).Name, v.Field(i).Interface())
  22.     }
  23. }

Run in playground

Note: If the Fields in your struct are not exported then the v.Field(i).Interface() will give panic panic: reflect.Value.Interface: cannot return value obtained from unexported field or method.

答案3

得分: 35

Go 1.17（2021年第三季度）应该通过提交009bfea和CL 281233添加一个新选项，修复问题42782。

> ## reflect: 添加VisibleFields函数
>
> 在编写反射结构类型的代码时，通常需要知道完整的结构字段集，包括由于嵌入匿名成员而可用的字段，同时排除因为它们与另一个同名字段处于相同级别而被抹除的字段。
>
> 实现这个逻辑并不复杂，但有点微妙且容易出错。
>
> 这个CL在reflect包中添加了一个新的reflect.VisibleFields()函数，它返回适用于给定结构类型的完整字段集。

  1. fields := reflect.VisibleFields(typ)
  2. for j, field := range fields {
  3.     ...
  4. }

示例：

  1. type employeeDetails struct {
  2.     id          int16
  3.     name        string
  4.     designation string
  5. }
  6. func structIterator() {
  7. 	fields := reflect.VisibleFields(reflect.TypeOf(struct{ employeeDetails }{}))
  8. 	for _, field := range fields {
  9. 		fmt.Printf("Key: %s\tType: %s\n", field.Name, field.Type)
  10. 	}
  11. }
英文:

Go 1.17 (Q3 2021) should add a new option, through commit 009bfea and CL 281233, fixing issue 42782.

> ## reflect: add VisibleFields function
>
> When writing code that reflects over a struct type, it's a common requirement to know the full set of struct fields, including fields available due to embedding of anonymous members while excluding fields that are erased because they're at the same level as another field with the same name.
>
> The logic to do this is not that complex, but it's a little subtle and easy to get wrong.
>
> This CL adds a new reflect.VisibleFields() function to the reflect package that returns the full set of effective fields that apply in a given struct type.

  1. fields := reflect.VisibleFields(typ)
  2. for j, field := range fields {
  3.     ...
  4. }

Example,

  1. type employeeDetails struct {
  2.     id          int16
  3.     name        string
  4.     designation string
  5. }
  6. func structIterator() {
  7. 	fields := reflect.VisibleFields(reflect.TypeOf(struct{ employeeDetails }{}))
  8. 	for _, field := range fields {
  9. 		fmt.Printf(&quot;Key: %s\tType: %s\n&quot;, field.Name, field.Type)
  10. 	}
  11. }

答案4

得分: 7

也许有点晚了 :))) 但是还有另一种解决方案，你可以找到结构体的键和值，并对其进行迭代。

  1. package main
  3. import (
  4. 	"fmt"
  5. 	"reflect"
  6. )
  8. type person struct {
  9. 	firsName string
  10. 	lastName string
  11. 	iceCream []string
  12. }
  14. func main() {
  15. 	u := struct {
  16. 		myMap    map[int]int
  17. 		mySlice  []string
  18. 		myPerson person
  19. 	}{
  20. 		myMap:   map[int]int{1: 10, 2: 20},
  21. 		mySlice: []string{"red", "green"},
  22. 		myPerson: person{
  23. 			firsName: "Esmaeil",
  24. 			lastName: "Abedi",
  25. 			iceCream: []string{"Vanilla", "chocolate"},
  26. 		},
  27. 	}
  28. 	v := reflect.ValueOf(u)
  29. 	for i := 0; i < v.NumField(); i++ {
  30. 		fmt.Println(v.Type().Field(i).Name)
  31. 		fmt.Println("\t", v.Field(i))
  32. 	}
  33. }

并且对于 v.Field(i) 不会出现 panic。

英文:

Maybe too late :))) but there is another solution that you can find the key and value of structs and iterate over that

  1. package main
  3. import (
  4. 	&quot;fmt&quot;
  5. 	&quot;reflect&quot;
  6. )
  8. type person struct {
  9. 	firsName string
  10. 	lastName string
  11. 	iceCream []string
  12. }
  14. func main() {
  15. 	u := struct {
  16. 		myMap    map[int]int
  17. 		mySlice  []string
  18. 		myPerson person
  19. 	}{
  20. 		myMap:   map[int]int{1: 10, 2: 20},
  21. 		mySlice: []string{&quot;red&quot;, &quot;green&quot;},
  22. 		myPerson: person{
  23. 			firsName: &quot;Esmaeil&quot;,
  24. 			lastName: &quot;Abedi&quot;,
  25. 			iceCream: []string{&quot;Vanilla&quot;, &quot;chocolate&quot;},
  26. 		},
  27. 	}
  28. 	v := reflect.ValueOf(u)
  29. 	for i := 0; i &lt; v.NumField(); i++ {
  30. 		fmt.Println(v.Type().Field(i).Name)
  31. 		fmt.Println(&quot;\t&quot;, v.Field(i))
  32. 	}
  33. }
  1. and there is no *panic* for v.Field(i)

答案5

得分: 0

使用以下代码：

  1. type x struct {
  2.     Id  int
  3.     jsj int
  4. }
  6. func main() {
  7.     x2 := x{jsj: 10, Id: 5}
  8.     v := reflect.ValueOf(x2)
  9.     for i := 0; i < v.NumField(); i++ {
  10.         fmt.Println(v.Field(i))
  11.     }
  12. }

输出：

  1. 10
  2. 5
英文:

use this:

  1. type x struct {
  2. 	Id  int
  3. 	jsj int
  4. }
  5. func main() {
  6. 	x2 := x{jsj: 10, Id: 5}
  7. 	v := reflect.ValueOf(x2)
  8. 	for i := 0; i &lt; v.NumField(); i++ {
  9. 		fmt.Println(v.Field(i))
  10. 	}
  11. }

====>10

====>5

答案6

得分: -1

采用Chetan Kumar的解决方案，如果你需要应用到map[string]int类型的情况下：

  1. package main
  3. import (
  4. 	"fmt"
  5. 	"reflect"
  6. )
  8. type BaseStats struct {
  9. 	Hp           int
  10. 	HpMax        int
  11. 	Mp           int
  12. 	MpMax        int
  13. 	Strength     int
  14. 	Speed        int
  15. 	Intelligence int
  16. }
  18. type Stats struct {
  19. 	Base      map[string]int
  20. 	Modifiers []string
  21. }
  23. func StatsCreate(stats BaseStats) Stats {
  24. 	s := Stats{
  25. 		Base: make(map[string]int),
  26. 	}
  28. 	// 遍历结构体的字段
  29. 	v := reflect.ValueOf(stats)
  30. 	typeOfS := v.Type()
  32. 	for i := 0; i < v.NumField(); i++ {
  33. 		val := v.Field(i).Interface().(int)
  34. 		s.Base[typeOfS.Field(i).Name] = val
  35. 	}
  36. 	return s
  37. }
  39. func (s Stats) GetBaseStat(id string) int {
  40. 	return s.Base[id]
  41. }
  43. func main() {
  44. 	m := StatsCreate(BaseStats{300, 300, 300, 300, 10, 10, 10})
  46. 	fmt.Println(m.GetBaseStat("Hp"))
  47. }
英文:

Taking Chetan Kumar solution and in case you need to apply to a map[string]int

  1. package main
  3. import (
  4. 	&quot;fmt&quot;
  5. 	&quot;reflect&quot;
  6. )
  8. type BaseStats struct {
  9. 	Hp           int
  10. 	HpMax        int
  11. 	Mp           int
  12. 	MpMax        int
  13. 	Strength     int
  14. 	Speed        int
  15. 	Intelligence int
  16. }
  18. type Stats struct {
  19. 	Base map[string]int
  20. 	Modifiers []string
  21. }
  23. func StatsCreate(stats BaseStats) Stats {
  24. 	s := Stats{
  25. 		Base: make(map[string]int),
  26. 	}
  28. 	//Iterate through the fields of a struct
  29. 	v := reflect.ValueOf(stats)
  30. 	typeOfS := v.Type()
  32. 	for i := 0; i&lt; v.NumField(); i++ {
  33. 		val := v.Field(i).Interface().(int)
  34. 		s.Base[typeOfS.Field(i).Name] = val
  35. 	}
  36. 	return s
  37. }
  39. func (s Stats) GetBaseStat(id string) int {
  40. 	return s.Base[id]
  41. }
  44. func main() {
  45. 	m := StatsCreate(BaseStats{300, 300, 300, 300, 10, 10, 10})
  47. 	fmt.Println(m.GetBaseStat(&quot;Hp&quot;))
  48. }

答案7

得分: -1

使用reflect包。首先，使用reflect.TypeOf获取变量的类型，使用reflect.NumField获取字段的数量。要迭代地获取结构体字段的值，必须使用反射变量并使用函数rg.Elem().Field(i)。

  1. package main
  3. import (
  4. 	"fmt"
  5. 	"reflect"
  6. )
  8. type Gopher struct {
  9. 	Name  string
  10. 	Color string
  11. 	Year  int
  12. }
  14. func main() {
  15. 	g := Gopher{Name: "AAA", Color: "BBBB", Year: 2021}
  17. 	gtype := reflect.TypeOf(g)
  19. 	numFields := gtype.NumField()
  21. 	rg := reflect.ValueOf(&g)
  23. 	for i := 0; i < numFields; i++ {
  24. 		fmt.Println(rg.Elem().Field(i))
  25. 	}
  26. }
英文:

Use reflect package. First, get the type of variable with reflect.TypeOf and get numbers of elements with reflect.NumField.To obtain the values of the fields iteratively of a structure must reflect the variable and use the function rg.Elem().Field(i)

  1. package main
  3. import (
  4. 	&quot;fmt&quot;
  5. 	&quot;reflect&quot;
  6. )
  8. type Gopher struct {
  9. 	Name  string
  10. 	Color string
  11. 	Year  int
  12. }
  14. func main() {
  15. 	g := Gopher{Name: &quot;AAA&quot;, Color: &quot;BBBB&quot;, Year: 2021}
  17. 	gtype := reflect.TypeOf(g)
  19. 	numFields := gtype.NumField()
  21. 	rg := reflect.ValueOf(&amp;g)
  23. 	for i := 0; i &lt; numFields; i++ {
  24. 		fmt.Println(rg.Elem().Field(i))
  25. 	}
  26. }

答案8

得分: -2

在Go语言中，你可以使用reflect包来遍历结构体的字段。reflect包允许你在运行时检查值的属性，包括它们的类型和值。下面是一个遍历结构体字段的示例：

  1. package main
  3. import (
  4. 	"fmt"
  5. 	"reflect"
  6. )
  8. type Movie struct {
  9. 	Name string
  10. 	Year int
  11. }
  13. func main() {
  14. 	p := Movie{"The Dark Knight", 2008}
  16. 	val := reflect.ValueOf(p)
  17. 	typ := val.Type()
  19. 	for i := 0; i < val.NumField(); i++ {
  20. 		field := val.Field(i)
  21. 		fieldType := typ.Field(i)
  23. 		fmt.Printf("字段名：%s，字段值：%v\n", fieldType.Name, field.Interface())
  24. 	}
  25. }

输出结果：

  1. 字段名：Name，字段值：The Dark Knight
  2. 字段名：Year，字段值：2008

你可以在Go Playground上运行这段代码。

英文:

In Go, you can use the reflect package to iterate through the fields of a struct. The reflect package allows you to inspect the properties of values at runtime, including their type and value. Here's an example of how to iterate through the fields of a struct:

Go Playground

  1. package main
  3. import (
  4. 	&quot;fmt&quot;
  5. 	&quot;reflect&quot;
  6. )
  8. type Movie struct {
  9. 	Name string
  10. 	Year int
  11. }
  13. func main() {
  14. 	p := Movie{&quot;The Dark Knight&quot;, 2008}
  16. 	val := reflect.ValueOf(p)
  17. 	typ := val.Type()
  19. 	for i := 0; i &lt; val.NumField(); i++ {
  20. 		field := val.Field(i)
  21. 		fieldType := typ.Field(i)
  23. 		fmt.Printf(&quot;Field Name: %s, Field Value: %v\n&quot;, fieldType.Name, field.Interface())
  24. 	}
  25. }

Output:

  1. Field Name: Name, Field Value: The Dark Knight
  2. Field Name: Age, Field Value: 2008

huangapple
  • 本文由 发表于 2013年9月21日 05:39:55
  • 转载请务必保留本文链接：https://go.coder-hub.com/18926303.html
  • go
  • go-reflect
匿名

发表评论

匿名网友

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen:

确定