méthode de réflexion Golang

1. Le concept de réflexion

En programmation, la réflexion fait référence à la capacité d'obtenir des informations sur la structure du programme au moment de l'exécution. Une explication simple est que le programme peut vérifier son propre statut, ses propriétés et ses méthodes au moment de l'exécution sans avoir à déterminer toutes ces informations au moment de la compilation. Reflection permet aux programmes linguistiques Go d'avoir une flexibilité et des capacités similaires à celles d'autres langages dynamiques.

Dans le langage Go, pour implémenter la réflexion, vous pouvez utiliser le package Reflect, qui fournit une grande quantité de méta-informations sur les types et les valeurs, qui peuvent être utilisées dynamiquement lorsque le programme est en cours d'exécution.

2. Application de la réflexion

Reflection propose un large éventail de scénarios d'application dans le langage Go. Par exemple :

1. Lors de l'écriture d'une fonction générale, il est difficile de prédire le type spécifique des paramètres entrants, vous pouvez donc utiliser la réflexion pour obtenir dynamiquement les informations sur les paramètres entrants.

2. Lors de l'écriture d'un framework ORM, vous pouvez automatiquement mapper des objets aux tables de la base de données, ou vous pouvez interroger les données de la base de données et utiliser la réflexion pour mapper automatiquement les objets correspondants.

3. De nombreux frameworks et outils utilisent la réflexion pour lire les fichiers de configuration ou analyser les paramètres de commande.

3. Types de réflexion

Dans le langage Go, il existe deux principaux types de réflexion :

1.Type

Le type est une information de type, qui représente un type en Go, qui peut être un type de données de base ou une structure Body. , fonction, pointeur, tableau, tranche, interface, etc.

2.Value

Value représente une valeur, qui peut être une valeur de n'importe quel type. Elle regroupe la valeur des données et les informations de type d'une instance, et fournit une série de méthodes pour faire fonctionner l'instance.

4. Opérations de base de la réflexion

1. Obtenir les informations de type

Utilisez la fonction reflex.TypeOf() pour obtenir les informations de type de n'importe quelle valeur. La syntaxe est la suivante :

func TypeOf(i interface{}) Type

Par exemple, nous voulons obtenir. le type de la chaîne "bonjour" Informations :

t := reflect.TypeOf("hello")
fmt.Println(t.Kind())  // 输出：string

2. Obtenir les informations sur la valeur

Utilisez la fonction reflex.ValueOf() pour obtenir les informations sur la valeur de n'importe quelle valeur. La syntaxe est la suivante :

func ValueOf(i interface{}) Value

Par exemple, nous. souhaitez obtenir les informations sur la valeur de la variable de chaîne "hello":

value := reflect.ValueOf("hello")
fmt.Println(value.String()) // 输出：hello

3. Obtenez les informations sur le type et la valeur de la variable

Si vous souhaitez obtenir les informations sur le type et la valeur de la variable en même temps, vous pouvez utilisez les méthodes réflexion.TypeOf() et réflexion.ValueOf() ensemble, comme suit :

var age int = 22
t := reflect.TypeOf(age)                // 变量类型信息
v := reflect.ValueOf(age)               // 变量值信息
fmt.Println(t.Kind(), v.Int())          // 输出：int 22

4. Définir par réflexion La valeur de la variable

En utilisant la réflexion, vous pouvez modifier dynamiquement la valeur de la variable Vous devez. utilisez la méthode de type Value Set() dans le package Reflect. La syntaxe est la suivante :

func (v Value) Set(x Value)

Parmi eux, le type du paramètre x doit être cohérent avec le type de v, sinon il signalera une erreur.

Par exemple, nous changeons la valeur de la variable age en 33 :

v := reflect.ValueOf(&age)
v.Elem().SetInt(33)
fmt.Println(age)                     // 输出：33

5 Modifiez la valeur des membres de la structure par réflexion

En utilisant la réflexion pour modifier dynamiquement les valeurs des membres de la structure, vous devez utiliser le type Value et Type dans le package Reflect. La méthode FieldByName() dans le type a la syntaxe suivante :

func (v Value) FieldByName(name string) Value

Par exemple, nous définissons une structure Person et modifions les valeurs du nom et de l'âge de ses membres :

type Person struct {
    name string
    age  int
}

func main() {
    p := Person{name: "Mike", age: 22}
    v := reflect.ValueOf(&p).Elem()
    v.FieldByName("name").SetString("Tom")
    v.FieldByName("age").SetInt(33)
    fmt.Println(p)                         // 输出：{Tom 33}
}

6 .Appelez la fonction par réflexion

En utilisant la réflexion, vous pouvez dynamiquement Pour appeler une fonction, vous devez utiliser le type Value dans le package Reflect et la méthode Call() dans le type Type. Parmi eux, le paramètre args est le paramètre d'entrée de la fonction et la valeur de retour est le paramètre de sortie de la fonction.

Par exemple, nous avons défini une fonction Ajouter et appelée la fonction Ajouter par réflexion :

func (v Value) Call(args []Value) []Value

Ce qui précède sont les opérations de base de la réflexion dans le langage Go. La réflexion donne au langage Go des capacités et une flexibilité plus puissantes lorsque nous développons Reflection. également être utilisé de manière flexible pour mettre en œuvre certaines fonctions.

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!