go调用lua
安装
使用
- 注册表
- 调用栈
- Data model
- Go中调用lua
API
- Lua调用go
- 打开Lua内置模块的子集
- 使用Go创建模块
- - 示例1（官方）
  - 示例2
- 关闭一个运行的lua虚拟机
- 虚拟机之间共享lua字节码
go-lua调优
- 预编译
- 虚拟机实例池
- 模块调用

go调用lua

这里比较下两个比较有名的go-lua包：

github.com/Shopify/go-lua和github.com/yuin/gopher-lua是两个Go语言库，允许Go程序与Lua脚本进行交互。

以下是这两个库之间的主要区别：

Shopify/go-lua:
- Shopify/go-lua是一个用Go编写的Lua解释器。
- 它旨在提供一个轻量级、易于使用的Go和Lua之间的接口。
- 该项目主要关注简单性和易集成性。
- 它提供了调用Go函数和Lua函数之间的绑定。
yuin/gopher-lua:
- yuin/gopher-lua是一个更丰富功能且活跃维护的Go语言Lua虚拟机实现。
- 它支持广泛的Lua功能，并包含一个标准库，涵盖许多常见的Lua功能。
- 这个库允许Go代码执行Lua脚本，访问Lua变量，并注册Go函数供Lua脚本使用。
- 它提供了更全面的文档和更大的社区，相比之下优于github.com/Shopify/go-lua。
- 根据我上次更新的信息，yuin/gopher-lua已经有了更近期的更新和改进，这表明它的维护活跃性更高。

在选择这些库时，请考虑项目的具体要求。如果您需要与Lua进行简单轻量级集成，github.com/Shopify/go-lua可能已经足够。另一方面，如果您需要一个功能更丰富且持续维护的库，支持更广泛的Lua功能，github.com/yuin/gopher-lua会是一个更好的选择。

安装

GopherLua supports >= Go1.9.

go get github.com/yuin/gopher-lua

使用

GopherLua的API与Lua的运行方式非常相似，但是堆栈仅用于传递参数和接收返回值。

Run scripts in the VM.

L := lua.NewState()
defer L.Close()
// 直接执行lua代码
if err := L.DoString(`print("hello")`); err != nil {panic(err)
}

L := lua.NewState()
defer L.Close()
// 执行lua脚本文件
if err := L.DoFile("hello.lua"); err != nil {panic(err)
}

调用栈和注册表大小:

LState的调用栈大小控制脚本中Lua函数的最大调用深度（Go函数调用不计入其中）。

LState的注册表实现对调用函数（包括Lua和Go函数）的栈式存储，并用于表达式中的临时变量。其存储需求会随着调用栈的使用和代码复杂性的增加而增加。

注册表和调用栈都可以设置为固定大小或自动大小。

当您在进程中实例化大量的LState时，值得花时间来调整注册表和调用栈的选项。

注册表

