Go reflection implements dynamic modification of objects

Reflection is a powerful feature in the Go language that allows us to inspect and modify objects at runtime. With reflection, we can: Iterate over an object's fields and dynamically modify field values. Create a structure based on dynamic input, even if we don't know the input key name. Implement custom parsers and serializers without modifying source code.

Use Go reflection to dynamically modify objects

Introduction

Reflection is the Go language A powerful feature that allows programs to inspect and modify data structures at runtime. With reflection, we can dynamically manipulate objects without modifying the source code. This is useful when implementing custom parsers, serializers, and other scenarios where behavior needs to be dynamically adjusted based on input.

Code

To demonstrate the power of Go reflection, let’s create a structure named Person and use reflection to dynamically change it Fields of:

package main

import (
    "fmt"
    "reflect"
)

type Person struct {
    Name string
    Age  int
}

func main() {
    // 创建一个 Person 结构体的实例
    p := Person{"John", 30}

    // 获取反射类型
    rt := reflect.TypeOf(p)

    // 迭代结构体字段
    for i := 0; i < rt.NumField(); i++ {
        // 获取字段反射值
        fv := reflect.ValueOf(p).Field(i)

        // 修改字段值
        switch fv.Kind() {
        case reflect.String:
            fv.SetString("Jane")
        case reflect.Int:
            fv.SetInt(35)
        }
    }

    // 打印修改后的结构体
    fmt.Println(p)
}

Practical Example

Let us consider a practical example where we need to dynamically parse a JSON input that has inconsistent key values. Using reflection, we can dynamically create a struct with the correct type and value, even if we know nothing about the entered keys.

Here is a code example to do this:

package main

import (
    "encoding/json"
    "fmt"
    "reflect"
)

func main() {
    // 输入 JSON 字符串
    input := `{"name": "John", "age": 30}`

    // 解析 JSON 为 map[string]interface{}
    data := make(map[string]interface{})
    if err := json.Unmarshal([]byte(input), &data); err != nil {
        panic(err)
    }

    // 创建 Person 反射类型
    pType := reflect.TypeOf(Person{})

    // 创建 Person 反射值
    pValue := reflect.New(pType)

    // 迭代 JSON 对象的键值对
    for key, val := range data {
        // 获取结构体字段的反射值
        fv := pValue.Elem().FieldByName(key)

        // 检查字段是否存在
        if !fv.IsValid() {
            continue
        }

        // 根据字段类型设置字段值
        switch fv.Kind() {
        case reflect.String:
            fv.SetString(val.(string))
        case reflect.Int:
            fv.SetInt(int64(val.(float64)))
        }
    }

    // 打印修改后的结构体
    fmt.Println(pValue.Elem().Interface())
}

As you can see, by using reflection, we can flexibly manipulate objects and create the required structure based on dynamic input.

The above is the detailed content of Go reflection implements dynamic modification of objects. For more information, please follow other related articles on the PHP Chinese website!