Using Golang reflection to implement structure field traversal and modification

Go reflection can be used to traverse and modify structure fields. Field traversal: Use reflect.TypeOf and reflect.Field to traverse structure fields. Field modification: Access and modify the values ​​of structure fields through Elem and Set. Practical case: Use reflection to convert the structure into a map, and then convert the map into JSON.

Use Go reflection to implement structure field traversal and modification

Go reflection is a powerful technology that allows us to check and Modify types and values ​​in the program. It is ideal for working with unknown or dynamic data, as well as reflecting on existing structures for introspection operations.

Field traversal

To traverse the fields of a structure, you can use the reflect.TypeOf function to retrieve the type information of the structure, and then use NumField method gets the number of fields. Each field can be accessed through the Field method, which returns a reflect.StructField object.

type Person struct {
  Name string
  Age  int
}

func main() {
  person := Person{"Alice", 25}

  t := reflect.TypeOf(person)
  for i := 0; i < t.NumField(); i++ {
    field := t.Field(i)
    fmt.Println(field.Name, field.Type)
  }
}

Field modification

You can access the value of the structure field through the Elem method, which will return reflect.Value Object. To modify a field, you can use the Set method, which accepts a reflect.Value parameter:

// 使用 Elem 访问字段值
nameField := reflect.ValueOf(person).Elem().FieldByName("Name")

// 使用 Set 修改字段值
nameField.SetString("Bob")

fmt.Println(person.Name) // 输出：Bob

Practical case

Let's say we have a struct that stores a user's personal information, but we want to return it in JSON format. We can use reflection to convert the structure into map[string]interface{}:

type User struct {
  Name     string
  Age      int
  Password string
}

func main() {
  user := User{"Alice", 25, "secret"}

  // 将结构体转换为 map
  userMap := make(map[string]interface{})
  t := reflect.TypeOf(user)
  for i := 0; i < t.NumField(); i++ {
    field := t.Field(i)
    value := reflect.ValueOf(user).Elem().FieldByName(field.Name)
    userMap[field.Name] = value.Interface()
  }

  // 将 map 转换为 JSON
  json, err := json.Marshal(userMap)
  if err != nil {
    // 处理错误
  }

  fmt.Println(string(json)) // 输出：{"Name":"Alice","Age":25}
}

Conclusion

Go reflection provides a powerful way to traverse and modify structure fields. By using reflect.TypeOf, reflect.StructField, reflect.Value and reflect.Set we can handle unknown or dynamic data, And perform reflection operations on existing structures to achieve code scalability and flexibility.

The above is the detailed content of Using Golang reflection to implement structure field traversal and modification. For more information, please follow other related articles on the PHP Chinese website!