注册表可以在每个LState的基础上配置初始大小、最大大小和步长大小。这将允许注册表根据需要进行扩展。一旦扩展，它将不会再缩小。

 L := lua.NewState(lua.Options{RegistrySize: 1024 * 20,         // this is the initial size of the registryRegistryMaxSize: 1024 * 80,      // this is the maximum size that the registry can grow to. If set to `0` (the default) then the registry will not auto growRegistryGrowStep: 32,            // this is how much to step up the registry by each time it runs out of space. The default is `32`.})
defer L.Close()

如果注册表对于给定的脚本来说太小，最终可能会导致程序崩溃。而如果注册表太大，将会浪费内存（如果实例化了许多LState，这可能是一个显著的问题）。自动增长的注册表在调整大小时会带来一点点性能损耗，但不会影响其他方面的性能。

调用栈

调用栈可以以两种不同的模式运行，即固定大小或自动大小。固定大小的调用栈具有最高的性能，并且具有固定的内存开销。自动大小的调用栈将根据需要分配和释放调用栈页面，从而确保任何时候使用的内存量最小。缺点是，每次分配新的调用帧页面时都会带来一点小的性能影响。默认情况下，一个LState会以每页8个调用帧的方式分配和释放调用栈帧，因此不会在每个函数调用时产生额外的分配开销。对于大多数用例，自动调整大小的调用栈的性能影响可能是可以忽略的。

 L := lua.NewState(lua.Options{CallStackSize: 120,                 // this is the maximum callstack size of this LStateMinimizeStackMemory: true,          // Defaults to `false` if not specified. If set, the callstack will auto grow and shrink as needed up to a max of `CallStackSize`. If not set, the callstack will be fixed at `CallStackSize`.})
defer L.Close()

Data model

在GopherLua程序中，所有的数据都是LValue。LValue是一个接口类型，具有以下方法：

type LValue interface {String() stringType() LValueType// to reduce `runtime.assertI2T2` costs, this method should be used instead of the type assertion in heavy paths(typically inside the VM).assertFloat64() (float64, bool)// to reduce `runtime.assertI2T2` costs, this method should be used instead of the type assertion in heavy paths(typically inside the VM).assertString() (string, bool)// to reduce `runtime.assertI2T2` costs, this method should be used instead of the type assertion in heavy paths(typically inside the VM).assertFunction() (*LFunction, bool)
}

实现LValue接口的对象是：

Type name	Go type	Type() value	Constants
`LNilType`	(constants)	`LTNil`	`LNil`
`LBool`	(constants)	`LTBool`	`LTrue`, `LFalse`
`LNumber`	float64	`LTNumber`	`-`
`LString`	string	`LTString`	`-`
`LFunction`	struct pointer	`LTFunction`	`-`
`LUserData`	struct pointer	`LTUserData`	`-`
`LState`	struct pointer	`LTThread`	`-`
`LTable`	struct pointer	`LTTable`	`-`
`LChannel`	chan LValue	`LTChannel`	`-`

Go中调用lua

L := lua.NewState()
defer L.Close()
// 加载double.lua
if err := L.DoFile("double.lua"); err != nil {panic(err)
}if err := L.CallByParam(lua.P{// 获取函数名Fn: L.GetGlobal("double"),NRet: 1,Protect: true,}, lua.LNumber(10)); err != nil {panic(err)
}
ret := L.Get(-1) // returned value
L.Pop(1)  // remove received value

Lua支持多个参数和多个返回值，参数好办，用lua.LNumber(123)，返回值个数也可以是多个，调用CallByParam的时候，NRet就是返回参数个数，Fn是要调用的全局函数名，Protect为true时，如果没找到函数或者出错不会panic，只会返回err。

**GopherLua的函数调用是通过堆栈来进行的，调用前将参数压栈，完事后将结果放入堆栈中，调用方在堆栈顶部拿结果。**调用完成后，要以压栈的方式，一个一个取回返回值ret := L.Get(-1)。

fib.lua 脚本内容：

function fib(n)if n < 2 then return n endreturn fib(n-1) + fib(n-2)
end


package mainimport ("fmt"lua "github.com/yuin/gopher-lua"
)func main() {// 1、创建 lua 的虚拟机L := lua.NewState()defer L.Close()// 加载fib.lua// Calling DoFile will load a Lua script, compile it to byte code and run the byte code in a LState.// 所以DoFile既加载了文件又执行了字节码if err := L.DoFile(`fib.lua`); err != nil {panic(err)}// 调用fib(n)err := L.CallByParam(lua.P{Fn:      L.GetGlobal("fib"), // 获取fib函数引用NRet:    1,                  // 指定返回值数量Protect: true,               // 如果出现异常，是panic还是返回err}, lua.LNumber(10)) // 传递输入参数nif err != nil {panic(err)}// 获取返回结果ret := L.Get(-1)// 从堆栈中扔掉返回结果// 这里一定要注意，不调用此方法，后续再调用 L.Get(-1) 获取的还是上一次执行的结果// 这里大家可以自己测试下L.Pop(1)// 打印结果res, ok := ret.(lua.LNumber)if ok {fmt.Println(int(res))} else {fmt.Println("unexpected result")}
}

API

Lua调用go

LGFunction类型：type LGFunction func(*LState) int

func main() {L := lua.NewState()defer L.Close()L.SetGlobal("double", L.NewFunction(func(state *lua.LState) int {lv := state.ToInt(1)        /* get argument */L.Push(lua.LNumber(lv * 2)) /* push result */// 返回值个数return 1}))// 加载编译执行hello.luaL.DoFile("./hello.lua")
}

hello.lua中的内容：

print(double(100))

再来一个案例：

package mainimport ("fmt"lua "github.com/yuin/gopher-lua"
)func Add(L *lua.LState) int {// 获取参数arg1 := L.ToInt(1)arg2 := L.ToInt(2)ret := arg1 + arg2// 返回值L.Push(lua.LNumber(ret))// 返回值的个数return 1
}func main() {L := lua.NewState()defer L.Close()// 注册全局函数L.SetGlobal("add", L.NewFunction(Add))// goerr := L.DoFile("main.lua")if err != nil {fmt.Print(err.Error())return}
}

main.lua内容：

print(add(10,20))

打开Lua内置模块的子集

打开Lua内置模块的子集可以通过以下方式实现，例如，可以避免启用具有访问本地文件或系统调用权限的模块。

func main() {L := lua.NewState(lua.Options{SkipOpenLibs: true})defer L.Close()for _, pair := range []struct {n stringf lua.LGFunction}{{lua.LoadLibName, lua.OpenPackage}, // Must be first{lua.BaseLibName, lua.OpenBase},{lua.TabLibName, lua.OpenTable},} {if err := L.CallByParam(lua.P{Fn:      L.NewFunction(pair.f),NRet:    0,Protect: true,}, lua.LString(pair.n)); err != nil {panic(err)}}if err := L.DoFile("main.lua"); err != nil {panic(err)}
}

使用Go创建模块

GopherLua除了可以满足基本的lua需要，还将Go语言特有的高级设计直接移植到lua环境中，使得内嵌的脚本也具备了一些高级的特性

可以使用context.WithTimeout对执行的lua脚本进行超时

可以使用context.WithCancel打断正在执行的lua脚本

多个lua解释器实例之间还可以通过channel共享数据

支持多路复用选择器select

使用Lua作为内嵌脚本的另外一个重要优势在于Lua非常轻量级，占用内存极小。

示例1（官方）

mymodule.go：

package mainimport lua "github.com/yuin/gopher-lua"var exports = map[string]lua.LGFunction{"myfunc": myfunc,
}func myfunc(L *lua.LState) int {return 0
}func Loader(L *lua.LState) int {// register functions to the tablemod := L.SetFuncs(L.NewTable(), exports)// 注册name属性到moduleL.SetField(mod, "name", lua.LString("value"))// returns the moduleL.Push(mod)return 1
}

mymain.go：

package mainimport ("./mymodule""github.com/yuin/gopher-lua"
)func main() {L := lua.NewState()defer L.Close()L.PreloadModule("mymodule", mymodule.Loader)if err := L.DoFile("main.lua"); err != nil {panic(err)}
}

main.lua：

local m = require("mymodule")
m.myfunc()
print(m.name)

示例2

在Go语言的实现中，当我们将一个函数注册为Lua函数（通过L.SetFuncs等方法），它会被转换为LGFunction类型，这样可以确保与Lua C API兼容。返回的整数值用于指示函数的返回值数量（通常用0表示成功，1表示出错）。

实际上，这个整数值在Go的GopherLua实现中没有特别的意义，因为Go语言不需要遵循C API规范。但为了与标准的Lua C API保持一致，Go的GopherLua库仍然要求注册给Lua的函数遵循这个规范，即返回一个整数值。

因此，在Go的GopherLua中，LGFunction类型一定要有返回值，以满足与Lua C API的兼容性需求，即使这个返回值在Go代码中可能并没有特别的实际意义。

package mainimport (lua "github.com/yuin/gopher-lua"
)var exports = map[string]lua.LGFunction{"add": add,
}func add(L *lua.LState) int {// 第一个参数firstArg := L.Get(1).(lua.LNumber)// 第二个参数secondArg := L.Get(2).(lua.LNumber)// 返回值L.Push(firstArg + secondArg)// 返回值个数return 1
}func Loader(L *lua.LState) int {// register functions to the tablemod := L.SetFuncs(L.NewTable(), exports)// returns the moduleL.Push(mod)return 1
}

关闭一个运行的lua虚拟机

L := lua.NewState()
defer L.Close()
ctx, cancel := context.WithTimeout(context.Background(), 1*time.Second)
defer cancel()
// set the context to our LState
L.SetContext(ctx)
err := L.DoString(`local clock = os.clockfunction sleep(n)  -- secondslocal t0 = clock()while clock() - t0 <= n do endendsleep(3)
`)
// err.Error() contains "context deadline exceeded"

虚拟机之间共享lua字节码

调用DoFile会加载Lua脚本，将其编译为字节码并在LState中运行该字节码。

如果您有多个LState，都需要运行相同的脚本，您可以在它们之间共享字节码，这将节省内存。共享字节码是安全的，因为它是只读的，不会被Lua脚本更改。

// CompileLua reads the passed lua file from disk and compiles it.
func CompileLua(filePath string) (*lua.FunctionProto, error) {file, err := os.Open(filePath)defer file.Close()if err != nil {return nil, err}reader := bufio.NewReader(file)chunk, err := parse.Parse(reader, filePath)if err != nil {return nil, err}proto, err := lua.Compile(chunk, filePath)if err != nil {return nil, err}return proto, nil
}// DoCompiledFile takes a FunctionProto, as returned by CompileLua, and runs it in the LState. It is equivalent
// to calling DoFile on the LState with the original source file.
func DoCompiledFile(L *lua.LState, proto *lua.FunctionProto) error {lfunc := L.NewFunctionFromProto(proto)L.Push(lfunc)return L.PCall(0, lua.MultRet, nil)
}// Example shows how to share the compiled byte code from a lua script between multiple VMs.
func Example() {codeToShare := CompileLua("mylua.lua")a := lua.NewState()b := lua.NewState()c := lua.NewState()DoCompiledFile(a, codeToShare)DoCompiledFile(b, codeToShare)DoCompiledFile(c, codeToShare)
}

go-lua调优

预编译

在查看上述 DoString(…) 方法的调用链后，发现每执行一次 DoString(…) 或 DoFile(…) ，都会各执行一次 parse 和 compile 。

func (ls *LState) DoString(source string) error {if fn, err := ls.LoadString(source); err != nil {return err} else {ls.Push(fn)return ls.PCall(0, MultRet, nil)}
}func (ls *LState) LoadString(source string) (*LFunction, error) {return ls.Load(strings.NewReader(source), "<string>")
}func (ls *LState) Load(reader io.Reader, name string) (*LFunction, error) {chunk, err := parse.Parse(reader, name)// ...proto, err := Compile(chunk, name)// ...
}

从这一点考虑，在同份 Lua 代码将被执行多次的场景下，如果我们能够对代码进行提前编译，那么应该能够减少 parse 和 compile 的开销。

package glua_testimport ("bufio""os""strings"lua "github.com/yuin/gopher-lua""github.com/yuin/gopher-lua/parse"
)// 编译 lua 代码字段
func CompileString(source string) (*lua.FunctionProto, error) {reader := strings.NewReader(source)chunk, err := parse.Parse(reader, source)if err != nil {return nil, err}proto, err := lua.Compile(chunk, source)if err != nil {return nil, err}return proto, nil
}// 编译 lua 代码文件
func CompileFile(filePath string) (*lua.FunctionProto, error) {file, err := os.Open(filePath)defer file.Close()if err != nil {return nil, err}reader := bufio.NewReader(file)chunk, err := parse.Parse(reader, filePath)if err != nil {return nil, err}proto, err := lua.Compile(chunk, filePath)if err != nil {return nil, err}return proto, nil
}func BenchmarkRunWithoutPreCompiling(b *testing.B) {l := lua.NewState()for i := 0; i < b.N; i++ {_ = l.DoString(`a = 1 + 1`)}l.Close()
}func BenchmarkRunWithPreCompiling(b *testing.B) {l := lua.NewState()proto, _ := CompileString(`a = 1 + 1`)lfunc := l.NewFunctionFromProto(proto)for i := 0; i < b.N; i++ {l.Push(lfunc)_ = l.PCall(0, lua.MultRet, nil)}l.Close()
}// goos: darwin
// goarch: amd64
// pkg: glua
// BenchmarkRunWithoutPreCompiling-8         100000             19392 ns/op           85626 B/op         67 allocs/op
// BenchmarkRunWithPreCompiling-8           1000000              1162 ns/op            2752 B/op          8 allocs/op
// PASS
// ok      glua    3.328s

虚拟机实例池

新建一个 Lua 虚拟机会涉及到大量的内存分配操作，如果采用每次运行都重新创建和销毁的方式的话，将消耗大量的资源。引入虚拟机实例池，能够复用虚拟机，减少不必要的开销。

type lStatePool struct {m     sync.Mutexsaved []*lua.LState
}func (pl *lStatePool) Get() *lua.LState {pl.m.Lock()defer pl.m.Unlock()n := len(pl.saved)if n == 0 {return pl.New()}x := pl.saved[n-1]pl.saved = pl.saved[0 : n-1]return x
}func (pl *lStatePool) New() *lua.LState {L := lua.NewState()// setting the L up here.// load scripts, set global variables, share channels, etc...return L
}func (pl *lStatePool) Put(L *lua.LState) {pl.m.Lock()defer pl.m.Unlock()pl.saved = append(pl.saved, L)
}func (pl *lStatePool) Shutdown() {for _, L := range pl.saved {L.Close()}
}// Global LState pool
var luaPool = &lStatePool{saved: make([]*lua.LState, 0, 4),
}

README 提供的实例池实现，但注意到该实现在初始状态时，并未创建足够多的虚拟机实例（初始时，实例数为 0），以及存在 slice 的动态扩容问题，这都是值得改进的地方（这是一个可以提交pr的点）。

模块调用

gopher-lua 支持 Lua 调用 Go 模块，在 Golang 程序开发中，我们可能设计出许多常用的模块，这种跨语言调用的机制，使得我们能够对代码、工具进行复用。

package mainimport ("fmt"lua "github.com/yuin/gopher-lua"
)const source = `
local m = require("gomodule")
m.goFunc()
print(m.name)
`func main() {L := lua.NewState()defer L.Close()L.PreloadModule("gomodule", load)if err := L.DoString(source); err != nil {panic(err)}
}func load(L *lua.LState) int {mod := L.SetFuncs(L.NewTable(), exports)L.SetField(mod, "name", lua.LString("gomodule"))L.Push(mod)return 1
}var exports = map[string]lua.LGFunction{"goFunc": goFunc,
}func goFunc(L *lua.LState) int {fmt.Println("golang")return 0
}// golang
// gomodule