Application of golang type conversion and reflection in code reuse

Application scenario: Application of type conversion and reflection in code reuse Universal functions: Create functions that can handle multiple types, such as the following function that calculates the maximum value of multiple values. Reflective JSON parsing: Access JSON data through reflection without relying on a specific type of structure. Dynamic value handling: Use reflection to implement dynamic value handling, such as storing and retrieving values.

Application of type conversion and reflection in code reuse in Go

Type conversion

In Go A variety of type conversion methods are provided, including:

// 类型断言
val := interface{}(int)(val) // 将 interface{} 转换为 int

// 类型转换
var val int = int(float)

// 类型转换函数
val = strconv.Atoi(string)

Reflection

Reflection allows the program to inspect and modify types and values ​​at runtime. The reflection interface provides the following functions:

// 获得类型信息
val := reflect.TypeOf(val)

// 获得值信息
val := reflect.ValueOf(val)

// 检查类型
val.Kind() // 返回类型种类（例如 Int, Float）

// 获得字段
val.Field(i) // 获取第 i 个字段的值

// 调用方法
val.Method(i).Call(args...) // 调用第 i 个方法

Code reuse application

Type conversion and reflection are widely used in code reuse. The following are some practical cases:

Universal functions:

Create universal functions that can handle multiple types:

func Max(vals ...interface{}) interface{} {
    var maxVal interface{}
    for _, v := range vals {
        switch v.(type) {
        case int:
            if v.(int) > maxVal.(int) {
                maxVal = v
            }
        case float64:
            if v.(float64) > maxVal.(float64) {
                maxVal = v
            }
        }
    }
    return maxVal
}

Reflected JSON Parsing:

Access JSON data through reflection without relying on a specific type of structure:

type JSON map[string]interface{}

func ParseJSON(data []byte) (JSON, error) {
    m := make(map[string]interface{})
    if err := json.Unmarshal(data, &m); err != nil {
        return nil, err
    }
    return JSON(m), nil
}

Dynamic value processing:

Use reflection to implement dynamic value processing, such as storing and retrieving values.

type ValueStore struct {
    m map[string]reflect.Value
}

func (s *ValueStore) Set(key string, val interface{}) {
    s.m[key] = reflect.ValueOf(val)
}

func (s *ValueStore) Get(key string) interface{} {
    return s.m[key].Interface()
}

The above is the detailed content of Application of golang type conversion and reflection in code reuse. For more information, please follow other related articles on the PHP Chinese website!