Lua 语言入门

Lua 是什么?核心优势与应用场景

什么是 Lua?

Lua 是一门轻量级、动态类型、解释型脚本语言，由巴西里约热内卢天主教大学团队开发，全程开源免费。它的核心设计理念只有一个：极简、高效、可嵌入。

不同于 Python、JS 主打独立开发，Lua 天生为「嵌入」而生，可以无缝集成到 C/C++、Java、Go 等主流语言中，作为脚本层实现逻辑热更新、功能扩展。

Lua 核心优势

极致轻量：编译后体积仅几百 KB，无任何依赖，嵌入式设备、低端服务器均可运行。
运行高效：脚本语言中性能第一梯队，接近编译型语言，远超 Python、JS。
语法极简：关键字极少，语法宽松，零基础 1 小时即可上手基础语法。
热更新神器：无需重启程序，动态替换脚本逻辑，游戏、服务端必备。
高扩展性：完美对接 C/C++，底层高性能开发、上层脚本快速迭代。

主流应用场景

游戏开发：Unity、Cocos2d、Roblox 核心脚本语言（90% 手游热更新基于 Lua）
服务器开发：OpenResty（Nginx）脚本扩展，高性能网关、接口服务
嵌入式开发：路由器、智能家居、工程设备脚本逻辑
软件插件：Photoshop、Redis、Wireshark 插件脚本开发

环境搭建与第一个程序

环境安装

Windows

windows 用户可下载对应的二进制文件：https://luabinaries.sourceforge.net/download.html

以 lua-5.5.0_Win64_bin.zip 为例，下载后解压，双击 lua55.exe 即可打开 lua 编辑环境。

可以将该目录添加到环境变量 Path 中，方便后续直接使用 lua 命令。

MacOS

终端执行 brew install lua

Linux

终端执行 sudo apt install lua5.5

第一个 Lua 程序

新建 hello.lua 文件，写入代码：

1
2
3
4
5
6


--- 单行注释
--[[
    多行注释
    Lua 入门第一个程序
]]
print("Hello Lua!")

终端执行 lua hello.lua，即可打印输出内容 Hello Lua!。

注意：Windows 安装包 exe 程序可能是 lua55.exe，则命令该为 lua55 hello.lua。

Lua 基础语法

Lua 语法及其宽松，无需声明变量类型、无需分号结尾，上手门槛极低，核心基础知识点如下：

数据类型	说明	示例
`nil`	空值（未赋值、删除变量）	`a = nil`
`boolean`	布尔值，true / false	`flag = true`
`number`	数字（整数 + 浮点数统一存储）	`num = 10`、`pi = 3.14`
`string`	字符串，单/双引号均可	`str = "Lua 基础`
`function`	函数	`func = function() end`
`table`	表（Lua 核心，数组 + 字典合体）	`t = {1,2,name="lua"}`

重点特性：Lua 中 nil、false 为假，0、空字符串、空表均为真（和其他语言不同）

运算符

支持常规运算、比较、逻辑运算符，新增独特字符串拼接符 ..：

1
2
3
4
5


--- 字符串拼接
local str = "hello" .. " lua"

-- 逻辑运算：and、or、not
local res = 10 > 5 and true or false

流程控制语句

条件判断

1
2
3
4
5
6
7
8


local score = 90
if score >= 80 then
    print("优秀")
elseif score >= 60 then
    print("及格")
else
    print("不及格")
end

循环语句

Lua 有三种循环：while、for、repeat-unit

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


-- for 循环 (1-5 遍历)
for i=1,5 do
    print(i)
end

-- while 循环
local num = 1
while num <=3 do
    print(num)
    num = num + 1
end

函数基础

Lua 函数是一等公民，可以赋值、传参、返回多值，是进阶核心基础：

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


-- 普通函数
local function add(a,b)
    return a + b  -- 返回值
end

-- 匿名函数赋值
local sub = function(a,b)
    return a - b
end

-- 返回多值
local function getInfo()
    return "Lua",5.5
end
local name,version = getInfo()

Lua 进阶

如果说基础语法是入门，那 Table 表就是 Lua 的灵魂，Lua 80% 的进阶用法、项目实战、框架封装都基于 Table 实现。

Table 万能数据表（数组 + 字典）

