在Go语言中实现动态代码评估：从PHP的eval()到编译型语言的策略

package main

import (
    "fmt"
    // 假设存在一个名为 "expr_evaluator" 的库
    // import "github.com/some/expr_evaluator"
)

// 这里我们用一个伪函数来模拟表达式评估器的行为
func evaluateExpression(expr string, context map[string]interface{}) (interface{}, error) {
    // 实际中，这里会调用 expr_evaluator 库来解析和执行 expr
    // 例如：
    // parsedExpr, err := expr_evaluator.Parse(expr)
    // if err != nil {
    //     return nil, err
    // }
    // result, err := parsedExpr.Execute(context)
    // if err != nil {
    //     return nil, err
    // }
    // return result, nil

    // 为演示目的，我们模拟一个简单的布尔表达式评估
    // 假设我们的表达式是 "checkGeo('DE') && checkOS('android')"
    // 并且我们有一个机制可以根据 context 调用相应的函数
    if expr == "checkGeo('DE') && checkOS('android')" {
        geo, ok := context["geo"].(string)
        os, osOk := context["os"].(string)
        if ok && osOk && geo == "DE" && os == "android" {
            return true, nil
        }
        return false, nil
    }
    return nil, fmt.Errorf("unsupported expression or evaluation failed")
}

func main() {
    context := map[string]interface{}{
        "geo": "DE",
        "os":  "android",
    }
    expr := "checkGeo('DE') && checkOS('android')" // 示例表达式

    result, err := evaluateExpression(expr, context)
    if err != nil {
        fmt.Printf("评估表达式失败: %v\n", err)
        return
    }
    fmt.Printf("表达式 '%s' 的评估结果: %v\n", expr, result) // 输出: 表达式 'checkGeo('DE') && checkOS('android')' 的评估结果: true

    context2 := map[string]interface{}{
        "geo": "AU",
        "os":  "ios",
    }
    result2, err2 := evaluateExpression(expr, context2)
    if err2 != nil {
        fmt.Printf("评估表达式失败: %v\n", err2)
        return
    }
    fmt.Printf("表达式 '%s' 的评估结果: %v\n", expr, result2) // 输出: 表达式 'checkGeo('DE') && checkOS('android')' 的评估结果: false
}

package main

import (
    "fmt"
    "strings"
)

// Token 类型
type TokenType int

const (
    TOKEN_IDENTIFIER TokenType = iota // checkGeo, checkOS
    TOKEN_LPAREN                      // (
    TOKEN_RPAREN                      // )
    TOKEN_STRING                      // "DE", "android"
    TOKEN_AND                         // &&
    TOKEN_OR                          // ||
    TOKEN_EOF                         // End of File
)

// Token 结构
type Token struct {
    Type  TokenType
    Value string
}

// 词法分析器 (Lexer)
type Lexer struct {
    input string
    pos   int
    ch    byte
}

func NewLexer(input string) *Lexer {
    l := &Lexer{input: input}
    l.readChar()
    return l
}

func (l *Lexer) readChar() {
    if l.pos >= len(l.input) {
        l.ch = 0 // EOF
    } else {
        l.ch = l.input[l.pos]
    }
    l.pos++
}

func (l *Lexer) peekChar() byte {
    if l.pos >= len(l.input) {
        return 0
    }
    return l.input[l.pos]
}

func (l *Lexer) skipWhitespace() {
    for l.ch == ' ' || l.ch == '\t' || l.ch == '\n' || l.ch == '\r' {
        l.readChar()
    }
}

func (l *Lexer) NextToken() Token {
    l.skipWhitespace()

    var tok Token
    switch l.ch {
    case '(':
        tok = Token{Type: TOKEN_LPAREN, Value: "("}
    case ')':
        tok = Token{Type: TOKEN_RPAREN, Value: ")"}
    case '&':
        if l.peekChar() == '&' {
            tok = Token{Type: TOKEN_AND, Value: "&&"}
            l.readChar() // consume second '&'
        } else {
            // Handle single '&' if needed, or error
        }
    case '|':
        if l.peekChar() == '|' {
            tok = Token{Type: TOKEN_OR, Value: "||"}
            l.readChar() // consume second '|'
        } else {
            // Handle single '|' if needed, or error
        }
    case '\'':
        tok.Type = TOKEN_STRING
        l.readChar() // consume opening quote
        start := l.pos - 1
        for l.ch != '\'' && l.ch != 0 {
            l.readChar()
        }
        tok.Value = l.input[start : l.pos-1]
        // The original example has '{geo:["DE","AU","NL"]}' which is JSON string.
        // For simplicity, we just extract the string as is.
        // A real parser would then parse this JSON string.
    case 0:
        tok = Token{Type: TOKEN_EOF, Value: ""}
    default:
        if isLetter(l.ch) {
            start := l.pos - 1
            for isLetter(l.ch) {
                l.readChar()
            }
            tok.Value = l.input[start : l.pos-1]
            tok.Type = TOKEN_IDENTIFIER
            return tok
        } else {
            // Error: unexpected character
            return Token{Type: -1, Value: string(l.ch)}
        }
    }
    l.readChar()
    return tok
}

