2.2.1 Lua语言

Lua 语言是由巴西里约热内卢宗座天主教大学的一个团队设计和维护的，它诞生于1993年，当前最新的版本是 Lua 5.4。Lua 最大的特点就是可嵌入，常被用于电子游戏，工业软件，嵌入式系统中。

www.lua.org 是 Lua 语言的官方网站，lua-users.org 是一个由社区开发者维护的知识库，两者是学习 Lua 语言的最佳途径。本书就 Lua 语言的基础知识进行简要介绍。

1.基础数据类型

-- number
local num1 = 0
local num2 = 3.14

-- string
-- 表示字符串的三种方式：单引号，双引号 或 一对 [[]]
local str1 = 'abc123'
local str2 = "abc123"
local str3 = [[abc123]]

-- boolean
local is_ready = true -- boolean

-- nil
local empty = nil

Lua是一种弱类型的解释性语言，它使用 local 关键字声明局部变量，未使用 local 而直接定义的变量将称为全局变量。所以，除非确定要声明全局变量，否则变量一律使用 local 声明。

Lua 使用 nil 表示“空”，未赋值的变量默认值是 nil。

以下我们通过 Lua 和较流行的 JavaScript，Python 语言对比，让大家直观感受 Lua 和他们的异同点。

语言对比项	Lua	JavaScript	Python
声明局部变量	local a = 1	let a = 1	a = 1
查看变量的数据类型	type(a)	typeof a	type(a)
查看变量的数据类型	type(a)	typeof a	type(a)

2.table 数据类型

table 数据类型是 Lua 特有的一种类型，它可以表现为一个哈希表或数组。

-- 数组
local a1 = { 1, 'abc', 'xyz' }
print(a1[1]) -- 1
print(a1[2]) -- abc
print(a1[3]) -- xyz

-- 哈希表
local a2 = { k1 = 'abc', k2 = 'xyz' }
-- a2.k1 和 a2['k1'] 均可
print(a2.k1) -- abc
print(a2['k1']) -- abc
print(a2.k2) -- xyz
print(a2['k2']) -- xyz

-- 两者的混合
-- 不建议这样使用 table
local a3 = { k1 = 'abc', k2 = 'xyz', 3, 4, 5 }
print(a3.k1) -- abc
print(a3.k2) -- xyz
print(a3[1]) -- 3
print(a3[2]) -- 4
print(a3[3]) -- 5

Lua 中的 table 有些像 Javascript 中的 Object 和 Array，它的灵活度非常高，它可以包含任意数据类型，甚至可以包含函数和其它table，如下面的例子。

local _M = {} -- table

_M.config = {
    a = 1
}

_M.init = function ()
    -- do something
end

_M.run = function ()
    -- run something
end

print(_M.config) -- table: 0x1665cf0
print(_M.init) -- function: 0xc367e0
print(_M.run) --function: 0xc3d1e0

当我们尝试打印 _M.config 和 _M.init 时，不难发现他们是引用类型。也就是说变量保存的是一个内存地址。当没有任何引用指向某个 table 时，它所占用的内存就会被Lua的垃圾回收机制自动回收。

local a = { name = "Kim" }
local b = a

print(b.name) -- Kim

a.name = "John"

print(b.name) -- John

-- 注意，a = nil 即意味着将 a 变量删除
-- 但是不意味着 { name = "Kim" } 的销毁
-- 因为仍然有 b 变量指向该 table
a = nil
print(b.name) -- John

使用 table 类型表示一个数组时，它的索引值是从 1 开始的，而不是 0。这一点与常见的编程语言不同，也是刚接触 Lua 的开发者最容易犯错的地方。以下是 table 类型的一些特点。

• 索引从 1 开始而不是 0。

• 使用 = 连接键值对，而不是更贴近JSON结构的 :。

• 不要在 table 中使用 nil 值，当 table 中存在 nil 值时，计算 table 长度会出问题。

3.控制结构

-- if
local is_ready = true
if is_ready then
    print("ready")
end

-- if-else
if is_ready then
    print("ready")
else
    print("not ready")
end

-- if-elseif-else
local x = 3
if x > 100 then
    print("x > 100")
elseif x > 10 then
    print("x > 10 and x <= 100")
else
    print("x <= 10")
end
-- 打印结果
-- x <= 10

-- while
while x >= 0 do
    print(x)
    x = x - 1
end
-- 打印结果
-- 3
-- 2
-- 1
-- 0

