Lua 零基础入门

Lua

1.Lua是什么？

1.1 Lua的历史

Lua是由Roberto Ierusalimschy、Luiz Henrique de Figueiredo和Waldemar Celes于1993年创建的，当时他们是巴西里约热内卢天主教大学计算机图形技术组（Tecgraf）的成员。在开发Lua之前，他们曾参与过数据描述/配置语言"SOL"（简单对象语言）和"DEL"（数据录入语言）的工作。这两种语言是他们独立开发的两个不同项目的一部分，旨在增强工程应用的交互式图形程序。然而，SOL和DEL缺乏许多控制流结构，因此需要增加完整的编程能力。因此，为了满足这个需求，他们创建了Lua。

在《The Evolution of Lua》中，Lua的作者写道，在1993年，Tcl是Lua的唯一真正竞争者，但Tcl的语法相对较为陌生，且只能在Unix平台上运行，不太适合数据描述。此外，LISP和Scheme的语法也不够友好，Python还处于起步阶段。在Tecgraf的自由、自主的氛围下，他们自然而然地尝试开发自己的脚本语言。考虑到这门语言的潜在用户不一定是专业程序员，因此他们希望语言避免复杂的语法和语义。另外，由于Tecgraf的客户使用各种不同的计算机平台，他们希望新语言的实现能够高度可移植。最后，考虑到Tecgraf的其他产品也需要嵌入脚本语言，他们决定让新语言像SOL一样提供带有C API的库。

1.2 Lua的特点

Lua 作为一种脚本语言具有多种特点，以下是其中一些主要的特点：

1. 轻量级和可嵌入性：Lua 的核心非常小巧，可以轻松地嵌入到其他应用程序中，作为脚本语言使用。这使得 Lua 在游戏开发、嵌入式系统和其他领域中得到广泛应用。
2. 简洁清晰的语法：Lua 的语法简洁明了，易于学习和使用。它没有过多的冗余符号，采用基于表达式的语法，没有大括号，使用 end 关键字来结束块，使得代码更加清晰易读。
3. 动态类型和自动内存管理：Lua 是一种动态类型语言（运行时进行变量类型检查和解析），变量不需要显式声明类型。它还具有自动内存管理，通过垃圾回收机制来管理内存，简化了开发者的工作。
4. 强大的数据描述能力：Lua 支持多种基本数据类型，包括数字、字符串、布尔值、表（类似于字典或关联数组）、函数等。表是 Lua 中最重要的数据结构之一，可以灵活地表示复杂的数据集合。
5. 灵活的扩展能力：Lua 提供了丰富的扩展接口，可以通过 C/C++ 编写扩展模块，并与 Lua 脚本进行交互。这种可扩展性使得 Lua 可以与其他语言轻松集成，满足不同应用场景的需求。
6. 高性能：Lua 的解释器经过优化，执行速度较快，适合用于处理大规模的数据和复杂的逻辑。
7. 动态代码执行：Lua 支持动态代码执行，可以通过 load 和 loadfile 函数动态加载并执行 Lua 脚本，灵活性很高。
8. 适用于嵌入式系统：由于 Lua 的轻量级和可嵌入性，它在嵌入式系统中得到广泛应用，可以用于控制设备、配置参数等任务。

Ps:

1、什么是脚本语言？

脚本语言是一种用于编写脚本的编程语言。

脚本是一系列按照特定顺序执行的命令或指令，通常用于自动化任务、配置文件、批处理处理、快速原型开发等场景。脚本语言通常被设计为易于编写和理解，其语法和结构往往更加简单直观。

脚本语言与编译型语言的主要区别在于，脚本语言不需要经过编译成机器代码的过程，而是由解释器逐行解释执行。这使得脚本语言的开发和调试更加快速和灵活，因为开发者可以立即看到代码的效果，而不需要额外的编译步骤。

脚本语言通常用于各种不同的领域，包括：

1. 自动化任务：例如批处理处理、系统管理任务、自动化测试等。
2. Web 开发：许多 Web 应用程序的后端和前端都使用脚本语言编写，如 Python、JavaScript、PHP 等。
3. 游戏开发：脚本语言在游戏开发中也得到广泛应用，用于编写游戏逻辑、AI、用户界面等。
4. 配置文件：许多软件和系统使用脚本语言编写配置文件，以便用户可以轻松地配置和定制软件的行为。

