La réflexion est-elle importante en golang ?

Golang fournit un mécanisme pour mettre à jour les variables, afficher les valeurs au moment de l'exécution, appeler des méthodes et modifier directement leur disposition sans connaître le type au moment de la compilation. s'appelle la réflexion.

Pourquoi utiliser la réflexion ?                                                                                                                               (Apprentissage recommandé : go)

Par exemple, nous avons parfois besoin d'une fonction capable de gérer différents types de valeurs. Sans connaître le type, vous pourriez écrire :

// 伪代码
switch value := value.(type) {
case string:
    // ...一些操作
case int:   
    // ...一些操作  
case cbsStruct: // 自定义的结构体  
    // ...一些操作

// ...
}

Avez-vous rencontré des problèmes ?

Il y a un problème ici : il y a beaucoup de types, cette fonction sera très longue à écrire, et il peut aussi y avoir des types personnalisés, ce qui signifie que ce jugement devra peut-être être modifié dans le futur , car il n'y a aucun moyen de savoir. On ne sait pas à quel type appartient la valeur.

Lorsque vous ne pouvez pas voir à travers un type inconnu, le code ci-dessus n'est en fait pas très raisonnable. Pour le moment, vous avez besoin d'une réflexion pour vous aider à le gérer. Reflection utilise les fonctions TypeOf et ValueOf pour obtenir les informations de. l'objet cible depuis l'interface et complétez facilement l'objectif.

3. Que peut faire exactement la réflexion ?

package main

import (
    "fmt"
    "reflect"
)

func main() {
    var name string = "咖啡色的羊驼"

    // TypeOf会返回目标数据的类型，比如int/float/struct/指针等
    reflectType := reflect.TypeOf(name)

    // valueOf返回目标数据的的值，比如上文的"咖啡色的羊驼"
    reflectValue := reflect.ValueOf(name)

    fmt.Println("type: ", reflectType)
    fmt.Println("value: ", reflectValue)
}

Golang fournit le package Reflect pour prendre en charge la réflexion. Les principales incluent deux méthodes et deux structures (pour être précis, une structure et une interface), qui sont utilisées respectivement pour obtenir et faire fonctionner Dynamic. types et valeurs dynamiques des variables d'interface.

Deux méthodes :

func TypeOf(i interface{}) Type {...} Cette méthode reçoit une interface vide de type Variables et les paramètres réels seront copiés et convertis en variables d'interface vides, qui seront éventuellement utilisées comme paramètres de TypeOf.

À l'intérieur de la fonction, les informations de type dynamique de la variable d'interface seront extraites et encapsulées dans Reflect.Type pour le retour. Parce que Reflect.Type est une interface, ce qui est réellement utilisé est une instance de l'interface. La véritable instance ici est Reflect .rtype.

func ValueOf(i interface{}) Value {...} Avec le type de fonction TypeOf, il reçoit également une copie, puis la convertit en une variable d'interface vide, et prend la variable d'interface à l'intérieur de la méthode. La valeur dynamique est ensuite encapsulée et renvoyée en tant qu'objet Reflect.Value.

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!