Lua 没有数组、字典、对象，所有复合数据全靠 Table 实现，兼具有序数组和无序字典特性：

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


-- 1. 数组形式（默认从 1 开始索引，不是 0）
local arr = {"Java","Lua","Python"}
print(arr[1])   -- 输出 Java

-- 2. 字典形式
local dict = {
    name = "Lua"
    version = 5.5
    type = "script"
}
print(dict.name)

-- 3. 混合形式
local mix = {
    name = "Lua"
    version = 5.5
    type = "script"
    arr = {"Java","Lua","Python"}
}

💡 新手大坑：Lua 数组默认索引从1开始，区别于所有主流编程语言。

全局变量与局部变量

Lua 中变量分两种：局部变量 local、全局变量，进阶开发必须严格区分：

局部变量 local：作用于仅限当前代码块，访问速度极快，项目开发优先使用
全局变量：全局生效，存储在全局表 _G 中，访问慢、易冲突，禁止滥用

✅进阶规范：所有变量、函数必须加 local，杜绝全局污染。

迭代器与 Table 遍历

项目中高频使用的三种遍历方式：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


local t = {name="Lua",version=5.5,type="script","Hello","Lua"}

-- 1. ipairs：只遍历数组部分 (有序、从 1 开始)
for i,v in ipairs(t) do
    print(i,v)
end

-- 2. pairs：遍历全部（数组 + 字典，无序）
for k,v in pairs(t) do
    print(k,v)
end

闭包与作用域 (高阶核心)

闭包是 Lua 进阶的核心，简单说：函数嵌套函数，内层函数访问外层局部变量，可实现数据私有化、状态保存：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


local function counter()
    local num = 0  -- 私有变量
    -- 内层闭包函数
    return function()
        num = num + 1
        return num
    end
end

local c1 = counter()
print(c1())  -- 1
print(c1())  -- 2  保留上一次状态

闭包广泛用于热更新、回调函数、私有数据封装，是中高级 Lua 开发者必备能力。

高阶进阶

掌握以下知识点，才算真正脱离入门，达到 Lua 进阶水平，可独立开发项目、框架脚本。

元表与原方法 (Lua 底层核心)

元表 (metatable) 是 Lua 的底层机制，可以修改 Table 的默认行为，比如实现表相加、自动赋值、拦截访问，是框架、ORM、热更新的底层支持。

核心常用元方法：

__index：访问表不存在的字段时触发（实现默认值、继承）
__newindex：给表不存在的字段赋值时触发（拦截赋值、只读表）
__add：实现两个表相加运算

简易示例（表默认值实现）：

1
2
3
4
5
6
7
8
9


local t = {}
local mt = {
    __index = function()
        return "default"
    end
}

setmetatable(t, mt)   -- 绑定元表
print(t.name)       -- 不存在字段，输出默认值

模块与包管理

Lua 通过 require 引入模块，实现代码解耦、复用，是项目工程化的基础。

新建模块 module.lua

1
2
3
4
5
6
7


local M = {}   -- 模块导出表

function M.hello()
    print("模块调用成功")
end

return M

主文件引入使用

1
2


local mod = require("module")
mod.hello()

Lua 面向对象编程（进阶核心）

Lua 没有原生 OOP 语法，通过元表 + __index 继承实现面向对象，是游戏开发、框架开发的核心用法：

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


-- 父类
local Person = {}
Person.__index = Person

-- 构造函数
function Person.new(name, age)
    local self = setmetatable({}, Person)
    self.name = name
    self.age = age
    return self
end

-- 成员方法
function Person:say()
    print("Hello, my name is " .. self.name .. " and I am " .. self.age .. " years old.")
end

-- 实例化对象
local p = Person.new("小明", 12)
p:say()

常见问题与性能优化

新手高频坑点

Table 数组索引从 1 开始，而非 0
0、空字符串、空表为真，仅 nil、false 为假
尽量使用局部变量 local，减少全局变量
pairs 遍历无序，ipairs 遍历有序且仅数组部分

性能优化技巧

变量优化：高频访问的全局变量、模块方法，提前缓存为局部变量
字符串优化：字符串拼接大量数据时，避免频繁 .. 拼接，使用 table.concat
Table 优化：预分配表空间，避免频繁扩容；及时置空无用表释放内存
循环优化：循环内不创建变量、不调用复杂函数，减少循环开销