Lua脚本语言——进阶语法

Posted 2021-08-10 二宝小菜鸟

一.Lua 模块与包

模块类似于一个封装库，从 Lua 5.1 开始，Lua 加入了标准的模块管理机制，可以把一些公用的代码放在一个文件里，以 API 接口的形式在其他地方调用，有利于代码的重用和降低代码耦合度。

Lua 的模块是由变量、函数等已知元素组成的 table，因此创建一个模块很简单，就是创建一个 table，然后把需要导出的常量、函数放入其中，最后返回这个 table 就行。以下为创建自定义模块 module.lua，文件代码格式如下：

-- 文件名为 module.lua-- 定义一个名为 module 的模块module = {}
-- 定义一个常量module.constant = "这是一个常量"
-- 定义一个函数function module.func1() io.write("这是一个公有函数！\n")end
local function func2() print("这是一个私有函数！")end
function module.func3() func2()end
return module

由上可知，模块的结构就是一个 table 的结构，因此可以像操作调用 table 里的元素那样来操作调用模块里的常量或函数。

上面的 func2 声明为程序块的局部变量，即表示一个私有函数，因此是不能从外部访问模块里的这个私有函数，必须通过模块里的公有函数来调用.

1.require 函数

Lua提供了一个名为require的函数用来加载模块。要加载一个模块，只需要简单地调用就可以了。例如：

require("<模块名>")或者require "<模块名>"

执行 require 后会返回一个由模块常量或函数组成的 table，并且还会定义一个包含该 table 的全局变量。

-- test_module.lua 文件-- module 模块为上文提到到 module.luarequire("module")
print(module.constant)
module.func3()

运行结果：

这是一个常量这是一个私有函数！

或者给加载的模块定义一个别名变量，方便调用：

-- test_module2.lua 文件-- module 模块为上文提到到 module.lua-- 别名变量 mlocal m = require("module")
print(m.constant)
m.func3()

输出结果：

这是一个常量这是一个私有函数！

2.加载机制

对于自定义的模块，模块文件不是放在哪个文件目录都行，函数 require 有它自己的文件路径加载策略，它会尝试从 Lua 文件或 C 程序库中加载模块。

require 用于搜索 Lua 文件的路径是存放在全局变量 package.path 中，当 Lua 启动后，会以环境变量 LUA_PATH 的值来初始这个环境变量。如果没有找到该环境变量，则使用一个编译时定义的默认路径来初始化。

当然，如果没有 LUA_PATH 这个环境变量，也可以自定义设置，在当前用户根目录下打开 .profile 文件（没有则创建，打开 .bashrc 文件也可以），例如把 "~/lua/" 路径加入 LUA_PATH 环境变量里：

#LUA_PATHexport LUA_PATH="~/lua/?.lua;;"

文件路径以 ";" 号分隔，最后的 2 个 ";;" 表示新加的路径后面加上原来的默认路径。

接着，更新环境变量参数，使之立即生效。

source ~/.profile

这时假设 package.path 的值是：

/Users/dengjoe/lua/?.lua;./?.lua;/usr/local/share/lua/5.1/?.lua;/usr/local/share/lua/5.1/?/init.lua;/usr/local/lib/lua/5.1/?.lua;/usr/local/lib/lua/5.1/?/init.lua

那么调用 require("module") 时就会尝试打开以下文件目录去搜索目标。

/Users/dengjoe/lua/module.lua;./module.lua/usr/local/share/lua/5.1/module.lua/usr/local/share/lua/5.1/module/init.lua/usr/local/lib/lua/5.1/module.lua/usr/local/lib/lua/5.1/module/init.lua

如果找过目标文件，则会调用 package.loadfile 来加载模块。否则，就会去找 C 程序库。

搜索的文件路径是从全局变量 package.cpath 获取，而这个变量则是通过环境变量 LUA_CPATH 来初始。

搜索的策略跟上面的一样，只不过现在换成搜索的是 so 或 dll 类型的文件。如果找得到，那么 require 就会通过 package.loadlib 来加载它。

3.C 包

Lua和C是很容易结合的，使用 C 为 Lua 写包。