总的来说，脚本语言是一种简单、灵活且功能强大的编程语言，适用于各种不同的应用场景，能够大大提高开发效率和灵活性。

2、什么是解释性语言，什么是编译性语言？

解释性语言和编译性语言是两种不同类型的编程语言

解释性语言：

• 解释性语言的代码由解释器逐行执行，并在运行时进行解释和执行。
• 在执行程序时，解释器会逐行读取源代码，并将其转换为计算机可理解的指令，然后立即执行。
• 由于解释器直接执行源代码，因此解释性语言的开发和调试更加灵活，可以动态地修改和查看代码的效果。
• 常见的解释性语言包括 Lua、Python、Ruby、JavaScript、PHP 等。

编译性语言：

• 编译性语言的代码需要先经过编译器将源代码转换为机器代码（或者中间代码），然后再由计算机执行。
• 编译器在编译阶段将源代码转换为目标代码，这个目标代码是针对特定硬件平台的可执行文件或者中间代码。
• 一旦编译完成，生成的可执行文件可以在没有编译器的情况下独立运行，而不需要再次编译源代码。
• 编译性语言的执行速度通常比解释性语言更快，因为代码已经被预先转换为机器代码。
• 常见的编译性语言包括 C、C++、Java等。

2. 解释器的安装

2.1 下载压缩包

https://www.lua.org/download.html
1

lua-5.4.6.tar.gz
1

2.2 解压

tar -xzf lua-5.4.6.tar.gz
1

lua-5.4.6
1

2.3 安装

cd lua-5.4.6  //进入目录
make //编译
sudo make install //安装
1
2
3

2.4 确认安装结果

lua -v
1

Lua 5.4.6
1

ps. lua 在线模拟器

https://wiki.luatos.com/
1

3.基本语法

3.1 第一个Lua 程序

3.1.1 交互式编程

Lua 提供了交互式编程模式。我们可以在命令行中输入程序并立即查看效果。

Lua 交互式编程模式可以通过命令 lua -i 或 lua 来启用：

$ lua
$ Lua 5.4.6  Copyright (C) 1994-2023 Lua.org, PUC-Rio
> 
1
2
3

在命令行中，输入以下命令:

> print("Hello World！")
1

接着我们按下回车键，输出结果如下：

> print("Hello World！")
Hello World！
>
1
2
3

3.1.2 脚本式编程

我们可以将 Lua 程序代码保存到一个以 lua 结尾的文件，并执行，该模式称为脚本式编程，如我们将如下代码存储在名为 hello.lua 的脚本文件中：

vim hello.lua
1

print("Hello world!")
1

终端运行

$ lua hello.lua
1

hello world!
1

3.2 注释

3.2.1 单行注释

两个减号是单行注释:

--
1

3.2.2 多行注释

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

3.3 标识符

在 Lua 中，标识符是用于命名变量、函数、以及其他用户定义的东西的名称。Lua 中的标识符遵循以下规则：

1. 标识符可以由字母、数字和下划线 _ 组成。
2. 标识符必须以字母（包括大小写）或下划线 _ 开始，不能以数字开头。
3. Lua 是大小写敏感的，因此 myVariable 和 MyVariable 是两个不同的标识符。
4. Lua 的关键字（例如 if、then、else、while、function 等）不能用作标识符。
5. Lua 中允许使用 UTF-8 编码的字母作为标识符，因此也可以使用非拉丁字母作为标识符。

例如，以下是一些合法的 Lua 标识符：

• myVar
• _count
• table1
• 变量名

而以下是一些不合法的 Lua 标识符：

• 3abc（以数字开头）
• if（关键字）
• my-variable（包含连字符 -）
• #table（包含特殊字符 #）

注意：

最好不要使用下划线加大写字母的标示符，因为Lua的保留字也是这样的

3.4 关键字

4.数据类型

Lua 是动态类型语言，变量不要类型定义,只需要为变量赋值。 值可以存储在变量中，作为参数传递或结果返回。

