Comment créer des types personnalisés dynamiques à l'aide de la réflexion Golang ?

Comment créer des types personnalisés dynamiques à l'aide de la réflexion de Go ? Créez un type personnalisé : utilisez le mot-clé type pour définir une structure. Obtenez le type de réflexion : obtenez le type de réflexion du type via la fonction reflect.TypeOf(). Créer un type dynamique : utilisez la fonction Reflect.New pour créer un pointeur vers un type personnalisé. Définir des valeurs : utilisez les fonctions v.Elem() et Reflect.Set() pour définir des valeurs. Obtenir la valeur : utilisez la méthode Interface() pour obtenir la valeur d'interface de la valeur.

Comment créer des types personnalisés dynamiques à l'aide de la réflexion de Go

La réflexion est une fonctionnalité puissante de Go qui permet à un programme d'inspecter et de modifier son propre code. Avec la réflexion, nous pouvons créer des types personnalisés dynamiques qui peuvent être modifiés au moment de l'exécution selon les besoins.

Créer un type personnalisé

Pour créer un type personnalisé, nous pouvons utiliser type Mot-clé : type 关键字：

type person struct {
    name string
    age  int
}

反射类型

要获取一个类型的反射类型，可以使用 reflect.TypeOf() 函数：

t := reflect.TypeOf(person{})

创建动态类型

要创建动态类型，我们可以使用 reflect.New 函数以指定反射类型作为参数：

v := reflect.New(t)

该 v 变量现在代表了一个指向自定义类型的指针。我们现在可以使用反射来设置和获取值：

设置值

可以使用 v.Elem() 获取指针指向的值，然后使用标准方法或 reflect.Set 函数设置值：

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

获取值

使用 reflect.Value 类型的 Interface 方法可以获取值的接口值：

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

实战案例

假设我们有一个 JSON 字符串，其中包含一个人的姓名和年龄：

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

我们可以使用反射来动态创建 person

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
}

🎜Type réfléchissant🎜🎜🎜Pour obtenir le type réfléchissant d'un type, nous pouvons utiliser reflect.TypeOf() : 🎜rrreee🎜🎜Création d'un type dynamique🎜🎜🎜Pour créer un type dynamique, nous pouvons utiliser la fonction reflect.New avec un type de réflexion spécifié en paramètre : 🎜 rrreee🎜La variable v représente désormais un pointeur vers un type personnalisé. Nous pouvons maintenant utiliser la réflexion pour définir et obtenir des valeurs : 🎜🎜🎜Définissez une valeur🎜🎜🎜Vous pouvez obtenir la valeur pointée par le pointeur en utilisant v.Elem() puis utiliser les méthodes standard ou reflect.Set Fonction pour définir la valeur : 🎜rrreee🎜🎜Obtenir la valeur 🎜🎜🎜Utiliser la méthode Interface de type reflect.Value pour obtenir la valeur d'interface de la valeur : 🎜rrreee🎜🎜 Cas pratique 🎜🎜🎜Supposons que nous ayons une chaîne JSON contenant le nom et l'âge d'une personne : 🎜rrreee🎜Nous pouvons utiliser la réflexion pour créer dynamiquement le type person et définissez sa valeur : 🎜rrreee

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!