与Lua中写包不同，C包在使用以前必须首先加载并连接，在大多数系统中最容易的实现方式是通过动态连接库机制。

Lua在一个叫loadlib的函数内提供了所有的动态连接的功能。这个函数有两个参数:库的绝对路径和初始化函数。所以典型的调用的例子如下:

local path = "/usr/local/lua/lib/libluasocket.so"local f = loadlib(path, "luaopen_socket")

loadlib 函数加载指定的库并且连接到 Lua，然而它并不打开库（也就是说没有调用初始化函数），反之他返回初始化函数作为 Lua 的一个函数，这样我们就可以直接在Lua中调用他。

如果加载动态库或者查找初始化函数时出错，loadlib 将返回 nil 和错误信息。我们可以修改前面一段代码，使其检测错误然后调用初始化函数：

local path = "/usr/local/lua/lib/libluasocket.so"-- 或者 path = "C:\\windows\\luasocket.dll"，这是 Window 平台下local f = assert(loadlib(path, "luaopen_socket"))f() -- 真正打开库

一般情况下我们期望二进制的发布库包含一个与前面代码段相似的 stub 文件，安装二进制库的时候可以随便放在某个目录，只需要修改 stub 文件对应二进制库的实际路径即可。

将 stub 文件所在的目录加入到 LUA_PATH，这样设定后就可以使用 require 函数加载 C 库了。

二.Lua 元表(Metatable)

在 Lua table 中我们可以访问对应的 key 来得到 value 值，但是却无法对两个 table 进行操作(比如相加)。

因此 Lua 提供了元表(Metatable)，允许我们改变 table 的行为，每个行为关联了对应的元方法。

例如，使用元表我们可以定义 Lua 如何计算两个 table 的相加操作 a+b。

当 Lua 试图对两个表进行相加时，先检查两者之一是否有元表，之后检查是否有一个叫 __add 的字段，若找到，则调用对应的值。 __add 等即时字段，其对应的值（往往是一个函数或是 table）就是"元方法"。

有两个很重要的函数来处理元表：

• setmetatable(table,metatable): 对指定 table 设置元表(metatable)，如果元表(metatable)中存在 __metatable 键值，setmetatable 会失败。

• getmetatable(table): 返回对象的元表(metatable)。

以下实例演示了如何对指定的表设置元表：

mytable = {} -- 普通表mymetatable = {} -- 元表setmetatable(mytable,mymetatable) -- 把 mymetatable 设为 mytable 的元表

以上代码也可以直接写成一行：

mytable = setmetatable({},{})

以下为返回对象元表：

getmetatable(mytable) -- 这回返回mymetatable

1.__index 元方法

这是 metatable 最常用的键。

当你通过键来访问 table 的时候，如果这个键没有值，那么Lua就会寻找该table的metatable（假定有metatable）中的__index 键。如果__index包含一个表格，Lua会在表格中查找相应的键。

我们可以在使用 lua 命令进入交互模式查看：

$ luaLua 5.3.0 Copyright (C) 1994-2015 Lua.org, PUC-Rio> other = { foo = 3 }> t = setmetatable({}, { __index = other })> t.foo3> t.barnil

如果__index包含一个函数的话，Lua就会调用那个函数，table和键会作为参数传递给函数。

__index 元方法查看表中元素是否存在，如果不存在，返回结果为 nil；如果存在则由 __index 返回结果。

实例：

mytable = setmetatable({key1 = "value1"}, { __index = function(mytable, key) if key == "key2" then return "metatablevalue" else return nil end end})
print(mytable.key1,mytable.key2)

实例输出结果：

value1 metatablevalue

实例解析：

• mytable 表赋值为 {key1 = "value1"}。

• mytable 设置了元表，元方法为 __index。

• 在mytable表中查找 key1，如果找到，返回该元素，找不到则继续。

• 在mytable表中查找 key2，如果找到，返回 metatablevalue，找不到则继续。

• 判断元表有没有__index方法，如果__index方法是一个函数，则调用该函数。

