ToB企服应用市场:ToB评测及商务社交产业平台

标题: 浅谈如何使用 github.com/yuin/gopher-lua [打印本页]
作者: 温锦文欧普厨电及净水器总代理    时间: 2023-5-13 17:01
标题: 浅谈如何使用 github.com/yuin/gopher-lua
最近熟悉 go 项目时，发现项目中有用到 github.com/yuin/gopher-lua这个包，之前并没有接触过，特意去看了官方文档和找了些网上的资料，特此记录下。
本次介绍计划分为两篇文章，这一次主要介绍  github.com/yuin/gopher-lua 这个包的介绍以及基础使用，下一边将介绍  github.com/yuin/gopher-lua 是如何在项目中使用的。如有不对的地方，请不吝赐教，谢谢。
文章中的 gopher-lua 如果没有特别说明，即为：github.com/yuin/gopher-lua。
1、 gopher-lua 基础介绍

我们先开看看官方是如何介绍自己的：
  1. GopherLua is a Lua5.1(+ goto statement in Lua5.2) VM and compiler written in Go. GopherLua has a same goal with Lua: Be a scripting language with extensible semantics . It provides Go APIs that allow you to easily embed a scripting language to your Go host programs.
复制代码
GopherLua是一个Lua5.1（Lua5.2中的+goto语句）虚拟机和用Go编写的编译器。GopherLua与Lua有着相同的目标：成为一种具有可扩展语义的脚本语言。它提供了Go API，允许您轻松地将脚本语言嵌入到Go主机程序中。
看上面的翻译还是有点抽象，说说自己的理解。  github.com/yuin/gopher-lua  是一个纯 Golang 实现的 Lua 虚拟机，它能够很轻松的在 go 写的程序中调用 lua 脚本。另外提一嘴，使用插件后，也能够在 lua 脚本中调用 go 写好的代码。挺秀的！
接下来我们看一看，   github.com/yuin/gopher-lua  的性能如何，这里就直接引用官方自己做的测试来介绍。详情见 wiki page  链接。点进链接过后，发现性能还不错，执行效率和性能仅比 C 实现的 bindings 差点。
官方测试例子是生成斐波那契数列，测试执行结果如下：
progtimeanko182.73sotto173.32sgo-lua8.13sPython3.45.84sGopherLua5.40slua5.1.41.71s2、 gopher-lua 基础介绍

下面的介绍，都是基于 v1.1.0 版本进行的。
  1. go get github.com/yuin/gopher-lua@v1.1.0
复制代码
Go的版本需要 >= 1.9
2.1 gopher-lua 中的 hello world

这里写一个简单的程序，了解 gopher-lua 是如何使用的。
  1. package main
  3. import (
  4.         lua "github.com/yuin/gopher-lua"
  5. )
  7. func main() {
  8.         // 1、创建 lua 的虚拟机
  9.         L := lua.NewState()
  10.         // 执行完毕后关闭虚拟机
  11.         defer L.Close()
  12.         // 2、加载fib.lua
  13.         if err := L.DoString(`print("hello world")`); err != nil {
  14.                 panic(err)
  15.         }
  17. }
复制代码
执行结果：
  1. hello world
复制代码
看到这里，感觉没啥特别的地方，接下来，我们看一看 gopher-lua  如何调用事先写好的 lua脚本。
fib.lua 脚本内容：
  1. function fib(n)
  2.     if n < 2 then return n end
  3.     return fib(n-1) + fib(n-2)
  4. end
复制代码
main.go
  1. package main
  3. import (
  4.         "fmt"
  5.         lua "github.com/yuin/gopher-lua"
  6. )
  8. func main() {
  9.         // 1、创建 lua 的虚拟机
  10.         L := lua.NewState()
  11.         defer L.Close()
  12.         // 加载fib.lua
  13.         if err := L.DoFile(`fib.lua`); err != nil {
  14.                 panic(err)
  15.         }
  16.         // 调用fib(n)
  17.         err := L.CallByParam(lua.P{
  18.                 Fn:      L.GetGlobal("fib"), // 获取fib函数引用
  19.                 NRet:    1,                  // 指定返回值数量
  20.                 Protect: true,               // 如果出现异常，是panic还是返回err
  21.         }, lua.LNumber(10)) // 传递输入参数n
  22.         if err != nil {
  23.                 panic(err)
  24.         }
  25.         // 获取返回结果
  26.         ret := L.Get(-1)
  27.         // 从堆栈中扔掉返回结果
  28.     // 这里一定要注意，不调用此方法，后续再调用 L.Get(-1) 获取的还是上一次执行的结果
  29.     // 这里大家可以自己测试下
  30.         L.Pop(1)
  31.         // 打印结果
  32.         res, ok := ret.(lua.LNumber)
  33.         if ok {
  34.                 fmt.Println(int(res))
  35.         } else {
  36.                 fmt.Println("unexpected result")
  37.         }
  38. }
