Existe-t-il un équivalent à la fonction `eval()` de JavaScript pour l'évaluation dynamique du code Go ?

Évaluer Go Code avec eval()

Introduction

En JavaScript, la fonction eval() vous permet d'exécuter du code ou des expressions de manière dynamique. Existe-t-il une fonction équivalente dans Go qui peut évaluer le code Go ?

Réponse

Oui, il est possible d'évaluer les expressions Go de manière dynamique. Le composant clé pour cela est le package go/types. Voici comment procéder :

Création d'un package et d'une portée

Tout d'abord, créez un objet package pour contenir le code à évaluer, et un objet scope.Scope pour définir la portée dans laquelle le code s'exécutera.

package eval

import (
    "go/ast"
    "go/constant"
    "go/parser"
    "go/token"
    "go/types"
)

var (
    // Create a new package object to hold the evaluated code.
    pkg = types.NewPackage("eval", "example.com/eval")

    // Create a new scope object to define the scope of evaluation.
    scope = types.NewScope(nil, token.NewFileSet())
)

Insérer des constantes dans Scope

La fonction eval() permet généralement d'évaluer des expressions qui référencer des variables ou des constantes définies. Pour simuler ce comportement dans Go, nous pouvons insérer des constantes dans la portée de l'évaluation.

// Insert a constant named "x" with value 10 into the scope.
scope.Insert(scope.Lookup("x"), &types.Const{
    Val:    constant.MakeInt64(10),
    Type:   pkg.Scope().Lookup("int").Type(), // Lookup the "int" type from the package's scope.
    Pkg:    pkg,
    Name:   "x",
    Kind:   types.Const,
    Obj:    nil, // We don't need an Object for introducing constants directly.
    Alias:  false,
})

Analyse et évaluation des expressions

Ensuite, vous devez analyser l'expression Go à évaluer et créer un AST (Abstract Syntax Tree) pour cela. Une fois que vous avez l'AST, vous pouvez évaluer l'expression à l'aide du package go/types.

// Parse the input Go expression.
expr, err := parser.ParseExpr("x + 17")
if err != nil {
    panic(err)
}

// Evaluate the expression in the defined scope.
result, err := types.Eval(expr, scope)
if err != nil {
    panic(err)
}

Résultat et conclusion

Le résultat de l'évaluation sera stocké dans le résultat variable comme constante.Valeur. Vous pouvez le convertir au type souhaité selon vos besoins. Dans votre exemple, vous pouvez obtenir le résultat en utilisant :

intResult, ok := constant.Int64Val(result)
if !ok {
    panic("failed to convert result to int")
}

En suivant ces étapes, vous pouvez réaliser une évaluation dynamique du code Go, similaire à la fonction eval() en JavaScript.

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!