func isLetter(ch byte) bool {
    return 'a' <= ch && ch <= 'z' || 'A' <= ch && ch <= 'Z'
}

// 抽象语法树 (AST) 节点接口
type Node interface {
    String() string
}

type Expression interface {
    Node
    // Eval(context map[string]interface{}) (bool, error) // For evaluation
}

// 函数调用节点
type CallExpression struct {
    Function  *Identifier
    Arguments []Expression // For simplicity, assume one string argument
}

func (ce *CallExpression) String() string {
    var args []string
    for _, a := range ce.Arguments {
        args = append(args, a.String())
    }
    return fmt.Sprintf("%s(%s)", ce.Function.String(), strings.Join(args, ", "))
}

// 标识符节点 (函数名)
type Identifier struct {
    Value string
}

func (i *Identifier) String() string { return i.Value }

// 字符串字面量节点
type StringLiteral struct {
    Value string
}

func (sl *StringLiteral) String() string { return fmt.Sprintf("'%s'", sl.Value) }

// 二元操作符节点 (&&, ||)
type BinaryExpression struct {
    Left     Expression
    Operator Token
    Right    Expression
}

func (be *BinaryExpression) String() string {
    return fmt.Sprintf("(%s %s %s)", be.Left.String(), be.Operator.Value, be.Right.String())
}

// 语法分析器 (Parser)
type Parser struct {
    lexer *Lexer
    curr  Token
    peek  Token
    errs  []string
}

func NewParser(l *Lexer) *Parser {
    p := &Parser{lexer: l}
    p.nextToken()
    p.nextToken() // Initialize curr and peek
    return p
}

func (p *Parser) nextToken() {
    p.curr = p.peek
    p.peek = p.lexer.NextToken()
}

func (p *Parser) parseExpression() Expression {
    // Simplified parsing for demonstration: assumes only binary expressions or function calls
    left := p.parsePrimaryExpression()
    for p.curr.Type == TOKEN_AND || p.curr.Type == TOKEN_OR {
        op := p.curr
        p.nextToken()
        right := p.parsePrimaryExpression()
        left = &BinaryExpression{Left: left, Operator: op, Right: right}
    }
    return left
}

func (p *Parser) parsePrimaryExpression() Expression {
    if p.curr.Type == TOKEN_IDENTIFIER && p.peek.Type == TOKEN_LPAREN {
        return p.parseCallExpression()
    }
    // Add other primary expressions if needed (e.g., parenthesized expressions)
    return nil // Error
}

func (p *Parser) parseCallExpression() *CallExpression {
    ident := &Identifier{Value: p.curr.Value}
    p.nextToken() // Consume identifier
    p.nextToken() // Consume '('

    callExpr := &CallExpression{Function: ident}
    if p.curr.Type == TOKEN_STRING {
        callExpr.Arguments = append(callExpr.Arguments, &StringLiteral{Value: p.curr.Value})
        p.nextToken() // Consume string
    } else {
        // Error: expected string argument
    }

    if p.curr.Type != TOKEN_RPAREN {
        // Error: expected ')'
    }
    p.nextToken() // Consume ')'
    return callExpr
}

// 评估器 (Evaluator)
type Evaluator struct {
    context map[string]interface{}
}

func NewEvaluator(context map[string]interface{}) *Evaluator {
    return &Evaluator{context: context}
}

func (e *Evaluator) Eval(node Node) (bool, error) {
    switch n := node.(type) {
    case *BinaryExpression:
        leftVal, err := e.Eval(n.Left)
        if err != nil {
            return false, err
        }
        rightVal, err := e.Eval(n.Right)
        if err != nil {
            return false, err
        }
        if n.Operator.Type == TOKEN_AND {
            return leftVal && rightVal, nil
        }
        if n.Operator.Type == TOKEN_OR {
            return leftVal || rightVal, nil
        }
        return false, fmt.Errorf("unknown binary operator: %s", n.Operator.Value)
    case *CallExpression:
        return e.evalCallExpression(n)
    default:
        return false, fmt.Errorf("unknown node type: %T", n)
    }
}

func (e *Evaluator) evalCallExpression(call *CallExpression) (bool, error) {
    funcName := call.Function.Value
    if len(call.Arguments) == 0 {
        return false, fmt.Errorf("function '%s' expects at least one argument", funcName)
    }
    arg, ok := call.Arguments[0].(*StringLiteral)
    if !ok {
        return false, fmt.Errorf("function '%s' expects a string literal argument", funcName)
    }

    switch funcName {
    case "checkGeo":
        // In a real scenario, parse arg.Value as JSON, then