复制代码
执行结果：
55
从上面我们已经能够感受到部分  gopher-lua  的魅力了。接下来，我们就一起详细的学习学习  gopher-lua  。
2.2 gopher-lua 中的数据类型

All data in a GopherLua program is an LValue . LValue is an interface type that has following methods.
GopherLua程序中的所有数据都是一个LValue。LValue是一种具有以下方法的接口类型。

  1. // value.go:29
  3. type LValue interface {
  4.         String() string
  5.         Type() LValueType
  6.         // to reduce `runtime.assertI2T2` costs, this method should be used instead of the type assertion in heavy paths(typically inside the VM).
  7.         assertFloat64() (float64, bool)
  8.         // to reduce `runtime.assertI2T2` costs, this method should be used instead of the type assertion in heavy paths(typically inside the VM).
  9.         assertString() (string, bool)
  10.         // to reduce `runtime.assertI2T2` costs, this method should be used instead of the type assertion in heavy paths(typically inside the VM).
  11.         assertFunction() (*LFunction, bool)
  12. }
复制代码
上面来自官方的介绍，接下来我们看看 gopher-lua  支持那些数据类型。
Type nameGo typeType() valueConstantsLNilType(constants)LTNilLNilLBool(constants)LTBoolLTrue, LFalseLNumberfloat64LTNumber-LStringstringLTString-LFunctionstruct pointerLTFunction-LUserDatastruct pointerLTUserData-LStatestruct pointerLTThread-LTablestruct pointerLTTable-LChannelchan LValueLTChannel-具体的实现，大家有兴趣，可以自己去看看源码，这里就不做分析了。
那我们是如何知道 go 调用 lua 函数后，得到结果的类型呢？我们可以通过以下方式来知道：
  1. package main
  3. import (
  4.         "fmt"
  5.         lua "github.com/yuin/gopher-lua"
  6. )
  8. func main() {
  9.         // 1、创建 lua 的虚拟机
  10.         L := lua.NewState()
  11.         defer L.Close()
  12.         // 加载fib.lua
  13.         if err := L.DoFile(`fib.lua`); err != nil {
  14.                 panic(err)
  15.         }
  17.         TestString(L)
  18. }
  20. func TestString(L *lua.LState) {
  21.         err := L.CallByParam(lua.P{
  22.                 Fn:      L.GetGlobal("TestLString"), // 获取函数引用
  23.                 NRet:    1,                          // 指定返回值数量
  24.                 Protect: true,                       // 如果出现异常，是panic还是返回err
  25.         })
  26.         if err != nil {
  27.                 panic(err)
  28.         }
  30.         lv := L.Get(-1) // get the value at the top of the stack
  31.         // 从堆栈中扔掉返回结果
  32.         L.Pop(1)
  33.         if str, ok := lv.(lua.LString); ok {
  34.                 // lv is LString
  35.                 fmt.Println(string(str))
  36.         }
  37.         if lv.Type() != lua.LTString {
  38.                 panic("string required.")
  39.         }
  40. }
复制代码
fib.lua中的代码：
  1. function TestLString()
  2.     return "this is test"
  3. end
复制代码
接下来看看指针类型是如何判断的：
  1. lv := L.Get(-1) // get the value at the top of the stack
  2. if tbl, ok := lv.(*lua.LTable); ok {
  3.     // lv is LTable
  4.     fmt.Println(L.ObjLen(tbl))
  5. }
复制代码
特别注意：
大家有不明白的地方，推荐去看看官方怎么说的。
2.3 gopher-lua 中的调用堆栈和注册表大小

官方还介绍了性能优化这块的内容，我就不介绍了，大家感兴趣可以去看官方。
主要是对于我这种非科班出生的菜鸟来说，还是有点难度的，这里就不瞎说了，免得误导大家。哈哈......
一般来说，使用默认的方式，性能不会太差。对性能没有特别高的要求，也没有必要去折腾这个。
3、gopher-lua 中常用的API