• 元方法中查看是否传入 "key2" 键的参数（mytable.key2已设置），如果传入 "key2" 参数返回 "metatablevalue"，否则返回 mytable 对应的键值。

  
  

我们可以将以上代码简单写成：

mytable = setmetatable({key1 = "value1"}, { __index = { key2 = "metatablevalue" } })print(mytable.key1,mytable.key2)

总结：

Lua 查找一个表元素时的规则，其实就是如下 3 个步骤:

• 1.在表中查找，如果找到，返回该元素，找不到则继续

• 2.判断该表是否有元表，如果没有元表，返回 nil，有元表则继续。

• 3.判断元表有没有 __index 方法，如果 __index 方法为 nil，则返回 nil；如果 __index 方法是一个表，则重复 1、2、3；如果 __index 方法是一个函数，则返回该函数的返回值。

2.__newindex 元方法

__newindex 元方法用来对表更新，__index则用来对表访问 。

当你给表的一个缺少的索引赋值，解释器就会查找__newindex 元方法：如果存在则调用这个函数而不进行赋值操作。

以下实例演示了 __newindex 元方法的应用：

mymetatable = {}mytable = setmetatable({key1 = "value1"}, { __newindex = mymetatable })
print(mytable.key1)
mytable.newkey = "新值2"print(mytable.newkey,mymetatable.newkey)
mytable.key1 = "新值1"print(mytable.key1,mymetatable.key1)

输出结果：

value1nil 新值2新值1 nil

以下实例使用了 rawset 函数来更新表：

mytable = setmetatable({key1 = "value1"}, { __newindex = function(mytable, key, value) rawset(mytable, key, "\""..value.."\"") end})
mytable.key1 = "new value"mytable.key2 = 4
print(mytable.key1,mytable.key2)

输出结果：

new value "4"

3.为表添加操作符

以下实例演示了两表相加操作：

-- 计算表中最大值，table.maxn在Lua5.2以上版本中已无法使用-- 自定义计算表中最大键值函数 table_maxn，即计算表的元素个数function table_maxn(t) local mn = 0 for k, v in pairs(t) do if mn < k then mn = k end end return mnend
-- 两表相加操作mytable = setmetatable({ 1, 2, 3 }, { __add = function(mytable, newtable) for i = 1, table_maxn(newtable) do table.insert(mytable, table_maxn(mytable)+1,newtable[i]) end return mytable end})
secondtable = {4,5,6}
mytable = mytable + secondtable for k,v in ipairs(mytable) doprint(k,v)end

输出结果：

1 12 23 34 45 56 6

__add 键包含在元表中，并进行相加操作。表中对应的操作列表如下：(注意：__是两个下划线)

4.__call 元方法

__call 元方法在 Lua 调用一个值时调用。以下实例演示了计算表中元素的和：

-- 计算表中最大值，table.maxn在Lua5.2以上版本中已无法使用-- 自定义计算表中最大键值函数 table_maxn，即计算表的元素个数function table_maxn(t) local mn = 0 for k, v in pairs(t) do if mn < k then mn = k end end return mnend
-- 定义元方法__callmytable = setmetatable({10}, { __call = function(mytable, newtable) sum = 0 for i = 1, table_maxn(mytable) do sum = sum + mytable[i] end for i = 1, table_maxn(newtable) do sum = sum + newtable[i] end return sum end})newtable = {10,20,30}print(mytable(newtable))

输出结果：

70

5.__tostring 元方法

__tostring 元方法用于修改表的输出行为。以下实例我们自定义了表的输出内容：

mytable = setmetatable({ 10, 20, 30 }, { __tostring = function(mytable) sum = 0 for k, v in pairs(mytable) do sum = sum + v end return "表所有元素的和为 " .. sum end})print(mytable)

输出结果：

表所有元素的和为 60

三.Lua 协同程序(coroutine)

什么是协同(coroutine)？

Lua 协同程序(coroutine)与线程比较类似：拥有独立的堆栈，独立的局部变量，独立的指令指针，同时又与其它协同程序共享全局变量和其它大部分东西。协同是非常强大的功能，但是用起来也很复杂。

线程和协同程序区别:

