Comment puis-je exécuter dynamiquement du code Go comme eval() de JavaScript ?

Exécuter du code/des expressions Go comme Eval() de JavaScript

En JavaScript, la méthode eval() vous permet d'exécuter du code de manière dynamique en fonction de une entrée de chaîne. Existe-t-il une fonctionnalité similaire disponible dans Go ?

Solution

Oui, il est possible d'obtenir une fonctionnalité similaire avec Go en utilisant l'approche suivante :

Utilisation de packages, d'étendues et de constantes :

1. Créer un package : Définissez un package personnalisé dans votre code Go.
2. Créer un scope : Créez un objet Scope dans le package pour représenter l'environnement dans lequel le code sera évalué.
3. Insérer des constantes : Insérez des constantes dans le scope du package. Ces constantes représentent les valeurs et les variables disponibles pour l'évaluation.
4. Construire des constantes : Utilisez la fonction types.NewConst() pour construire des constantes avec les informations de type appropriées.

Exemple d'utilisation :

Voici un extrait de code qui montre comment évaluer des expressions simples dans Go :

import (
    "fmt"

    "go/types"
)

func main() {
    // Create a new package
    pkg := types.NewPackage("mypkg", "github.com/example/mypkg")

    // Create a new scope
    scope := types.NewScope(pkg, nil)

    // Insert constants into the scope
    scope.Insert(types.NewConst("x", types.Int, types.NewInt64(10)))
    scope.Insert(types.NewConst("y", types.Int, types.NewInt64(20)))

    // Evaluate simple expressions
    expr1 := "x * y"
    expr2 := "2 + 2"
    expr3 := "x + 17"
    result1, _ := evaluate(pkg, scope, expr1)
    result2, _ := evaluate(pkg, scope, expr2)
    result3, _ := evaluate(pkg, scope, expr3)

    // Print the results
    fmt.Println(result1, result2, result3)
}

// evaluate takes a package, scope, and expression and evaluates the expression in the provided scope.
func evaluate(pkg *types.Package, scope *types.Scope, expr string) (types.Object, error) {
    // Check the expression
    if expr == "" {
        return nil, fmt.Errorf("empty expression")
    }

    // Parse the expression
    parsed, err := types.ParseExpr(expr)
    if err != nil {
        return nil, err
    }

    // Evaluate the expression
    return pkg.Check(parsed.Pos(), parsed), nil
}

Ce code évaluera les expressions fournies dans le portée du package personnalisé, vous permettant d'évaluer dynamiquement le code en fonction des chaînes d'entrée.

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!