lua 光速入门

首先明确 lua 和 js Python一样是动态解释性语言，需要解释器执行。并且不同于 Python 的强类型与 js 的弱类型，它有点居中，倾向于强类型。

安装

1. 下载解释器，解压缩即可，里面是 exe 可执行文件。

https://www.lua.org/

2. 本地测试为了方便全局使用。可将执行文件目录添加到环境变量。
3. 之后即可使用可执行文件名在命令行执行 lua 脚本。

注释

-- 单行注释

--[[
    多行注释
]]
1
2
3
4
5

字符串

--双引号间的一串字符
str1 = "Lua"
--单引号间的一串字符
str2 = 'Lua'
--[[和]]--间的一串字符
str3 = [[Lua]]
str4 = [[使用双括号时，甚至能包含换行数据
换行了
最后一行]]
1
2
3
4
5
6
7
8
9

-- 字符串拼接
print('abc'..'def')
1
2

变量

-- 全局变量赋值
a = 'ikun'

-- 局部变量赋值
local b = 'ikun'
1
2
3
4
5

nil表示没有任何有效值，只要是没有声明的值，它就是 nil，类似于 undefined。

逻辑运算

-- 不等于：~=，等于：==
123 ~= 231
1
2

-- && || !
and or not
1
2

条件判断

if 条件1 then
    满足条件1
elseif 条件2 then
    不满足条件1，但是满足条件2
else
    前面条件全都不满足
end
1
2
3
4
5
6
7

n = 5
if n < 10 then
    print('n小于10')
end
1
2
3
4

循环

while 继续循环判断依据 do
    执行的代码
end
1
2
3

local result = 0
local num = 1

while num <= 100 do
    result = result + num
    num = num + 1
end

print(result)
1
2
3
4
5
6
7
8
9

-- 其中，步长可以省略，默认为1
for 临时变量名=开始值,结束值,步长 do
    循环的代码
end
1
2
3
4

local result = 0

for i=1,100 do
    result = result + i
end

print(result)
1
2
3
4
5
6
7

函数

function add(a, b)
    local res = a + b
    print(res)
    return res, "ikun" -- 支持多个返回值，类似于元祖类型
end

res, hhh = add(1, 2)
print(res, hhh)
1
2
3
4
5
6
7
8

Table (表)

table 是 Lua 中唯一的数据结构，用于表示数组、集合、字典等。类似于 JavaScript 的对象和数组。

t = {"a", "b", 123}
1

t = {1,3,8,5,4}
print(t[1]) --打印1
print(t[3]) --打印8

t[2] = 99 --更改第二个元素的值
print(t[2]) --打印99

t[6] = 2 --凭空新建第六个元素并赋值
print(t[6]) --打印2

print(t[10])
--因为不存在，打印nil
1
2
3
4
5
6
7
8
9
10
11
12

table 下标从 1 开始。并且在声明 table 时可以自定义下标。

如果全自定义下标的话，其实 table 就是 js 中的对象。

t = {
    ["apple"] = 10,
    banana = 12,
    pear = 6,
}
--使用["下标"] = 值
--和  下标 = 值
--都是正确写法
--当第二种方式有歧义时，应该用第一种方式

--可以用下面两种方式访问：
print(t["apple"])
--输出10
print(t.apple)
--输出10
--当第二种方式有歧义时，应该用第一种方式
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

table 的元素没有同类型限制，数字、字符串、函数可以混搭。

如果混搭的话，获取元素，默认从 1 开始的数字下标会跳过自定义了下标的元素进行计数。如下：

t = {
    666,
    name = "ikun",
    "hhh", -- 它的下标是 2，不是 3
    age = 20
}


print(t[1], t[2], t[3], t[4])
-- 666     hhh     nil     nil

print(t[1], t.name, t[3], t.age)
-- 666     ikun    nil     20

print(t[1], t.name, t[2], t.age)
-- 666     ikun    hhh     20

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

实际上，在 Lua 中，所有的全局变量全部被存放在了一个大 table 中，这个 table 名为：_G。类似于 js 的 window。

增删 table 元素。

• table.insert (table, [pos ,] value)
• table.remove (table [, pos])

local a = {1, 8}             --a[1] = 1,a[2] = 8
table.insert(a, 1, 3)   --在表索引为1处插入3
print(a[1], a[2], a[3])
table.insert(a, 10)    --在表的最后插入10
print(a[1], a[2], a[3], a[4])

-->打印的结果：
--3    1    8
--3    1    8    10


local a = { 1, 2, 3, 4}
print(table.remove(a, 1)) --删除速索引为1的元素
print(a[1], a[2], a[3], a[4])

print(table.remove(a))   --删除最后一个元素
print(a[1], a[2], a[3], a[4])

-->打印的结果：
--1
--2    3    4    nil
--4
--2    3    nil    nil
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

将元素是 string 或者 number 类型的 table，每个元素连接起来变成字符串并返回。

• table.concat (table [, sep [, i [, j ] ] ])

local a = {1, 3, 5, "hello" }
print(table.concat(a))
print(table.concat(a, "|"))

-->打印的结果：
--135hello
--1|3|5|hello
1
2
3
4
5
6
7

常用全局函数

1. print(s1, s2, ..., sn)：输出所有参数到标准输出，并在参数之间插入空格，最后输出一个换行符。

2. type(v)：返回参数 v 的类型，类型可以是 nil, number, string, boolean, table, function, thread, 或 userdata。

3. tonumber(e, base)：尝试将参数 e 转换为数字。如果 e 是一个数字字符串，那么它可以被转换成对应的数字。可选参数 base 指定了数字的进制（默认为 10）。

4. tostring(e)：将参数 e 转换为字符串。对于数值，它将其转换为数字的字符串表示形式。对于其他值，结果取决于 __tostring 元方法。

5. require(modname)：加载并运行指定模块 modname 的代码。如果模块已经加载，require 会返回之前加载的模块。

6. loadfile(filename)：加载名为 filename 的 Lua 文件，但不执行它。返回一个函数，当调用这个函数时，会执行文件中的代码。

7. loadstring(str)：加载字符串 str 中的 Lua 代码，但不执行它。返回一个函数，当调用这个函数时，会执行字符串中的代码。

模块化

---函数功能：
-- 生成从1-max的table
-- @输入值：table的最大值
-- @返回：  table结果
-- @例子：  local list = getNumberList(10)
local function getNumberList(max)
    local t = {}
    for i=1,max do
        table.insert(t,i)
    end
    return t
end

--手动返回一个table，包含了上面的函数
return {
    getNumberList = getNumberList,
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

当调用了require接口后，Lua虚拟机会自动加载你调用的文件，执行文件的内容，然后返回你文件里return的结果。

--引用tools.lua文件，并加载
local tool = require("tools")

local list = tool.getNumberList(12)
1
2
3
4