Lua 中有 8 个基本类型分别为：nil、boolean、number、string、userdata、function、thread 和 table。

5.变量

5.1 动态类

Lua 是一种动态类型语言，变量的类型是根据赋给它们的值自动确定的。

a = 1;
1

5.2 全局变量

在默认情况下，变量总是认为是全局的。

全局变量不需要声明，给一个变量赋值后即创建了这个全局变量，访问一个没有初始化的全局变量也不会出错，只不过得到的结果是：nil。

> print(b)
nil
> b=10
> print(b)
10
1
2
3
4
5

如果你想删除一个全局变量，只需要将变量赋值为nil。

b = nil
print(b)      --> nil
1
2

这样变量b就好像从没被使用过一样。换句话说, 当且仅当一个变量不等于nil时，这个变量即存在。

5.3 局部变量

如果想使用局部变量，在变量前加 local 关键字

局部变量的作用域通常是从声明处到当前语句块结束。

local c = 10 -- 这是一个局部变量
1

5.4 多重赋值

a,b =  1,2
print(a,b)
1
2

1  2
1

a,b,c =  1,2
print(a,b)
1
2

1  2  nil
1

5.5 数值型变量

-- 整型
a = 1

-- 浮点型
b = 2.1

-- 科学计数法
c = 1e3

-- 十六进制
d = 0x11

print(a,b,c,d)
1
2
3
4
5
6
7
8
9
10
11
12
13

1	2.1	1000.0	17
1

-- 获取字符 'A' 的 ASCII 码值
asciiValue = string.byte('A')

-- 输出 ASCII 码值
print(asciiValue)  -- 输出 65
1
2
3
4
5

5.6 字符串型变量

字符串由一对双引号或单引号来表示

a = "hello"
b = 'world'

print(a,b) -- hello	world
1
2
3
4

支持在字符串中插入转义字符

c = "hello\nworld"
print(c) -- hello
			world
1
2
3

长字符串

d = [[hello
world
!]]

print(d)
1
2
3
4
5

