How to create dynamic custom types using Golang reflection?

How to create dynamic custom types using Go’s reflection? Create a custom type: Use the type keyword to define a structure. Get the reflection type: Get the type reflection type through the reflect.TypeOf() function. Create a dynamic type: Use the reflect.New function to create a pointer to a custom type. Set values: Use the v.Elem() and reflect.Set() functions to set values. Get value: Use the Interface() method to get the interface value of the value.

How to use Go’s reflection to create dynamic custom types

Reflection is a powerful feature in Go that allows programs Inspect and modify its own code. With reflection, we can create dynamic custom types that can be modified at runtime as needed.

Create a custom type

To create a custom type, we can use the type keyword:

type person struct {
    name string
    age  int
}

Reflection type

To obtain the reflection type of a type, you can use the reflect.TypeOf() function:

t := reflect.TypeOf(person{})

Create a dynamic type

To create a dynamic type, we can use the reflect.New function taking the specified reflection type as argument:

v := reflect.New(t)

The v variable now represents A pointer to a custom type. We can now use reflection to set and get values:

Set the value

You can use v.Elem() to get the value pointed to by the pointer, Then set the value using standard methods or the reflect.Set function:

v.Elem().FieldByName("name").SetString("John")
v.Elem().FieldByName("age").SetInt(30)

Get the value

Use the reflect.Value type The Interface method can get the interface value of the value:

name := v.Elem().FieldByName("name").Interface()
age := v.Elem().FieldByName("age").Interface()

Practical case

Suppose we have a JSON string that contains a person's Name and age:

{
  "name": "Jane",
  "age": 35
}

We can use reflection to dynamically create the person type and set its value:

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

func main() {
    // 反射创建自定义类型
    t := reflect.TypeOf(person{})
    v := reflect.New(t)

    // 反射解组 JSON 字符串
    var data map[string]interface{}
    err := json.Unmarshal([]byte(`{
        "name": "Jane",
        "age": 35
    }`), &data)
    if err != nil {
        panic(err)
    }

    // 反射设置字段值
    for k, v := range data {
        v.Elem().FieldByName(k).Set(reflect.ValueOf(v))
    }

    // 反射获取字段值
    fmt.Println(v.Elem().FieldByName("name").Interface()) // 输出："Jane"
    fmt.Println(v.Elem().FieldByName("age").Interface())  // 输出：35
}
type person struct {
    name string
    age  int
}

The above is the detailed content of How to create dynamic custom types using Golang reflection?. For more information, please follow other related articles on the PHP Chinese website!