3.1 lua 调用 Go 中的代码

test.lua 脚本内容：
  1. print(double(100))
复制代码
main.go 中的内容：
  1. package main
  3. import (
  4.         "fmt"
  5.         lua "github.com/yuin/gopher-lua"
  6. )
  8. func main() {
  9.         L := lua.NewState()
  10.         defer L.Close()
  11.         L.SetGlobal("double", L.NewFunction(Double)) /* Original lua_setglobal uses stack... */
  12.         L.DoFile("test.lua")
  13. }
  15. func Double(L *lua.LState) int {
  16.         fmt.Println("coming go code.............")
  17.         lv := L.ToInt(1)            /* get argument */
  18.         L.Push(lua.LNumber(lv * 2)) /* push result */
  19.         return 1                    /* number of results */
  20. }
复制代码
执行结果：
  1. coming go code.............
  2. 200
复制代码
上面我们已经实现了一个简单的 lua 脚本中调用 go 代码的功能。
3.2 使用Go创建模块给lua使用

上面介绍了 lua 中调用 Go中的代码，Go提供的功能不多还好，直接使用即可，但是实际项目中，既然使用到了Go和lua结合的模式，必然会存在Go提供基础功能，lua来编写业务的方式，这个时候如果还是使用上面的方式，使用起来将非常不方便。这里提供了一种方式，将Go中的功能封装成一个模块，提供给 lua 使用，这样就方便许多。
接下来我们一起看看怎么做。
mymodule.go 的内容：
  1. package main
  3. import (
  4.         "fmt"
  5.         lua "github.com/yuin/gopher-lua"
  6. )
  8. func Loader(L *lua.LState) int {
  9.         // register functions to the table
  10.         mod := L.SetFuncs(L.NewTable(), exports)
  11.         // register other stuff
  12.         L.SetField(mod, "name", lua.LString("testName"))
  14.         // returns the module
  15.         L.Push(mod)
  16.         return 1
  17. }
  19. var exports = map[string]lua.LGFunction{
  20.         "MyAdd": MyAdd,
  21. }
  23. func MyAdd(L *lua.LState) int {
  24.         fmt.Println("coming custom MyAdd")
  25.         x, y := L.ToInt(1), L.ToInt(2)
  26.         // 原谅我还不知道怎么把计算结果返回给 lua ，太菜了啦
  27.     // 不过用上另外一个包后，我知道，具体看实战篇。
  28.         fmt.Println(x)
  29.         fmt.Println(y)
  30.         return 1
  31. }
复制代码
main.go 的内容：
  1. package main
  3. import lua "github.com/yuin/gopher-lua"
  5. func main() {
  6.         L := lua.NewState()
  7.         defer L.Close()
  8.         L.PreloadModule("myModule", Loader)
  9.         if err := L.DoFile("main.lua"); err != nil {
  10.                 panic(err)
  11.         }
  12. }
复制代码
main.lua 的内容:
  1. local m = require("myModule")
  2. m.MyAdd(10, 20)
  3. print(m.name)
复制代码
运行 main.go 得到执行结果：
  1. coming custom MyAdd
  2. 10      
  3. 20      
  4. testName
复制代码
3.3 Go 调用 lua 中的代码

lua 中的代码
  1. function TestGoCallLua(x, y)
  2.     return x+y, x*y
  3. end
复制代码
go 中的代码
  1. func TestTestGoCallLua(L *lua.LState) {
  2.         err := L.CallByParam(lua.P{
  3.                 Fn:      L.GetGlobal("TestGoCallLua"), // 获取函数引用
  4.                 NRet:    2,                            // 指定返回值数量,注意这里的值是 2
  5.                 Protect: true,                         // 如果出现异常，是panic还是返回err
  6.         }, lua.LNumber(10), lua.LNumber(20))
  7.         if err != nil {
  8.                 panic(err)
  9.         }
  11.         multiplicationRet := L.Get(-1)
  12.         addRet := L.Get(-2)
  13.         if str, ok := multiplicationRet.(lua.LNumber); ok {
  14.                 fmt.Println("multiplicationRet is: ", int(str))
  15.         }
  17.         if str, ok := addRet.(lua.LNumber); ok {
  18.                 fmt.Println("addRet is: ", int(str))
  19.         }
  21. }
