Lua 脚本基础详解：从入门到实践

Lua 是一种轻量级、可扩展的脚本语言，以其简洁、高效、易于嵌入而闻名。它被广泛应用于游戏开发（如《魔兽世界》、《Roblox》）、嵌入式系统、Web 服务器（如 Nginx、OpenResty）、图像处理（如 Adobe Lightroom）等众多领域。本教程旨在为初学者提供一个全面而详细的 Lua 基础知识指南，帮助你快速掌握这门强大的脚本语言。

1. Lua 简介

1.1 什么是 Lua？

Lua（在葡萄牙语中意为“月亮”）由巴西里约热内卢天主教大学的三位研究人员于 1993 年开发。它的设计目标是成为一种易于嵌入其他应用程序的扩展语言，同时保持小巧和快速。

1.2 Lua 的特点

轻量级: Lua 的核心解释器非常小巧（编译后通常只有几百 KB），对资源要求低，非常适合内存或处理能力受限的环境。
可嵌入性: Lua 从设计之初就考虑到了嵌入性。它提供了一个简单而强大的 C API，使得 C/C++ 程序可以轻松地调用 Lua 函数，反之亦然。这使得宿主程序能够利用 Lua 来实现配置、自动化和用户脚本等功能。
简洁高效: Lua 的语法简单一致，学习曲线平缓。其虚拟机（VM）经过高度优化，执行速度在脚本语言中名列前茅。
可移植性: Lua 使用 ANSI C 编写，几乎可以在所有支持标准 C 编译器的平台上编译和运行。
动态类型: 变量类型在运行时确定，无需显式声明类型。
垃圾回收: Lua 提供了自动内存管理，通过增量式垃圾回收器自动回收不再使用的内存，减轻了开发者的负担。
强大的数据描述能力: Lua 的核心数据结构 table 极其灵活，可以用来表示数组、哈希表（字典）、集合、对象等。

1.3 为何学习 Lua？

广泛的应用: 掌握 Lua 能让你在游戏开发、服务器配置、自动化脚本等多个热门领域获得优势。
易于上手: 相比 C++, Java 等语言，Lua 语法更简单，更容易快速入门并看到成果。
提升开发效率: 在大型项目中，使用 Lua 编写逻辑或配置可以加快开发和迭代速度。
理解脚本语言核心: Lua 的设计哲学（如 table 的核心地位、元表机制）有助于深入理解脚本语言的工作原理。

2. 环境搭建与第一个程序

2.1 安装 Lua

你可以从 Lua 官方网站（https://www.lua.org/）下载源代码自行编译，或者通常可以通过操作系统的包管理器直接安装。

Windows: 可以下载预编译的二进制文件（如 LuaDist, LuaRocks），或者使用像 Scoop、Chocolatey 这样的包管理器。
macOS: 使用 Homebrew：brew install lua
Linux (Debian/Ubuntu): sudo apt update && sudo apt install lua5.3 (或适合你发行版的版本号)
Linux (Fedora): sudo dnf install lua

安装完成后，在终端或命令行输入 lua -v，如果看到版本号信息，则表示安装成功。

2.2 运行 Lua 代码

有两种主要方式运行 Lua 代码：

交互式解释器: 直接在终端输入 lua 启动解释器。你可以逐行输入 Lua 代码并立即看到结果。这是测试小段代码和学习语法的便捷方式。输入 os.exit() 或按 Ctrl+D (Unix-like) / Ctrl+Z Enter (Windows) 退出。

“`lua

print(“Hello from Lua interpreter!”)
Hello from Lua interpreter!
x = 10 + 5
print(x)
15
“`
运行脚本文件: 将 Lua 代码保存到一个以 .lua 为后缀的文件（例如 hello.lua），然后在终端中使用 lua 命令执行它：

hello.lua
“`lua
— 这是我的第一个 Lua 脚本
print(“Hello, World from file!”)

local message = “Lua is awesome!”
print(message)
“`

在终端运行：
bash lua hello.lua
输出：
Hello, World from file! Lua is awesome!

3. Lua 基础语法

3.1 注释