线程与协同程序的主要区别在于，一个具有多个线程的程序可以同时运行几个线程，而协同程序却需要彼此协作的运行。

在任一指定时刻只有一个协同程序在运行，并且这个正在运行的协同程序只有在明确的被要求挂起的时候才会被挂起。

协同程序有点类似同步的多线程，在等待同一个线程锁的几个线程有点类似协同。

基本语法:

以下实例演示了以上各个方法的用法：

-- coroutine_test.lua 文件co = coroutine.create( function(i) print(i); end)
coroutine.resume(co, 1) -- 1print(coroutine.status(co)) -- dead
print("----------")
co = coroutine.wrap( function(i) print(i); end)
co(1)
print("----------")
co2 = coroutine.create( function() for i=1,10 do print(i) if i == 3 then print(coroutine.status(co2)) --running print(coroutine.running()) --thread:XXXXXX end coroutine.yield() end end)
coroutine.resume(co2) --1coroutine.resume(co2) --2coroutine.resume(co2) --3
print(coroutine.status(co2)) -- suspendedprint(coroutine.running())
print("----------")

输出结果：

1dead----------1----------123runningthread: 0x7fb801c05868 falsesuspendedthread: 0x7fb801c04c88 true----------

coroutine.running就可以看出来,coroutine在底层实现就是一个线程。

当create一个coroutine的时候就是在新线程中注册了一个事件。

当使用resume触发事件的时候，create的coroutine函数就被执行了，当遇到yield的时候就代表挂起当前线程，等候再次resume触发事件。

接下来我们分析一个更详细的实例：

function foo (a) print("foo 函数输出", a) return coroutine.yield(2 * a) -- 返回 2*a 的值end
co = coroutine.create(function (a , b) print("第一次协同程序执行输出", a, b) -- co-body 1 10 local r = foo(a + 1)
 print("第二次协同程序执行输出", r) local r, s = coroutine.yield(a + b, a - b) -- a，b的值为第一次调用协同程序时传入
 print("第三次协同程序执行输出", r, s) return b, "结束协同程序" -- b的值为第二次调用协同程序时传入end)
print("main", coroutine.resume(co, 1, 10)) -- true, 4print("--分割线----")print("main", coroutine.resume(co, "r")) -- true 11 -9print("---分割线---")print("main", coroutine.resume(co, "x", "y")) -- true 10 endprint("---分割线---")print("main", coroutine.resume(co, "x", "y")) -- cannot resume dead coroutineprint("---分割线---")

输出结果：

第一次协同程序执行输出 1 10foo 函数输出 2main true 4--分割线----第二次协同程序执行输出 rmain true 11 -9---分割线---第三次协同程序执行输出 x ymain true 10 结束协同程序---分割线---main false cannot resume dead coroutine---分割线---

以上实例接下如下：

• 调用resume，将协同程序唤醒,resume操作成功返回true，否则返回false；

• 协同程序运行；

• 运行到yield语句；

• yield挂起协同程序，第一次resume返回；（注意：此处yield返回，参数是resume的参数）

• 第二次resume，再次唤醒协同程序；（注意：此处resume的参数中，除了第一个参数，剩下的参数将作为yield的参数）

• yield返回；

• 协同程序继续运行；

• 如果使用的协同程序继续运行完成后继续调用 resume方法则输出：cannot resume dead coroutine

resume和yield的配合强大之处在于，resume处于主程中，它将外部状态（数据）传入到协同程序内部；而yield则将内部的状态（数据）返回到主程中。

1.生产者-消费者问题

现在我就使用Lua的协同程序来完成生产者-消费者这一经典问题。

local newProductor
function productor() local i = 0 while true do i = i + 1 send(i) -- 将生产的物品发送给消费者 endend
function consumer() while true do local i = receive() -- 从生产者那里得到物品 print(i) endend
function receive() local status, value = coroutine.resume(newProductor) return valueend
function send(x) coroutine.yield(x) -- x表示需要发送的值，值返回以后，就挂起该协同程序end
-- 启动程序newProductor = coroutine.create(productor)consumer()

输出结果：

12345678910111213……

四.Lua 文件 I/O