-- for
-- for 循环的格式
-- for var = begin, finish, step do
-- end
for i = 3, 1, -1 do
  print(i)
end
-- 打印结果
-- 3
-- 2
-- 1

Lua 没有提供 continue 控制语句来跳入下一次循环，但是提供了 break 控制语句来跳出当前的 while，repeat 或 for 循环。

local students = { "Lisa", "Mike", "Alan", "Kim" }
-- 使用 #students 计算 table 长度
for i = 1, #students do
    if students[i] == "Alan" then
        print("Find Alan")
        break -- 找到 Alan 后跳出 for 循环
    else
        print(students[i] .. " is not Alan") -- 使用 .. 连接字符串
    end
end

-- 打印结果
-- Lisa is not Alan
-- Mike is not Alan
-- Find Alan

对于 table 类型，Lua 提供了两个函数 ipairs 和 pairs 用来遍历所有值。ipairs 仅用来遍历数组，而 pairs 可以遍历任何类型的 table。

local students = { "Lisa", "Mike", "Alan", "Kim" }

-- ipairs
for i, v in ipairs(students) do
    print("index:", i, " name:", v)
end

-- 打印结果
-- index:	1	 name:	Lisa
-- index:	2	 name:	Mike
-- index:	3	 name:	Alan
-- index:	4	 name:	Kim

-- pairs
for k, v in pairs(students) do
    print("index:", k, " name:", v)
end
-- 打印结果
-- index:	1	 name:	Lisa
-- index:	2	 name:	Mike
-- index:	3	 name:	Alan
-- index:	4	 name:	Kim

-- pairs
local user = { name = "Alan", gender = "male", age = 15 }
for k, v in pairs(user) do
    print("key:", k, " value:", v)
end
-- 打印结果
-- key:	age	 value:	15
-- key:	gender	 value:	male
-- key:	name	 value:	Alan


-- table 中存在 nil 的异常情况
local students = { "Lisa", nil, "Alan", "Kim" }
for i, v in ipairs(students) do
    print("index:", i, " name:", v)
end
-- 打印结果
-- index:	1	 name:	Lisa
-- 分析：ipairs 迭代器遇到 nil 值即认为 table 终止，所以尽量避免在 table 中使用 nil 值。

4.函数

-- 函数的定义
local function function_name (arg1, arg2, ..)
    -- 函数体
end

-- 函数示例
local function add(x, y)
    return x + y
end

-- 调用 add 函数
add(1, 2) -- return 3

使用 local 修饰符的函数为本地函数，如果没有 local 则为全局函数，除非确定要声明全局函数，否则函数一律使用 local 关键字。

在Lua中，函数是可以返回多个值的。

local function add(x, y)
    if type(x) == 'number' and type(y) == 'number' then
        return x + y, nil
    else
        return nil, 'not a number'
    end
end

local sum, err = add(1, 2)
print(sum, err) -- 3	nil

sum, err = add('abc', 'xyz')
print(sum, err) -- nil	not a number

上述 add(x, y) 函数返回了两个值：数字的加和与错误提示，当参数不符合约定时，该函数会提示相应的错误信息“not a number”。

函数的入参数量也可以时不定的。

-- 计算平均值
local function average(...)
   local sum = 0
   local arg = {...}
   for i, v in ipairs(arg) do
      sum = sum + v
   end

   return sum / #arg
end

average(1, 2, 3) -- return 2.0
average(1, 2, 3, 4, 5) -- return 3.0

如果函数的形参为...，则意味着它的参数个数是不定的。

因为 table 是引用类型，当函数的参数为 table 类型时，函数对该 table 的修改会对实参生效。

local user = { name = "Alan", gender = "male", age = 15 }

local function update_age (arg)
    arg.age = 16
end

update_age(user)
print(user.age) -- 16

5.模块

引入对模块和包的支持，是 Lua 5.1 的一项重大改进。将功能解耦并封装进模块中，这是一种良好的做法。以下是一个模块示例：

-- 模块示例：用户模块
-- user.lua
local _M = {}

_M.get_name = function ()
    return "Alan"
end

_M.get_gender = function ()
    return "male"
end

_M.get_age = function ()
    return 15
end

return _M

当我们需要使用用户模块时，只需要使用 require 函数将其加载即可。已经加载的模块不会被重复加载。

-- other.lua
local user = require('user')
local name = user.get_name()

print(name) -- Alan