Home  >  Article  >  Backend Development  >  How to create dynamic custom types using Golang reflection?

How to create dynamic custom types using Golang reflection?

WBOY
WBOYOriginal
2024-06-02 20:24:00383browse

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.

如何使用 Golang 反射创建动态自定义类型?

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!

Statement:
The content of this article is voluntarily contributed by netizens, and the copyright belongs to the original author. This site does not assume corresponding legal responsibility. If you find any content suspected of plagiarism or infringement, please contact admin@php.cn