Lua I/O 库用于读取和处理文件。分为简单模式（和C一样）、完全模式。

• 简单模式（simple model）拥有一个当前输入文件和一个当前输出文件，并且提供针对这些文件相关的操作。

• 完全模式（complete model） 使用外部的文件句柄来实现。它以一种面对对象的形式，将所有的文件操作定义为文件句柄的方法

简单模式在做一些简单的文件操作时较为合适。但是在进行一些高级的文件操作的时候，简单模式就显得力不从心。例如同时读取多个文件这样的操作，使用完全模式则较为合适。

打开文件操作语句如下：

file = io.open (filename [, mode])

mode 的值有：

1.简单模式

简单模式使用标准的 I/O 或使用一个当前输入文件和一个当前输出文件。

以下为 file.lua 文件代码，操作的文件为test.lua(如果没有你需要创建该文件)，代码如下：

-- 以只读方式打开文件file = io.open("test.lua", "r")
-- 设置默认输入文件为 test.luaio.input(file)
-- 输出文件第一行print(io.read())
-- 关闭打开的文件io.close(file)
-- 以附加的方式打开只写文件file = io.open("test.lua", "a")
-- 设置默认输出文件为 test.luaio.output(file)
-- 在文件最后一行添加 Lua 注释io.write("-- test.lua 文件末尾注释")
-- 关闭打开的文件io.close(file)

执行以上代码，你会发现，输出了 test.lua 文件的第一行信息，并在该文件最后一行添加了 lua 的注释。如我这边输出的是：

-- test.lua 文件

在以上实例中我们使用了 io."x" 方法，其中 io.read() 中我们没有带参数，参数可以是下表中的一个：

其他的 io 方法有：

• io.tmpfile():返回一个临时文件句柄，该文件以更新模式打开，程序结束时自动删除

• io.type(file): 检测obj是否一个可用的文件句柄

• io.flush(): 向文件写入缓冲中的所有数据

• io.lines(optional file name): 返回一个迭代函数,每次调用将获得文件中的一行内容,当到文件尾时，将返回nil,但不关闭文件

2.完全模式

通常我们需要在同一时间处理多个文件。我们需要使用 file:function_name 来代替 io.function_name 方法。以下实例演示了如何同时处理同一个文件:

-- 以只读方式打开文件file = io.open("test.lua", "r")
-- 输出文件第一行print(file:read())
-- 关闭打开的文件file:close()
-- 以附加的方式打开只写文件file = io.open("test.lua", "a")
-- 在文件最后一行添加 Lua 注释file:write("--test")
-- 关闭打开的文件file:close()

执行以上代码，你会发现，输出了 test.ua 文件的第一行信息，并在该文件最后一行添加了 lua 的注释。如我这边输出的是：

-- test.lua 文件

read 的参数与简单模式一致。

其他方法:

• file:seek(optional whence, optional offset): 设置和获取当前文件位置,成功则返回最终的文件位置(按字节),失败则返回nil加错误信息。参数 whence 值可以是:

  不带参数file:seek()则返回当前位置,file:seek("set")则定位到文件头,file:seek("end")则定位到文件尾并返回文件大小

• "set": 从文件头开始

• "cur": 从当前位置开始[默认]

• "end": 从文件尾开始

• offset:默认为0

• file:flush(): 向文件写入缓冲中的所有数据

• io.lines(optional file name): 打开指定的文件filename为读模式并返回一个迭代函数,每次调用将获得文件中的一行内容,当到文件尾时，将返回nil,并自动关闭文件。
  若不带参数时io.lines() <=> io.input():lines(); 读取默认输入设备的内容，但结束时不关闭文件,如：

for line in io.lines("main.lua") do　　print(line)end

以下实例使用了 seek 方法，定位到文件倒数第 25 个位置并使用 read 方法的 *a 参数，即从当期位置(倒数第 25 个位置)读取整个文件。

-- 以只读方式打开文件file = io.open("test.lua", "r")
file:seek("end",-25)print(file:read("*a"))
-- 关闭打开的文件file:close()

输出结果：

st.lua 文件末尾--test