Go语言中动态执行代码字符串的策略与实践

package main

import (
    "encoding/json"
    "fmt"
    "strings"
)

// 模拟的检查函数
func checkGeo(geoData map[string][]string) bool {
    countries, ok := geoData["geo"]
    if !ok || len(countries) == 0 {
        return false
    }
    for _, c := range countries {
        if c == "DE" { // 示例逻辑：如果包含"DE"则通过
            return true
        }
    }
    return false
}

func check0s(osData map[string][]string) bool {
    oses, ok := osData["os"]
    if !ok || len(oses) == 0 {
        return false
    }
    for _, o := range oses {
        if o == "android" { // 示例逻辑：如果包含"android"则通过
            return true
        }
    }
    return false
}

// RuleExecutor 负责解析和执行规则
type RuleExecutor struct {
    // 实际场景中可能需要一个更复杂的函数映射，例如使用反射或接口
    // 这里简化为直接调用
}

func NewRuleExecutor() *RuleExecutor {
    return &RuleExecutor{}
}

// Evaluate 简化版的规则解析和执行（仅支持简单的AND逻辑）
// 真实场景需要一个完整的词法分析器和语法解析器来处理复杂的逻辑表达式
func (re *RuleExecutor) Evaluate(ruleString string) (bool, error) {
    // 示例规则: checkGeo('{geo:["DE","AU","NL"]}') && check0s('{os:["android"]}')
    parts := strings.Split(ruleString, " && ")
    result := true

    for _, part := range parts {
        part = strings.TrimSpace(part)
        if part == "" {
            continue
        }

        // 提取函数名和参数
        funcNameEnd := strings.Index(part, "(")
        funcArgsStart := funcNameEnd + 1
        funcArgsEnd := strings.LastIndex(part, ")")

        if funcNameEnd == -1 || funcArgsEnd == -1 || funcArgsStart >= funcArgsEnd {
            return false, fmt.Errorf("invalid rule part format: %s", part)
        }

        funcName := part[:funcNameEnd]
        argsJson := part[funcArgsStart:funcArgsEnd]

        // 根据函数名调用对应的Go函数
        switch funcName {
        case "checkGeo":
            var geoData map[string][]string
            if err := json.Unmarshal([]byte(argsJson), &geoData); err != nil {
                return false, fmt.Errorf("failed to parse geo args: %w", err)
            }
            if !checkGeo(geoData) {
                result = false
            }
        case "check0s": // 注意，这里是check0s，与问题描述一致
            var osData map[string][]string
            if err := json.Unmarshal([]byte(argsJson), &osData); err != nil {
                return false, fmt.Errorf("failed to parse os args: %w", err)
            }
            if !check0s(osData) {
                result = false
            }
        default:
            return false, fmt.Errorf("unknown function: %s", funcName)
        }

        if !result { // 任何一个部分为false，则整个表达式为false
            break
        }
    }
    return result, nil
}

func main() {
    executor := NewRuleExecutor()
    rule1 := `checkGeo('{geo:["DE","AU","NL"]}') && check0s('{os:["android"]}')`

    res1, err1 := executor.Evaluate(rule1)
    if err1 != nil {
        fmt.Printf("Error evaluating rule1: %v\n", err1)
        return
    }
    fmt.Printf("Rule1 evaluation result: %t\n", res1) // 预期为true

    rule2 := `checkGeo('{geo:["US"]}') && check0s('{os:["ios"]}')`
    res2, err2 := executor.Evaluate(rule2)
    if err2 != nil {
        fmt.Printf("Error evaluating rule2: %v\n", err2)
        return
    }
    fmt.Printf("Rule2 evaluation result: %t\n", res2) // 预期为false
}