复制代码
具体的可以看 xxx 中的 TestTestGoCallLua 函数。
执行结果：
  1. multiplicationRet is:  200
  2. addRet is:  30
复制代码
3.4 lua中使用go中定义好的类型

这里我们直接使用官方的例子：
  1. type Person struct {
  2.     Name string
  3. }
  5. const luaPersonTypeName = "person"
  7. // Registers my person type to given L.
  8. func registerPersonType(L *lua.LState) {
  9.     mt := L.NewTypeMetatable(luaPersonTypeName)
  10.     L.SetGlobal("person", mt)
  11.     // static attributes
  12.     L.SetField(mt, "new", L.NewFunction(newPerson))
  13.     // methods
  14.     L.SetField(mt, "__index", L.SetFuncs(L.NewTable(), personMethods))
  15. }
  17. // Constructor
  18. func newPerson(L *lua.LState) int {
  19.     person := &Person{L.CheckString(1)}
  20.     ud := L.NewUserData()
  21.     ud.Value = person
  22.     L.SetMetatable(ud, L.GetTypeMetatable(luaPersonTypeName))
  23.     L.Push(ud)
  24.     return 1
  25. }
  27. // Checks whether the first lua argument is a *LUserData with *Person and returns this *Person.
  28. func checkPerson(L *lua.LState) *Person {
  29.     ud := L.CheckUserData(1)
  30.     if v, ok := ud.Value.(*Person); ok {
  31.         return v
  32.     }
  33.     L.ArgError(1, "person expected")
  34.     return nil
  35. }
  37. var personMethods = map[string]lua.LGFunction{
  38.     "name": personGetSetName,
  39. }
  41. // Getter and setter for the Person#Name
  42. func personGetSetName(L *lua.LState) int {
  43.     p := checkPerson(L)
  44.     if L.GetTop() == 2 {
  45.         p.Name = L.CheckString(2)
  46.         return 0
  47.     }
  48.     L.Push(lua.LString(p.Name))
  49.     return 1
  50. }
  52. func main() {
  53.     L := lua.NewState()
  54.     defer L.Close()
  55.     registerPersonType(L)
  56.     if err := L.DoString(`
  57.         p = person.new("Steeve")
  58.         print(p:name()) -- "Steeve"
  59.         p:name("Alice")
  60.         print(p:name()) -- "Alice"
  61.     `); err != nil {
  62.         panic(err)
  63.     }
  64. }
复制代码
官方还讲解了如何使用 go 中的context 来结束lua代码的执行，这里我就不演示了，大家自行研究。
3.5 gopher_lua 中goroutine的说明

这里直接放官方的文档，大家自行理解
  1. The LState is not goroutine-safe. It is recommended to use one LState per goroutine and communicate between goroutines by using channels.
复制代码
LState不是goroutine安全的。建议每个goroutine使用一个LState，并通过使用通道在goroutine之间进行通信。
  1. Channels are represented by channel objects in GopherLua. And a channel table provides functions for performing channel operations.
复制代码
在GopherLua中，通道由通道对象表示。通道表提供了执行通道操作的函数。这意味着，我们可以使用通道对象来创建、发送和接收消息，并使用通道表中的函数来控制通道的行为。通道是一种非常有用的并发编程工具，可以帮助我们在不同的goroutine之间进行通信和同步。通过使用GopherLua中的通道对象和通道表，我们可以轻松地在Lua代码中实现并发编程。
  1. Some objects can not be sent over channels due to having non-goroutine-safe objects inside itself.
复制代码
某些对象无法通过通道发送，因为其内部有非goroutine安全的对象。

上面这四种类型就不支持往通道中发送。
[code]package mainimport (        lua "github.com/yuin/gopher-lua"        "time")func receiver(ch, quit chan lua.LValue) {        L := lua.NewState()        defer L.Close()        L.SetGlobal("ch", lua.LChannel(ch))        L.SetGlobal("quit", lua.LChannel(quit))        if err := L.DoString(`    local exit = false    while not exit do      -- 这个 channel 的写法是固定的 ??      channel.select(        {"|



欢迎光临 ToB企服应用市场:ToB评测及商务社交产业平台 (https://dis.qidao123.com/) Powered by Discuz! X3.4