单行注释：使用两个连字符 -- 开始，直到行尾。
多行注释：使用 --[[ 开始，直到 ]] 结束。可以通过在开头的 [ 后加等号来处理嵌套注释，例如 --[=[ ... content ... ]=]。

“`lua
— 这是一个单行注释

–[[
这是一个
多行
注释块。
]]

–[==[
这个多行注释可以包含 –[[ 嵌套块 ]] 而不会提前结束。
]==]
“`

3.2 标识符与关键字

标识符: 用于命名变量、函数等。由字母、数字和下划线组成，但不能以数字开头。Lua 区分大小写（myVar 和 myvar 是不同的）。
关键字: Lua 有一些保留的关键字，不能用作标识符。常见的有：
and, break, do, else, elseif, end, false, for, function, if, in, local, nil, not, or, repeat, return, then, true, until, while

3.3 全局变量与局部变量

全局变量: 默认情况下，在 Lua 中创建的变量是全局变量，除非显式声明为局部变量。全局变量存储在一个名为 _G 的特殊表中。过度使用全局变量通常被认为是不好的实践，因为它可能导致命名冲突和难以追踪的副作用。

lua myGlobalVar = "I am global" -- 全局变量 print(_G.myGlobalVar) -- 可以通过 _G 访问
局部变量: 使用 local 关键字声明的变量是局部变量。其作用域限制在声明它的代码块（如函数、循环、if 语句或 do...end 块）内。强烈推荐优先使用局部变量，因为它们访问速度更快，并且有助于避免命名冲突，使代码更清晰。

“`lua
local myLocalVar = “I am local” — 局部变量

do
local innerVar = “Inside do block”
print(innerVar)
end
— print(innerVar) — 这里会出错，innerVar 在作用域外不可见

function myFunction()
local funcVar = “Inside function”
print(funcVar)
print(myLocalVar) — 可以访问外部的局部变量（闭包特性）
end

myFunction()
— print(funcVar) — 这里会出错
“`

4. 数据类型

Lua 是一种动态类型语言，变量不需要预先声明类型，类型是值的属性。Lua 有八种基本类型：

nil (空): 表示无效值或不存在的值。未赋值的变量默认为 nil。nil 本身也是一种类型，只有一个值 nil。它在逻辑运算中被视为 false。

lua local a print(type(a)) --> nil a = 10 print(type(a)) --> number a = nil -- 将变量重新设为 nil print(type(a)) --> nil
boolean (布尔): 只有两个值：true 和 false。注意，在 Lua 中，只有 false 和 nil 被认为是假 (falsy)；所有其他值（包括 0 和空字符串 ""）都被认为是真 (truthy)。

lua local isReady = true local hasFailed = false if isReady then print("Ready!") end if 0 then print("Zero is true in Lua") end if "" then print("Empty string is true in Lua") end if not hasFailed and not nil then print("Neither failed nor nil") end
number (数字): 默认情况下表示双精度浮点数。从 Lua 5.3 开始，也引入了整数（integer）子类型。大多数情况下，你不需要区分它们，Lua 会在需要时自动转换。

lua local pi = 3.14159 local count = 100 local temperature = -5.5 print(type(pi)) --> number print(type(count)) --> number (可能是 integer 子类型)
string (字符串): 表示字符序列。可以使用单引号 ' ' 或双引号 " " 定义。两者没有区别。也支持使用 [[ ... ]] 定义多行字符串，这种字符串不会转义任何字符。

``lua local name = "Alice" local greeting = 'Hello, ' .. name .. '!' --..` 是字符串连接符
print(greeting) –> Hello, Alice!

local longText = [[
这是一个
可以跨越
多行的字符串。
\n 和 ‘ ” 都可以直接写，不会被转义。
]]
print(longText)
“`
table (表): Lua 中最重要和最灵活的数据结构。table 是一种关联数组，可以用任何非 nil 的值作为键，值也可以是任何类型。它可以用来模拟数组、字典（哈希映射）、集合、记录、对象等。

“`lua
— 作为数组（索引从 1 开始）
local colors = {“red”, “green”, “blue”}
print(colors[1]) –> red
print(#colors) –> 3 (获取数组部分的长度)

— 作为字典（哈希映射）
local person = {name = “Bob”, age = 30, isStudent = false}
print(person[“name”]) –> Bob
print(person.age) –> 30 (语法糖，等价于 person[“age”])

— 混合使用
local mixedTable = {10, 20, key = “value”, [5] = “index five”}
print(mixedTable[1]) –> 10
print(mixedTable.key) –> value
print(mixedTable[5]) –> index five
“`
注意: Lua 的数组索引默认从 1 开始，而不是像许多其他语言那样从 0 开始。
function (函数): 在 Lua 中，函数是一等公民（first-class value），意味着它们可以像其他值一样被存储在变量中、作为参数传递、作为返回值返回。

“`lua
local function greet(name)
print(“Hello, ” .. name)
end
greet(“Charlie”) –> Hello, Charlie

local say = greet — 函数可以赋值给变量
say(“David”) –> Hello, David
“`
userdata (用户数据): 用于存储任意 C/C++ 数据。它允许 C 代码将自己的数据结构暴露给 Lua 使用，是 Lua 与 C 交互的关键。通常在 C API 中创建和操作。
thread (线程): 表示一个独立的执行线程，主要用于实现协程（coroutine）。协程允许多个任务协作式地运行，而不是抢占式地并发。

type() 函数可以用来获取一个值的类型名称（字符串形式）。

lua print(type(nil)) --> nil print(type(true)) --> boolean print(type(10.5)) --> number print(type("hello")) --> string print(type({})) --> table print(type(print)) --> function print(type(coroutine.create(function() end))) --> thread -- userdata 通常由 C 代码创建

5. 运算符

5.1 算术运算符

+ (加法)
- (减法)
* (乘法)
/ (浮点除法)
// (整除，Lua 5.3+)
% (取模)
^ (乘方)
- (一元负号)

lua local a = 10 local b = 4 print(a + b) --> 14 print(a - b) --> 6 print(a * b) --> 40 print(a / b) --> 2.5 print(a // b) --> 2 (Lua 5.3+) print(a % b) --> 2 print(2 ^ 3) --> 8.0 print(-a) --> -10

5.2 关系运算符

比较结果为 boolean (true 或 false)。

== (等于)
~= (不等于)
< (小于)
> (大于)
<= (小于等于)
>= (大于等于)

注意: 对于 table, function, userdata, thread 类型，== 比较的是引用（内存地址），只有当两个变量指向同一个对象时才为 true。

“`lua
print(5 == 5.0) –> true (数字比较值)
print(“a” == “a”) –> true
print(“a” ~= “b”) –> true
print(nil == nil) –> true
print(10 > 5) –> true

local t1 = {}
local t2 = {}
local t3 = t1
print(t1 == t2) –> false (不同的 table 对象)
print(t1 == t3) –> true (指向同一个 table 对象)
“`

5.3 逻辑运算符

and: 如果第一个操作数为 false 或 nil，则返回第一个操作数；否则返回第二个操作数。
or: 如果第一个操作数不是 false 且不是 nil，则返回第一个操作数；否则返回第二个操作数。
not: 返回 boolean 值。如果操作数为 false 或 nil，返回 true；否则返回 false。

and 和 or 具有“短路”特性：如果第一个操作数足以确定结果，就不会计算第二个操作数。这常用于设置默认值：

lua local name = inputName or "Default Name" -- 如果 inputName 为 nil 或 false，则 name 为 "Default Name"

“`lua
print(true and “hello”) –> hello
print(nil and “hello”) –> nil
print(false and “hello”)–> false

print(true or “hello”) –> true
print(nil or “hello”) –> hello
print(false or “hello”) –> hello

print(not true) –> false
print(not nil) –> true
print(not 0) –> false (因为 0 是 truthy)
print(not “”) –> false (因为 “” 是 truthy)
“`

5.4 连接运算符

.. (字符串连接)

lua local s1 = "Hello" local s2 = " Lua" print(s1 .. s2) --> Hello Lua print("Result: " .. 10) --> Result: 10 (数字会自动转为字符串)

5.5 长度运算符

# (一元运算符): 获取字符串的长度或 table 的“数组部分”的长度。对于 table，它返回一个整数键 n，使得 t[n] 不是 nil 且 t[n+1] 是 nil。如果 table 没有正整数键，结果可能是 0。对于中间有 nil (洞) 的数组，其行为可能不符合直觉。

“`lua
print(#”Hello”) –> 5
local arr = {10, 20, 30, 40}
print(#arr) –> 4
local map = {a=1, b=2}
print(#map) –> 0 (通常对于纯哈希表返回 0)
local mixed = {1, 2, nil, 4}
print(#mixed) –> 2 (行为可能不确定，取决于 nil 的位置)
local sparse = {[1]=1, [100]=2}
print(#sparse) –> 1 or 0 or 100 (行为不确定)

— 获取 table 总元素数（包括非数字键）通常需要迭代
local count = 0
for k, v in pairs(map) do count = count + 1 end
print(count) –> 2
“`

6. 控制结构

6.1 条件语句 `if then else`

“`lua
local score = 75

if score >= 90 then
print(“Grade: A”)
elseif score >= 80 then
print(“Grade: B”)
elseif score >= 70 then
print(“Grade: C”)
else
print(“Grade: D”)
end — 不要忘记 end
“`

6.2 `while` 循环

当条件为真时重复执行代码块。

lua local i = 1 while i <= 5 do print("While loop, iteration: " .. i) i = i + 1 end -- 不要忘记 `end`

6.3 `repeat until` 循环

先执行代码块，然后检查条件。如果条件为 false 或 nil，则继续循环；如果为 true，则退出循环。至少执行一次。

lua local count = 0 repeat count = count + 1 print("Repeat loop, count: " .. count) until count >= 3 -- 条件为真时停止

6.4 `for` 循环

Lua 提供两种 for 循环：

数值 for: 迭代一个数字序列。

“`lua
— 语法: for var = start, end, [step] do … end
— step 默认为 1

— 从 1 到 5
for i = 1, 5 do
print(“Numeric for (1-5), i = ” .. i)
end

— 从 10 到 1，步长为 -2
for j = 10, 1, -2 do
print(“Numeric for (10-1, step -2), j = ” .. j)
end
`` 循环变量i和j` 在循环内部是局部的。
泛型 for: 使用迭代器函数遍历集合（主要是 table）。最常用的是 pairs 和 ipairs。
- pairs(t): 迭代 table t 中的所有键值对，顺序不保证。
lua local person = {name = "Eve", age = 25, city = "Lua Land"} print("\nIterating with pairs:") for key, value in pairs(person) do print(key .. ": " .. tostring(value)) -- 使用 tostring 确保值能打印 end
- ipairs(t): 迭代 table t 的数组部分（整数键 1, 2, 3, …），按顺序进行，直到遇到第一个 nil 值。
lua local fruits = {"apple", "banana", "orange"} print("\nIterating with ipairs:") for index, value in ipairs(fruits) do print(index .. ": " .. value) end

pairs vs ipairs 总结:
* 用 ipairs 遍历数组（需要保证顺序且只关心 1, 2, 3… 索引）。
* 用 pairs 遍历字典或混合表（不关心顺序或需要访问所有键）。

6.5 `break` 和 `return`

break: 立即退出当前所在的循环 (while, repeat, for)。
return: 从函数中返回值。如果在主代码块（非函数内）使用，会终止脚本的执行。

“`lua
for i = 1, 10 do
if i > 5 then
break — 当 i 大于 5 时退出循环
end
print(“i = ” .. i)
end
print(“Loop finished.”)

function findValue(t, valueToFind)
for key, value in pairs(t) do
if value == valueToFind then
return key — 找到值，返回其键并退出函数
end
end
return nil — 循环结束还没找到，返回 nil
end

local myTable = {a=10, b=20, c=30}
local keyFound = findValue(myTable, 20)
if keyFound then
print(“Found value 20 at key: ” .. keyFound) –> Found value 20 at key: b
else
print(“Value not found.”)
end
“`

7. 函数

函数是 Lua 的核心构件之一。

7.1 定义函数

使用 function 关键字。

“`lua
— 方式一：
function add(a, b)
return a + b
end

— 方式二：匿名函数赋值给变量 (等价于方式一)
local subtract = function(a, b)
return a – b
end

print(add(5, 3)) –> 8
print(subtract(10, 4)) –> 6
`` 推荐使用local function … end` 来定义局部函数。

7.2 多返回值

Lua 函数可以返回多个值。

“`lua
function getCoordinates()
local x = 10
local y = 20
local z = 30
return x, y, z — 返回三个值
end

local x1, y1, z1 = getCoordinates() — 接收所有返回值
print(x1, y1, z1) –> 10 20 30

local x2 = getCoordinates() — 只接收第一个返回值
print(x2) –> 10

local x3, y3 = getCoordinates() — 接收前两个
print(x3, y3) –> 10 20

— 在表达式中，通常只有第一个返回值被使用
print(“Coords: ” .. getCoordinates()) –> Coords: 10
“`

7.3 可变参数 (`...`)

函数可以接受可变数量的参数。使用 ... (三个点) 表示。在函数内部，... 可以通过 select('#', ...) 获取参数数量，通过 select(n, ...) 获取第 n 个及之后的参数，或者通过 {...} 将所有可变参数收集到一个 table 中（推荐方式）。

“`lua
function sum(…)
local args = {…} — 将所有参数放入一个 table
local total = 0
for i, v in ipairs(args) do
total = total + v
end
return total
end

print(sum(1, 2, 3)) –> 6
print(sum(10, 20, 30, 40)) –> 100
print(sum()) –> 0
“`

8. Table 深入

table 是 Lua 中唯一的数据结构机制，但极其强大。

8.1 作为数组

“`lua
local myArray = {} — 创建空表
myArray[1] = “Apple”
myArray[2] = “Banana”
myArray[3] = “Cherry”

— 或者直接初始化
local days = {“Monday”, “Tuesday”, “Wednesday”}

print(myArray[1]) –> Apple
print(days[3]) –> Wednesday
print(#days) –> 3

— 遍历数组
for i, day in ipairs(days) do
print(“Day ” .. i .. “: ” .. day)
end

— 添加元素 (table 标准库)
table.insert(days, “Thursday”) — 在末尾添加
print(days[4]) –> Thursday
table.insert(days, 1, “Sunday”) — 在索引 1 处插入
print(days[1]) –> Sunday
print(#days) –> 5

— 删除元素
local removedDay = table.remove(days, 2) — 删除索引 2 的元素 (Monday)
print(“Removed: ” .. removedDay)
print(#days) –> 4
“`

8.2 作为字典 (哈希映射)

“`lua
local student = {
name = “Grace”,
major = “Computer Science”,
gpa = 3.8
}

— 访问
print(student.name) –> Grace
print(student[“major”]) –> Computer Science

— 添加/修改
student.year = 3
student[“gpa”] = 3.9

— 删除 (将键的值设为 nil)
student.major = nil

— 遍历
for k, v in pairs(student) do
if v ~= nil then — 检查 nil，因为 major 被删除了
print(k .. ” = ” .. tostring(v))
end
end
“`

8.3 Table 作为对象 (面向对象基础)

Lua 没有内置的类，但可以用 table 和函数（特别是配合元表）来模拟面向对象的编程。

“`lua
— 创建一个 “类” (原型 table)
local Rectangle = {}
Rectangle.new = function(w, h)
local rect = {width = w, height = h} — 创建实例 table
— 设置元表，使得实例可以查找 Rectangle 中的方法
setmetatable(rect, { __index = Rectangle })
return rect
end

— 定义方法
function Rectangle:area() — 使用冒号语法糖
return self.width * self.height
end
— 等价于:
— function Rectangle.area(self)
— return self.width * self.height
— end

function Rectangle:printInfo()
print(“Rectangle: width=” .. self.width .. “, height=” .. self.height)
end

— 创建实例
local r1 = Rectangle.new(10, 5)
local r2 = Rectangle.new(7, 3)

— 调用方法
r1:printInfo() –> Rectangle: width=10, height=5
print(“Area of r1:”, r1:area()) –> Area of r1: 50

r2:printInfo() –> Rectangle: width=7, height=3
print(“Area of r2:”, r2:area()) –> Area of r2: 21

— 解释:
— 当调用 r1:area() 时，Lua 发现 r1 本身没有 ‘area’ 键。
— 它检查 r1 的元表，找到 __index 元方法，该方法指向 Rectangle table。
— Lua 在 Rectangle table 中查找 ‘area’，找到了函数。
— 冒号语法糖自动将 r1 作为第一个参数 (self) 传递给 area 函数。
— 即 r1:area() 等价于 Rectangle.area(r1)。
`` **元表 (Metatables)** 是一个更高级的概念，允许你改变 table 的行为（如操作符重载__add,__mul，索引访问__index,__newindex等）。__index` 是实现继承和方法查找的关键。

9. 模块与 `require`

为了组织代码，可以将相关的函数和数据放到一个单独的 .lua 文件中，作为一个模块。其他脚本可以通过 require 函数加载和使用这个模块。

my_module.lua
“`lua
local M = {} — 创建一个 table 来存放模块内容

local function private_helper()
print(“This is a private helper function.”)
end

function M.public_function(name)
private_helper()
print(“Hello from the module, ” .. name .. “!”)
end

M.data = { value = 123 }

return M — 必须返回这个 table，以便 require 获取
“`

main.lua
“`lua
— 加载模块。require 会查找 my_module.lua (或 my_module.so/dll)
— 它会缓存结果，同一模块只会被执行一次。
local myModule = require(“my_module”) — 不需要写 .lua 后缀

— 使用模块的功能
myModule.public_function(“User”)
–> This is a private helper function.
–> Hello from the module, User!

print(myModule.data.value) –> 123

— 不能直接访问模块内的局部变量或函数
— myModule.private_helper() — 这会出错
``require会在预定义的路径列表中查找模块文件。这些路径通常存储在package.path(Lua 文件) 和package.cpath` (C 库) 变量中。

10. 错误处理

Lua 使用 error(message) 函数来抛出错误，这通常会终止脚本的执行。可以使用 pcall (protected call) 或 xpcall (extended pcall) 来捕获和处理错误。

pcall(function, arg1, ...): 在保护模式下调用 function。
* 如果函数执行成功，pcall 返回 true 和函数的所有返回值。
* 如果函数执行过程中发生错误，pcall 返回 false 和错误消息（或错误对象）。

“`lua
function mightFail(shouldFail)
if shouldFail then
error(“Something went wrong!”)
else
return “Success”, 123
end
end

— 尝试调用成功的情况
local ok1, result1, result2 = pcall(mightFail, false)
if ok1 then
print(“Call succeeded:”, result1, result2) –> Call succeeded: Success 123
else
print(“Call failed:”, result1)
end

— 尝试调用失败的情况
local ok2, err_msg = pcall(mightFail, true)
if ok2 then
print(“Call succeeded:”, err_msg)
else
print(“Call failed:”, err_msg) –> Call failed: …/lua_test.lua:3: Something went wrong! (错误消息包含堆栈信息)
end

print(“Script continues after pcall.”)
``xpcall(function, error_handler_function)` 允许你提供一个自定义的错误处理函数，在错误发生时被调用，接收错误对象作为参数。

11. 标准库简介

Lua 提供了一些内置的标准库，提供常用功能：

basic: 核心函数，如 print, type, tostring, tonumber, pcall, error 等（通常可以直接使用，无需库前缀）。
coroutine: 协程操作。
package: 模块加载和包管理 (require, package.path 等)。
string: 字符串处理 (string.sub, string.find, string.gsub, string.format 等)。
table: 表操作 (table.insert, table.remove, table.sort 等)。
math: 数学函数 (math.sin, math.cos, math.sqrt, math.random 等)。
io: 输入/输出操作 (io.read, io.write, io.open 等)。
os: 操作系统功能 (os.time, os.date, os.exit, os.execute 等)。
debug: 调试功能。
utf8: UTF-8 字符串支持 (Lua 5.3+)。

“`lua
— 示例
print(string.upper(“hello lua”)) –> HELLO LUA
print(string.sub(“Hello World”, 7, 11)) –> World
print(string.format(“Name: %s, Age: %d”, “Leo”, 28)) –> Name: Leo, Age: 28

local numbers = {5, 1, 9, 3}
table.sort(numbers)
for i, v in ipairs(numbers) do io.write(v .. ” “) end –> 1 3 5 9
print() — 换行

print(math.random(1, 10)) — 生成 1 到 10 之间的随机整数
print(os.date(“%Y-%m-%d %H:%M:%S”)) — 当前日期和时间
“`

12. 结语

本教程涵盖了 Lua 脚本语言的基础知识，包括语法、数据类型、控制流、函数、强大的 table 结构、模块化和错误处理。通过掌握这些核心概念，你已经具备了使用 Lua 编写简单到中等复杂度脚本的能力。

Lua 的真正威力往往体现在其与其他系统的集成（嵌入）以及其元表机制带来的灵活性。要进一步深入学习，建议：

阅读官方文档: Lua 官方网站提供了详细的参考手册。
阅读《Programming in Lua》 (PiL): 这本书（尤其是第一版在线免费）是学习 Lua 的权威指南。
实践: 在你感兴趣的领域（如游戏脚本、服务器配置）尝试使用 Lua 解决实际问题。
探索特定平台的 API: 如果你在特定环境（如 Roblox, OpenResty, Love2D）中使用 Lua，需要学习其提供的特定 API。

Lua 是一门设计优雅且实用的语言。希望本教程能为你开启 Lua 编程之旅提供坚实的基础。祝你学习愉快！

Lua脚本基础教程 – wiki基地

Lua 脚本基础详解：从入门到实践

1. Lua 简介

1.1 什么是 Lua？

1.2 Lua 的特点

1.3 为何学习 Lua？

2. 环境搭建与第一个程序

2.1 安装 Lua

2.2 运行 Lua 代码

3. Lua 基础语法

3.1 注释

3.2 标识符与关键字

3.3 全局变量与局部变量

4. 数据类型

5. 运算符

5.1 算术运算符

5.2 关系运算符

5.3 逻辑运算符

5.4 连接运算符

5.5 长度运算符

6. 控制结构

6.1 条件语句 `if then else`

6.2 `while` 循环

6.3 `repeat until` 循环

6.4 `for` 循环

6.5 `break` 和 `return`

7. 函数

7.1 定义函数

7.2 多返回值

7.3 可变参数 (`...`)

8. Table 深入

8.1 作为数组

8.2 作为字典 (哈希映射)

8.3 Table 作为对象 (面向对象基础)

9. 模块与 `require`

10. 错误处理

11. 标准库简介

12. 结语

发表评论取消回复

Lua 脚本基础详解：从入门到实践

1. Lua 简介

1.1 什么是 Lua？

1.2 Lua 的特点

1.3 为何学习 Lua？

2. 环境搭建与第一个程序

2.1 安装 Lua

2.2 运行 Lua 代码

3. Lua 基础语法

3.1 注释

3.2 标识符与关键字

3.3 全局变量与局部变量

4. 数据类型

5. 运算符

5.1 算术运算符

5.2 关系运算符

5.3 逻辑运算符

5.4 连接运算符

5.5 长度运算符

6. 控制结构

6.1 条件语句 if then else

6.2 while 循环

6.3 repeat until 循环

6.4 for 循环

6.5 break 和 return

7. 函数

7.1 定义函数

7.2 多返回值

7.3 可变参数 (...)

8. Table 深入

8.1 作为数组

8.2 作为字典 (哈希映射)

8.3 Table 作为对象 (面向对象基础)

9. 模块与 require

10. 错误处理

11. 标准库简介

12. 结语

发表评论 取消回复

6.1 条件语句 `if then else`

6.2 `while` 循环

6.3 `repeat until` 循环

6.4 `for` 循环

6.5 `break` 和 `return`

7.3 可变参数 (`...`)

9. 模块与 `require`

发表评论取消回复