Go语言中动态代码字符串的执行：编译型语言的挑战与替代方案

package main

import (
    "fmt"
    "github.com/sbinet/go-eval/pkg/eval" // 请注意，此库可能不再活跃维护，且功能有限
)

func main() {
    // 假设从数据库获取的表达式字符串
    exprString := "10 + 2 * 5"

    // 创建一个求值器上下文
    universe := eval.NewUniverse()
    scope := eval.NewScope(universe, nil)

    // 尝试解析并评估表达式
    // 注意：go-eval主要用于表达式，而非任意Go代码
    program, err := universe.Parse("main.go", []byte(fmt.Sprintf("package main\nfunc main() { _ = %s }", exprString)))
    if err != nil {
        fmt.Printf("解析表达式失败: %v\n", err)
        return
    }

    // 寻找表达式所在的节点并评估
    // 实际使用时，需要更复杂的逻辑来定位并提取要评估的表达式
    // 此处仅作示意，表明其能力局限于简单表达式
    // 通常，go-eval库更适合直接评估一个已知的表达式AST
    // 对于从字符串动态构造并评估，其API使用相对复杂且功能受限。

    // 更直接的用法可能是：
    // expr, err := eval.ParseExpr(exprString)
    // if err != nil {
    //     fmt.Printf("解析表达式失败: %v\n", err)
    //     return
    // }
    // value, err := expr.Eval(scope) // 需要一个合适的scope
    // if err != nil {
    //     fmt.Printf("评估表达式失败: %v\n", err)
    //     return
    // }
    // fmt.Printf("表达式 '%s' 的结果: %v\n", exprString, value.Value())

    fmt.Println("go-eval库主要用于评估简单的Go表达式，不适合执行任意代码。")
    fmt.Println("对于更复杂的场景，建议使用下文介绍的规则引擎或DSL。")
}

package main

import (
    "fmt"
    "github.com/expr-lang/expr" // 引入expr库
)

// 定义一个上下文结构，用于规则评估
type UserContext struct {
    Geo []string // 用户地理位置列表
    OS  []string // 用户操作系统列表
}

func main() {
    // 存储在数据库中的规则字符串
    // 对应题目中的 checkGeo(...) && check0s(...) 逻辑
    ruleString := `any(Geo, { . == "DE" || . == "AU" || . == "NL" }) && any(OS, { . == "android" })`

    // 模拟用户上下文数据
    context1 := UserContext{
        Geo: []string{"DE", "US"},
        OS:  []string{"android", "ios"},
    }
    context2 := UserContext{
        Geo: []string{"US", "CA"},
        OS:  []string{"ios"},
    }
    context3 := UserContext{
        Geo: []string{"NL"},
        OS:  []string{"android"},
    }

    // 1. 编译规则：将规则字符串编译成可执行程序
    // expr.Env(UserContext{}) 告诉编译器规则中可用的变量和类型
    program, err := expr.Compile(ruleString, expr.Env(UserContext{}))
    if err != nil {
        fmt.Printf("规则编译失败: %v\n", err)
        return
    }

    // 2. 执行规则：在不同的上下文数据上运行已编译的规则
    // 场景1
    output, err := expr.Run(program, context1)
    if err != nil {
        fmt.Printf("Context 1 规则执行失败: %v\n", err)
        return
    }
    fmt.Printf("Context 1 结果: %v (预期: true)\n", output)

    // 场景2
    output, err = expr.Run(program, context2)
    if err != nil {
        fmt.Printf("Context 2 规则执行失败: %v\n", err)
        return
    }
    fmt.Printf("Context 2 结果: %v (预期: false)\n", output)

    // 场景3
    output, err = expr.Run(program, context3)
    if err != nil {
        fmt.Printf("Context 3 规则执行失败: %v\n", err)
        return
    }
    fmt.Printf("Context 3 结果: %v (预期: true)\n", output)
}

{
  "conditions": [
    {
      "type": "geo",
      "operator": "any_in",
      "values": ["DE", "AU", "NL"]
    },
    {
      "type": "os",
      "operator": "any_in",
      "values": ["android"]
    }
  ],
  "logic": "AND"
}