Go Expr：轻量级通用表达式引擎详解

6个月前更新

049016

引言

在软件开发中，经常需要动态评估表达式，比如规则引擎、配置系统、业务逻辑定制等场景。Go Expr 是一个用 Go 编写的轻量级表达式求值引擎，它允许你在运行时解析和计算表达式，而无需预先编译代码。本文将详细介绍 Go Expr 的特性、安装方法、基本用法以及高级功能。

一、Go Expr 简介

Go Expr 是一个用纯 Go 实现的表达式求值库，具有以下特点：

轻量级：无外部依赖，适合嵌入到各种 Go 项目中
高性能：编译表达式为字节码执行
类型安全：支持静态类型检查
功能丰富：支持算术运算、逻辑运算、函数调用等
可扩展：允许自定义函数和变量

二、安装

使用 Go 模块安装 Go Expr：

go get github.com/antonmedv/expr

三、基本用法

1. 简单表达式求值

package main

import (
    "fmt"
    "github.com/antonmedv/expr"
)

func main() {
    // 定义表达式
    expr := "10 + 2 * 3"

    // 计算表达式
    output, err := expr.Eval(expr)
    if err != nil {
        panic(err)
    }

    fmt.Println(output) // 输出: 16
}

2. 使用变量

package main

import (
    "fmt"
    "github.com/antonmedv/expr"
)

func main() {
    // 定义上下文变量
    env := map[string]interface{}{
        "a": 10,
        "b": 20,
    }

    // 定义使用变量的表达式
    expr := "a + b * 2"

    // 计算表达式
    output, err := expr.Eval(expr, env)
    if err != nil {
        panic(err)
    }

    fmt.Println(output) // 输出: 50
}

3. 类型安全的求值

package main

import (
    "fmt"
    "github.com/antonmedv/expr"
)

func main() {
    // 定义类型化的上下文
    env := struct {
        A int
        B int
    }{
        A: 10,
        B: 20,
    }

    // 定义表达式
    expr := "A + B * 2"

    // 计算表达式
    output, err := expr.Eval(expr, env)
    if err != nil {
        panic(err)
    }

    fmt.Println(output) // 输出: 50
}

四、高级功能

1. 自定义函数

package main

import (
    "fmt"
    "github.com/antonmedv/expr"
)

func main() {
    // 定义自定义函数
    env := map[string]interface{}{
        "pow": func(x, y int) int {
            result := 1
            for i := 0; i < y; i++ {
                result *= x
            }
            return result
        },
    }

    // 使用自定义函数的表达式
    expr := "pow(2, 3) + 1"

    // 计算表达式
    output, err := expr.Eval(expr, env)
    if err != nil {
        panic(err)
    }

    fmt.Println(output) // 输出: 9 (2^3 + 1)
}

2. 预编译表达式

对于需要多次求值的表达式，可以预编译以提高性能：

package main

import (
    "fmt"
    "github.com/antonmedv/expr"
)

func main() {
    // 预编译表达式
    program, err := expr.Compile("a + b * 2", expr.Env(map[string]interface{}{}))
    if err != nil {
        panic(err)
    }

    // 定义上下文
    env := map[string]interface{}{
        "a": 10,
        "b": 20,
    }

    // 执行预编译的表达式
    output, err := expr.Run(program, env)
    if err != nil {
        panic(err)
    }

    fmt.Println(output) // 输出: 50
}

3. 复杂数据结构支持

package main

import (
    "fmt"
    "github.com/antonmedv/expr"
)

func main() {
    // 定义复杂数据结构
    user := struct {
        Name   string
        Age    int
        Active bool
    }{
        Name:   "Alice",
        Age:    30,
        Active: true,
    }

    // 定义表达式
    expr := `Name == "Alice" && Age > 25 && Active`

    // 计算表达式
    output, err := expr.Eval(expr, user)
    if err != nil {
        panic(err)
    }

    fmt.Println(output) // 输出: true
}

4. 内置函数

Go Expr 提供了一些内置函数：

package main

import (
    "fmt"
    "github.com/antonmedv/expr"
)

func main() {
    // 使用内置函数
    expr := `len("hello") + len([1, 2, 3])`

    // 计算表达式
    output, err := expr.Eval(expr)
    if err != nil {
        panic(err)
    }

    fmt.Println(output) // 输出: 8 (5 + 3)
}

五、性能优化

对于高性能要求的场景，建议：

预编译表达式：避免重复编译
复用环境：对于不变的环境变量，可以复用
限制功能：只启用需要的功能以减少开销

// 预编译并复用表达式
program, _ := expr.Compile("a + b * 2", expr.Env(map[string]interface{}{}))

// 多次执行
env1 := map[string]interface{}{"a": 1, "b": 2}
output1, _ := expr.Run(program, env1) // 5

env2 := map[string]interface{}{"a": 3, "b": 4}
output2, _ := expr.Run(program, env2) // 11

六、安全考虑

当从不可信来源接收表达式时，需要注意安全风险：

沙箱环境：限制可用的函数和操作
超时控制：防止无限循环
输入验证：过滤危险字符

// 限制可用的函数
safeEnv := map[string]interface{}{
    "add": func(a, b int) int { return a + b },
}

// 只允许使用add函数的表达式
expr := "add(1, 2)" // 允许
// expr := "os.Exit(0)" // 如果os不在env中，则不允许