获取字符串长度(#)

a = "hello world"
print(#a)  --11
1
2

字符串合并(…)

a = "hello"
b = "world"
c = a..b
print(c) -- helloworld
1
2
3
4

数值字符可以和数值直接进行运算

a = "10" + 1
print(a) -- 11.0
1
2

tostring() 和 tonumber()

a = tostring(10)
print(type(a))  --string

b = tonumber("10")
print(type(b))  --number

-- 转换失败 nil
c = tonumber("abc")
print(type(c)) --nil
1
2
3
4
5
6
7
8
9

6.运算符

Lua 和 C 中的对比：

赋值运算符:

• Lua: = (单等号)
• C: =

算术运算符:

• Lua: +, -, *, /, %
• C: +, -, *, /, %

关系运算符:

• Lua: ==, ~=, <, <=, >, >=
• C: ==, !=, <, <=, >, >=

逻辑运算符:

• Lua: and, or, not
• C: &&, ||, !

位运算符:

• Lua: &, |, ~, <<, >>
• C: &, |, ~, <<, >>

连接运算符:

• Lua: ..（用于连接字符串）
• C: +（用于连接字符串）

其他运算符:

• Lua: #（取长度）、:（用于对象方法调用）
• C: sizeof（取大小）

7. 控制流语句

7.1 选择语句

7.1.1 if then else

if condition then
    -- 当 condition 为 true 时执行这里的代码
else
    -- 当 condition 为 false 时执行这里的代码
end
1
2
3
4
5

-- 定义一个变量
local temperature = 25

-- 判断温度是否超过 20 度
if temperature > 20 then
    print("天气很热，建议穿短袖")
else
    print("天气不算太热，可以穿长袖")
end
1
2
3
4
5
6
7
8
9

7.1.2 if then elseif then end

if condition1 then
    -- 当 condition1 为 true 时执行这里的代码
elseif condition2 then
    -- 当 condition1 不满足，而 condition2 为 true 时执行这里的代码
else
    -- 当上述条件都不满足时执行这里的代码
end
1
2
3
4
5
6
7

-- 定义一个变量
local hour = 15

-- 判断当前时间段
if hour < 12 then
    print("现在是上午")
elseif hour >= 12 and hour < 18 then
    print("现在是下午")
else
    print("现在是晚上")
end
1
2
3
4
5
6
7
8
9
10
11

7.1.3 三目运算符

local result = condition and value1 or value2

--如果 condition 为 true，则返回 value1，否则返回 value2
1
2
3

-- 定义一个变量
local score = 85

-- 使用三元运算符判断成绩是否及格
local result = score >= 60 and "及格" or "不及格"

-- 输出结果
print("成绩：" .. score .. "，考试结果：" .. result)
1
2
3
4
5
6
7
8

ps： 无 switch/case

注意：Lua 中没有直接的 switch/case 语句。但你可以使用多个 if-elseif-else 结构来模拟类似的行为：

local choice = 2
if choice == 1 then
    -- 处理选择 1 的情况
elseif choice == 2 then
    -- 处理选择 2 的情况
elseif choice == 3 then
    -- 处理选择 3 的情况
else
    -- 处理其他情况
end
1
2
3
4
5
6
7
8
9
10

7.2 循环语句

7.2.1.for 循环

7.2.1.1 数值型for 循环

for var = startValue, endValue, stepValue do
    -- 循环体
end
1
2
3

• var 是循环变量，它从 startValue 开始递增，直到达到或超过 endValue，每次递增 stepValue。
• startValue、endValue 和 stepValue 是可选的，默认值分别为 1、endValue、1。
• 循环体会在每次迭代时执行，循环结束后，循环变量 var 的值会保留在循环作用域中(追踪循环结束时的变量值、利用循环变量的最终值进行后续操作、利用循环变量的最终值进行条件判断)。

for i = 1, 5 do
    print("数值型 for 循环，第 " .. i .. " 次迭代")
end
1
2
3

7.2.1.2 泛型 for 循环

for index, value in ipairs(iterable) do
    -- 循环体
end
1
2
3

• iterable 是一个可迭代的对象，例如数组或表。
• 在每次迭代时，index 和 value 分别表示当前元素的索引和值。
• ipairs() 函数用于迭代数组类型的表，它返回三个值：迭代函数、表、初始值。

local fruits = {"apple", "banana", "orange"}
for index, fruit in ipairs(fruits) do
    print("泛型 for 循环，第 " .. index .. " 个水果是 " .. fruit)
end
1
2
3
4

7.2.2 while 循环

while condition do
    -- 循环体
end
1
2
3

while 循环会在 condition 为 true 时执行循环体，直到 condition 为 false 才停止循环。

local j = 1
while j <= 5 do
    print("while 循环，第 " .. j .. " 次迭代")
    j = j + 1
end
1
2
3
4
5

7.2.3 repeat until 循环

repeat
    -- 循环体
until condition
1
2
3

repeat until 循环会先执行一次循环体，然后检查 condition，如果 condition 为 true，则继续执行循环体，直到 condition 为 false 才停止循环。

local k = 1
repeat
    print("repeat until 循环，第 " .. k .. " 次迭代")
    k = k + 1               -- lua 没有 k++ 也可以 k += 1 
until k > 5
1
2
3
4
5

8.函数

8.1 函数定义

optional_function_scope function function_name( argument1, argument2, argument3..., argumentn)
    function_body
    return result_params_comma_separated
end
1
2
3
4

• optional_function_scope: 该参数是可选的指定函数是全局函数还是局部函数，未设置该参数默认为全局函数，如果你需要设置函数为局部函数需要使用关键字 local。
• function_name: 指定函数名称。
• argument1, argument2, argument3…, argumentn: 函数参数，多个参数以逗号隔开，函数也可以不带参数。
• function_body: 函数体，函数中需要执行的代码语句块。
• result_params_comma_separated: 函数返回值，Lua语言函数可以返回多个值，每个值以逗号隔开。

--函数返回两个值的最大值 
function max(num1, num2)

   if (num1 > num2) then
      result = num1;
   else
      result = num2;
   end

   return result;
end
1
2
3
4
5
6
7
8
9
10
11

8.2 函数调用

函数调用可以通过函数名加上一对圆括号来完成，可以传入函数定义中所需的参数。

-- 调用函数
print("两值比较最大值为 ",max(10,4))
print("两值比较最大值为 ",max(5,6))
1
2
3

8.3 多返回值

在 Lua 中，函数可以返回多个值。调用函数时，可以使用逗号分隔多个返回值。

function f()
    return 1, 2, 3
end

local a, b, c = f()
print(a, b, c) -- 输出: 1 2 3
1
2
3
4
5
6

8.4 匿名函数

匿名函数在 Lua 中是一种特殊的函数，它们不需要显式地命名，通常用于一次性的、简单的操作或作为其他函数的参数。

local double = function(x)
    return x * 2
end

print(double(5)) -- 输出: 10
1
2
3
4
5

8.5 函数作为参数和返回值

在 Lua 中，函数可以作为参数传递给其他函数，也可以作为其他函数的返回值。

function applyFunction(func, value)
    return func(value)
end

print(applyFunction(double, 5)) -- 输出: 10
1
2
3
4
5

8.6 变长参数

在 Lua 中，函数可以接受变长参数，可以通过 ... 表示。可以使用 select() 函数获取变长参数的值

function sum(...)
    local result = 0
    for i = 1, select("#", ...) do
        result = result + select(i, ...)
    end
    return result
end

print(sum(1, 2, 3, 4, 5)) -- 输出: 15
1
2
3
4
5
6
7
8
9

ps : select

在 Lua 中，select 是一个用于操作可变数量参数的函数。它可以用于获取可变参数的数量和值。

select 函数的一般形式为：

select(index, ...)
1

其中：

• index 是一个索引值，用于选择可变参数列表中的参数。
• ... 是可变参数列表。

select 函数有两种主要用法：

1. 获取可变参数的数量

   当 index 的值为 "#" 时，select 函数返回可变参数的数量。

   示例：

   luaCopy codelocal count = select("#", 1, 2, 3, 4, 5)
   print(count)  -- 输出: 5
   1
   2

2. 获取可变参数的值：

   当 index 的值为一个整数时，select 函数返回可变参数列表中对应索引位置的参数值。

   示例：

   luaCopy codelocal value = select(3, "a", "b", "c", "d")
   print(value)  -- 输出: c
   1
   2

   在这个示例中，select(3, "a", "b", "c", "d") 返回可变参数列表中第 3 个参数的值，即 "c"。

需要注意的是，select 函数只能用于处理从 1 开始的索引位置，而不支持负数索引。如果 index 大于可变参数的数量，select 函数返回 nil。

8.数组

数组，就是相同数据类型的元素按一定顺序排列的集合，可以是一维数组和多维数组。在 Lua 中，数组不是一种特定的数据类型，而是一种用来存储一组值的数据结构。实际上，Lua 中并没有专门的数组类型，而是使用一种被称为 “table” 的数据结构来实现数组的功能。Lua 数组的索引键值可以使用整数表示，数组的大小不是固定的。在 Lua 索引值是以 1 为起始。

-- 创建一个数组
local myArray = {10, 20, 30, 40, 50}

-- 访问数组元素
print(myArray[1])  -- 输出 10
print(myArray[3])  -- 输出 30
print(myArray[-1])  -- 输出 50
1
2
3
4
5
6
7

要计算数组的长度（即数组中元素的个数），你可以使用 # 操作符：

local myArray = {10, 20, 30, 40, 50}

-- 计算数组长度
local length = #myArray

print(length) -- 输出 5
1
2
3
4
5
6

一维数组可以用 for 循环出数组中的元素

-- 创建一个数组
local myArray = {10, 20, 30, 40, 50}

-- 循环遍历数组
for i = 1, #myArray do
    print(myArray[i])
end
1
2
3
4
5
6
7

9.table(表)

在 Lua 中，table 是一种用来保存多个值的数据结构，它类似于其他编程语言中的数组、列表、字典或哈希表。table 是 Lua 中最重要的数据结构之一，也是 Lua 的核心之一。

9.1 数字下标

数字下标的表是 Lua 中常见的数据结构，通常用来表示数组或列表。在这样的表中，键是从 1 开始的整数索引，对应的值可以是任意类型的 Lua 值。

9.1.1 元素组成

在 Lua 的数字下标表中，每个元素可以是任何 Lua 支持的数据类型，包括但不限于：

数字（number）：整数或浮点数。

字符串（string）：任意长度的文本字符串。

布尔值（boolean）：true 或 false。

表（table）：嵌套的表，用来表示更复杂的数据结构。

函数（function）：可执行的代码块。

线程（thread）：Lua 的协程，用于实现轻量级并发。
用户数据（userdata）：C 语言中的数据类型，通常由 Lua 扩展库创建。
这意味着你可以将任何 Lua 支持的数据类型存储在数字下标表中的元素中。例如，你可以创建一个包含字符串、数字和表的数组，或者将函数作为数组的元素，以及其他更复杂的数据组合。

local myArray = {10, "hello", true, {20, 30}, function() print("This is a function") end}
1

9.1.2 元素访问

在 Lua 中，数组的索引从 1 开始，所以第一个元素的索引是 1，第二个元素的索引是 2，以此类推。

print(myArray[1])  -- 输出: 10
print(myArray[2])  -- 输出: hello
print(myArray[3])  -- 输出: true
print(myArray[4][1])  -- 输出: 20
myArray[5]()  -- 输出: This is a function
1
2
3
4
5

如果在数字下标表中某个索引位置没有存储任何值，Lua 会返回 nil。

print(myArray[5])  --输出: nil 
1

9.1.3 添加元素

以下是几种常见的往数字下标表中添加元素的方法：

①直接赋值

可以直接通过索引赋值的方式往表中添加元素。

luaCopy codelocal myArray = {10, 20, 30}

-- 直接赋值给新的索引位置
myArray[4] = 40
1
2
3
4

②使用 table.insert() 函数

可以使用 table.insert() 函数往数组末尾添加新元素。

luaCopy codelocal myArray = {10, 20, 30}

-- 使用 table.insert() 函数往数组末尾添加新元素
table.insert(myArray, 40)
1
2
3
4

ps：table.insert()

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

在table的数组部分指定位置(pos)插入值为value的一个元素. pos参数可选, 默认为数组部分末尾.

luaCopy codelocal myArray = {10, 20, 30}

-- 使用 table.insert() 函数往数组第二个位置添加新元素
table.insert(myArray,2, 40)

--myArray = {10, 40,20, 30}
1
2
3
4
5
6

③使用 # 操作符

可以使用 # 操作符来获取数组长度，然后在长度加一的位置赋值。

luaCopy codelocal myArray = {10, 20, 30}

-- 在数组长度加一的位置赋值
myArray[#myArray + 1] = 40
1
2
3
4

9.1.4 删除元素

①使用 table.remove() 函数

table.remove() 函数用于删除数组中的元素。它接受两个参数：数组和要删除的元素的索引。删除元素后，后续的元素会向前移动填补空缺。如果不指定索引，则默认删除数组的最后一个元素。

luaCopy codelocal myArray = {10, 20, 30, 40}
table.remove(myArray)  -- 删除最后一个元素
1
2

luaCopy codelocal myArray = {10, 20, 30, 40}
table.remove(myArray, 2)  -- 删除索引为 2 的元素
1
2

第二个元素 20 将被删除，数组变成 {10, 30, 40}。

ps：table.remove() 返回值

table.remove() 函数在删除元素后会返回被删除的元素的值。如果指定了要删除的元素的索引，则返回该索引位置上的元素值；如果没有指定索引，则默认删除数组的最后一个元素，并返回该元素的值。

local myArray = {10, 20, 30, 40}
local removedValue = table.remove(myArray, 2)  -- 删除索引为 2 的元素
print(removedValue)  -- 输出: 20
1
2
3

local myArray = {10, 20, 30, 40}
local removedValue = table.remove(myArray)  -- 删除数组的最后一个元素
print(removedValue)  -- 输出: 40
1
2
3

②将要删除的元素赋值为 nil

直接将要删除的元素的位置赋值为 nil，这会将该位置上的元素删除，但不会改变数组的长度或索引。

luaCopy codelocal myArray = {10, 20, 30, 40}
myArray[2] = nil  -- 删除索引为 2 的元素
1
2

在这个示例中，第二个元素 20 将被删除，数组变成 {10, nil, 30, 40}。
注意：虽然元素被删除了，但数组长度仍然保持不变。

9.2 键值对

local myTable = {key1 = "value1", key2 = "value2"}
1

9.2.1 键值组成

在 Lua 中，表的键（key）和值（value）可以是任何类型的 Lua 值，包括但不限于：

1. 字符串（string）：可以作为键和值的类型，字符串是 Lua 中最常见的数据类型之一。
2. 数字（number）：同样可以作为键和值的类型，包括整数和浮点数。
3. 布尔值（boolean）：可以作为键和值的类型，表示逻辑上的真（true）和假（false）。
4. 表（table）：可以作为值的类型，允许嵌套表以构建复杂的数据结构。
5. 函数（function）：可以作为值的类型，表示可执行的代码块。
6. 用户数据（userdata）：一种特殊的数据类型，通常由 Lua 扩展库创建。
7. 线程（thread）：用于实现轻量级并发的数据类型，通常用于协程。
8. nil：表示空值或无效值的特殊类型，可以作为键和值的类型。

local myTable = {
    ["name"] = "John",               -- 字符串作为键
    [42] = "answer",                 -- 数字作为键
    [true] = "yes",                  -- 布尔值作为键
    [{}] = "empty table",            -- 表作为键
    [function() return "key" end] = "computed key",  -- 函数作为键
    ["array"] = {1, 2, 3},           -- 数组作为值
    ["nestedTable"] = {              -- 嵌套表作为值
        ["key1"] = "value1",
        ["key2"] = "value2"
    },
    ["nilValue"] = nil               -- nil 作为值
}
1
2
3
4
5
6
7
8
9
10
11
12
13

Lua 中键和值可以不带方括号。当键是字符串或者符合 Lua 变量命名规则的标识符时，可以直接使用键名来定义键值对，而无需使用方括号

local myTable = {
    name = "John",               -- 字符串作为键
    age = 30,                    -- 字符串作为键
    isAdult = true,              -- 字符串作为键
    hobbies = {"reading", "swimming"}, -- 字符串作为键, 表作为值
    greet = function() print("Hello, Lua!") end,  -- 字符串作为键, 函数作为值
}
1
2
3
4
5
6
7

9.2.2 值访问

要访问 Lua 表中的值，可以使用下标（键）来获取对应的值。在 Lua 中，可以使用表的键来访问表中的值，这可以通过使用方括号加上键名或者直接使用键名来完成。

local myTable = {
    name = "John",
    age = 30,
    isAdult = true,
    hobbies = {"reading", "swimming"},
    greet = function() print("Hello, Lua!") end,
}

-- 使用方括号加上键名来访问表中的值
print(myTable["name"])  -- 输出: John
print(myTable["age"])   -- 输出: 30

-- 直接使用键名来访问表中的值
print(myTable.name)     -- 输出: John
print(myTable.age)      -- 输出: 30
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

9.2.3 添加元素

直接赋值

直接通过赋值操作来向表中添加新元素，如果键不存在，则会创建新的键值对

local myTable = {}  -- 创建一个空表

-- 直接赋值给新的键
myTable["name"] = "John"
myTable["age"] = 30
1
2
3
4
5

9.2.4 删除元素

将要删除的元素赋值为 nil

local myTable = {name = "John", age = 30, city = "New York"}

-- 删除键为 "age" 的整个键值对
myTable["age"] = nil
1
2
3
4

9.2.5 遍历元素

pairs() 遍历表中所有的键值对

pairs()的使用格式:

for key, value in pairs(table) do
    -- 在这里处理 key 和 value
end
1
2
3

其中，table 是要迭代的表，key 和 value 分别是每次迭代中表中的键和对应的值。

local myTable = {name = "John", age = 30, city = "New York"}

for key, value in pairs(myTable) do
    print(key, value)
end
1
2
3
4
5