使用starlet简化Starlark脚本执行与数据转换

starlet是一个优秀的Go库，它简化了在Go应用中执行Starlark脚本以及与Go数据结构相互转换的过程。下面我将详细介绍如何使用这个库。

starlet核心功能

1. 执行Starlark脚本：在Go环境中运行Starlark脚本
2. 数据转换：在Go和Starlark数据结构间自动转换
3. 模块支持：提供标准库模块和自定义模块

基本使用方法

首先安装starlet：

go get github.com/qri-io/starlet

1. 简单脚本执行

package main

import (
	"fmt"
	"github.com/qri-io/starlet"
)

func main() {
	// 创建脚本执行器
	exec := starlet.NewExecutor(nil)

	// 执行简单脚本
	script := `
def greet(name):
    return "Hello, " + name + "!"

result = greet("World")
`
	out, err := exec.Execute(script)
	if err != nil {
		panic(err)
	}

	// 获取结果
	result := out["result"].(string)
	fmt.Println(result) // 输出: Hello, World!
}

2. 数据转换示例

starlet可以自动在Go和Starlark类型间转换：

package main

import (
	"fmt"
	"github.com/qri-io/starlet"
)

func main() {
	exec := starlet.NewExecutor(nil)

	// 输入数据
	input := map[string]interface{}{
		"numbers": []int{1, 2, 3, 4, 5},
		"config": map[string]string{
			"env":  "production",
			"host": "example.com",
		},
	}

	// 处理数据的脚本
	script := `
def process(data):
    total = 0
    for num in data["numbers"]:
        total += num
    
    return {
        "sum": total,
        "env": data["config"]["env"],
        "host": data["config"]["host"],
    }

result = process(input)
`

	// 执行脚本，传入输入数据
	out, err := exec.Execute(script, starlet.StringDict{"input": input})
	if err != nil {
		panic(err)
	}

	// 获取处理后的结果
	result := out["result"].(map[string]interface{})
	fmt.Printf("Sum: %d\n", result["sum"].(int64))
	fmt.Printf("Environment: %s\n", result["env"].(string))
}

3. 使用模块

starlet支持模块化，可以加载标准模块或自定义模块：

package main

import (
	"fmt"
	"github.com/qri-io/starlet"
	"github.com/qri-io/starlib/encoding/json"
)

func main() {
	// 创建执行器并加载json模块
	exec := starlet.NewExecutor(nil)
	exec.AddModule("json", json.Module)

	// 使用json模块处理数据
	script := `
data = {
    "name": "Alice",
    "age": 30,
    "skills": ["Go", "Python", "JavaScript"]
}

json_str = json.encode(data)
parsed = json.decode(json_str)

result = {
    "original": data,
    "json": json_str,
    "parsed": parsed,
}
`

	out, err := exec.Execute(script)
	if err != nil {
		panic(err)
	}

	result := out["result"].(map[string]interface{})
	fmt.Println("JSON string:", result["json"].(string))
}

4. 自定义函数

你可以将Go函数暴露给Starlark脚本使用：

package main

import (
	"fmt"
	"github.com/qri-io/starlet"
	"go.starlark.net/starlark"
)

// 自定义Go函数
func toUpper(thread *starlark.Thread, fn *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
	var s string
	if err := starlark.UnpackArgs("toUpper", args, kwargs, "s", &s); err != nil {
		return nil, err
	}
	return starlark.String(strings.ToUpper(s)), nil
}

func main() {
	exec := starlet.NewExecutor(nil)
	
	// 添加自定义函数
	exec.AddStringDict("utils", starlet.StringDict{
		"toUpper": starlet.NewBuiltin("toUpper", toUpper),
	})

	script := `
text = "hello starlark"
upper_text = utils.toUpper(text)
result = {
    "original": text,
    "upper": upper_text,
}
`

	out, err := exec.Execute(script)
	if err != nil {
		panic(err)
	}

	result := out["result"].(map[string]interface{})
	fmt.Println("Original:", result["original"].(string))
	fmt.Println("Upper:", result["upper"].(string))
}

高级用法

错误处理

out, err := exec.Execute(script)
if err != nil {
    if evalErr, ok := err.(*starlark.EvalError); ok {
        fmt.Println("Script error:", evalErr.Msg)
        fmt.Println("Call stack:", evalErr.Backtrace())
    } else {
        fmt.Println("Execution error:", err)
    }
    return
}

性能优化

对于频繁执行的脚本，可以预先编译：

// 预编译脚本
compiled, err := exec.Compile(script)
if err != nil {
    panic(err)
}

// 多次执行编译后的脚本
for i := 0; i < 10; i++ {
    out, err := exec.ExecuteCompiled(compiled, starlet.StringDict{"iteration": i})
    if err != nil {
        panic(err)
    }
    fmt.Println(out["result"])
}

总结

starlet提供了以下优势：

1. 简化了Starlark脚本在Go中的执行
2. 自动处理Go与Starlark类型转换
3. 支持模块化扩展
4. 提供良好的错误处理和性能优化选项

这使得它在配置处理、规则引擎、数据转换等场景中非常有用。