Gibt es ein Äquivalent zur JavaScript-Funktion „eval()' für die dynamische Auswertung von Go-Code?

Auswerten von Go-Code mit eval()

Einführung

In JavaScript ermöglicht Ihnen die Funktion eval() die Ausführung Code oder Ausdrücke dynamisch bearbeiten. Gibt es in Go eine entsprechende Funktion, die Go-Code auswerten kann?

Antwort

Ja, es ist möglich, Go-Ausdrücke dynamisch auszuwerten. Die Schlüsselkomponente hierfür ist das Paket go/types. So können Sie es machen:

Erstellen eines Pakets und eines Bereichs

Erstellen Sie zunächst ein Paketobjekt, um den auszuwertenden Code zu speichern, und ein Scope.Scope-Objekt, um den Bereich zu definieren, in dem Der Code wird ausgeführt.

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())
)

Konstanten in den Bereich einfügen

Die Funktion eval() ermöglicht dies normalerweise Auswerten von Ausdrücken, die auf definierte Variablen oder Konstanten verweisen. Um dieses Verhalten in Go zu simulieren, können wir Konstanten in den Auswertungsbereich einfügen.

// 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,
})

Ausdrücke analysieren und auswerten

Als nächstes müssen Sie den auszuwertenden Go-Ausdruck analysieren und erstellen einen AST (Abstract Syntax Tree) dafür. Sobald Sie den AST haben, können Sie den Ausdruck mit Hilfe des Pakets go/types auswerten.

// 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)
}

Ergebnis und Schlussfolgerung

Das Ergebnis der Auswertung wird im Ergebnis gespeichert Variable als Konstante.Wert. Sie können es bei Bedarf in den gewünschten Typ konvertieren. In Ihrem Beispiel können Sie das Ergebnis folgendermaßen erhalten:

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

Durch Befolgen dieser Schritte können Sie eine dynamische Auswertung von Go-Code erreichen, ähnlich der Funktion eval() in JavaScript.

Das obige ist der detaillierte Inhalt vonGibt es ein Äquivalent zur JavaScript-Funktion „eval()' für die dynamische Auswertung von Go-Code?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!