1.1 Lua语言简介

1.1 Lua语言简介

1 Lua语言简介：轻量级脚本的强大力量

Lua，在葡萄牙语中意为“月亮”，正如其名，它以小巧、灵活和优雅著称。自1993年诞生以来，Lua语言凭借其卓越的性能和易嵌入性，在游戏开发、配置脚本、嵌入式系统等领域占据了重要地位。本文将带您踏入Lua的世界，从零开始，了解这门简洁而强大的脚本语言。

1.1 初识Lua：它是什么，为何选择它？

1.1.1 Lua的定义与特性

Lua是一种轻量级、可嵌入、高性能的多范式脚本语言。由巴西里约热内卢天主教大学的 Roberto Ierusalimschy、Luiz Henrique de Figueiredo 和 Waldemar Celes 于1993年设计并开发。

Lua的核心特性包括：

• 轻量级：Lua解释器和标准库非常小巧，易于嵌入到各种应用程序中。

• 可嵌入性：Lua被设计为易于C/C++等宿主语言调用，也易于被宿主语言调用，实现灵活的扩展和定制。

• 高性能：Lua采用基于寄存器的虚拟机，执行效率高，接近于C语言的性能。

• 简洁优雅：Lua语法简洁明了，易于学习和使用，代码可读性强。

• 动态类型：Lua是动态类型语言，无需显式声明变量类型，类型检查在运行时进行。

• 多范式：Lua支持过程式编程、面向对象编程以及函数式编程范式，提供了灵活的编程模型。

• 扩展性：Lua可以通过C/C++扩展库进行功能扩展，也可以嵌入C/C++代码，实现强大的功能。

• 跨平台：Lua代码可以在各种操作系统平台上运行，具有良好的跨平台性。

1.1.2 为什么选择Lua？Lua的应用场景

选择Lua的理由有很多，尤其对于初学者和特定应用场景而言，Lua具有独特的优势：

• 易学易用：Lua的语法规则简单，学习曲线平缓，非常适合编程初学者入门。

• 快速原型开发：Lua的动态性和简洁性使其非常适合快速原型开发，可以快速验证想法和构建应用。

• 游戏开发：Lua是游戏开发领域的热门脚本语言，被广泛应用于游戏逻辑、UI、AI等模块的开发，例如《魔兽世界》、《愤怒的小鸟》、《文明》系列等知名游戏都使用了Lua。

• 嵌入式系统：Lua的小巧和高效使其成为嵌入式系统和物联网设备的理想选择，可以用于设备配置、脚本控制等。

• 配置脚本：许多应用程序使用Lua作为配置文件，例如Nginx、Redis等，Lua的灵活性和易读性使得配置更加强大和易于维护。

• 扩展应用程序：通过Lua脚本，可以为应用程序提供灵活的扩展能力，用户可以自定义功能和行为，例如Wireshark、Adobe Photoshop Lightroom等软件都支持Lua脚本扩展。

总而言之，Lua以其轻巧、高效、易学和强大的扩展性，成为了一个在众多领域都备受欢迎的脚本语言。

1.2 搭建Lua开发环境：准备起航

要开始Lua编程之旅，首先需要搭建Lua开发环境。

1.2.1 安装Lua解释器

Lua代码需要Lua解释器来执行。您可以从Lua官网 www.lua.org 下载适合您操作系统的Lua解释器。

• Windows: 建议下载预编译的二进制版本，例如 LuaDist 或者 Lua for Windows。下载后解压即可使用，并将Lua解释器所在目录添加到系统环境变量 PATH 中，方便在命令行中直接使用 lua 命令。

• macOS/Linux: 通常可以通过包管理器进行安装。

  • macOS (Homebrew): 在终端中运行 brew install lua

  • Debian/Ubuntu: 在终端中运行 sudo apt-get update && sudo apt-get install lua5.4 (版本号可能略有不同)

  • CentOS/RHEL/Fedora: 在终端中运行 sudo yum install lua 或 sudo dnf install lua

安装完成后，打开命令行终端（Windows: 命令提示符或 PowerShell, macOS/Linux: 终端），输入 lua -v 命令，如果能正确显示Lua的版本信息，则说明Lua解释器安装成功。

lua -v
​

输出示例：

Lua 5.4.4  Copyright (C) 1994-2022 Lua.org, PUC-Rio
​

1.2.2 运行Lua代码

Lua代码可以通过两种方式运行：

1. 交互式解释器 (Lua REPL): 在命令行终端中直接输入 lua 命令，即可进入Lua交互式解释器环境 (REPL - Read-Eval-Print Loop)。在 > 提示符后输入Lua代码，按下回车键即可立即执行并显示结果。

   lua
   Lua 5.4.4  Copyright (C) 1994-2022 Lua.org, PUC-Rio
   > print("Hello, Lua!")
   Hello, Lua!
   > 2 + 3
   5
   >
   ​

   输入 Ctrl+C (或 Ctrl+D，取决于操作系统) 可以退出交互式解释器。

2. 执行Lua脚本文件: 将Lua代码保存到以 .lua 为扩展名的文本文件中 (例如 hello.lua)，然后使用 lua 命令加上脚本文件名来执行。

   hello.lua 文件内容:

   print("Hello, Lua from file!")
   ​

   在命令行终端中执行:

   lua hello.lua
   ​

   输出结果：

   Hello, Lua from file!
   ​

1.2.3 代码编辑器 (可选)

虽然可以使用任何文本编辑器编写Lua代码，但为了提高开发效率，建议使用代码编辑器或集成开发环境 (IDE)，它们通常提供语法高亮、代码自动完成、代码调试等功能。

一些常用的Lua代码编辑器包括：

• VS Code (Visual Studio Code): 免费、跨平台、功能强大，可通过安装 Lua 插件获得良好的Lua开发支持。

• Sublime Text: 轻量级、快速、可扩展，可通过 Package Control 安装 Lua 插件。

• Atom: 免费、可定制、基于Web技术，可通过安装 Lua 插件。

• ZeroBrane Studio: 专门为Lua开发的轻量级IDE，集成了调试器，适合Lua初学者和专业开发者。

• IntelliJ IDEA/WebStorm/PhpStorm (with Lua plugin): 功能强大的IDE，如果已经使用JetBrains系列IDE，可以通过安装 Lua 插件来支持Lua开发。

选择哪种编辑器取决于个人偏好和需求，对于初学者，VS Code 或 ZeroBrane Studio 都是不错的选择。

1.3 Lua基础语法：构建代码的基石

掌握Lua的基础语法是编写Lua代码的先决条件。本节将介绍Lua中的基本语法元素。

1.3.1 变量与数据类型

Lua是动态类型语言，变量无需显式声明类型，变量的类型由赋给它的值决定。Lua中有以下几种基本数据类型：

• nil: 空类型，表示“没有值”或“不存在的值”。未初始化的变量默认值为 nil。

• boolean: 布尔类型，只有两个值：true (真) 和 false (假)。注意Lua中只有 false 和 nil 为假，其他所有值 (包括 0 和空字符串) 都为真。

• number: 数值类型，用于表示数字。Lua 5.3 版本之后，数值类型分为两种：

  • integer: 整数。

  • float: 浮点数 (双精度浮点数)。

  Lua会自动根据需要进行整数和浮点数之间的转换。

• string: 字符串类型，用于表示文本。字符串可以使用单引号 ' 或双引号 " 括起来。

• table: 表类型，Lua中最重要也是最强大的数据结构。表是一种关联数组，可以存储任意类型的值，并使用任意类型的值作为键 (除了 nil)。表类似于其他语言中的数组、哈希表、字典、对象等。

• function: 函数类型，表示函数。在Lua中，函数也是一种“第一类值”，可以像其他值一样赋值给变量、作为参数传递、作为返回值返回。

• userdata: 用户数据类型，用于表示宿主语言 (例如C/C++) 创建的数据。用户数据类型的值没有预定义的操作，只能通过宿主语言提供的接口进行操作。

• thread: 线程类型，用于表示独立的执行线程 (协程)。

变量声明与赋值:

Lua中变量无需显式声明，直接赋值即可创建变量。变量名可以是字母、数字和下划线的组合，但必须以字母或下划线开头，并且区分大小写。

-- 变量赋值示例
message = "Hello, Lua variables!"  -- 字符串类型
count = 10                        -- 数值类型 (整数)
price = 99.99                     -- 数值类型 (浮点数)
is_valid = true                   -- 布尔类型
nothing = nil                     -- nil 类型
print(message)
print(count)
print(price)
print(is_valid)
print(nothing)
-- 查看变量类型 (使用 type() 函数)
print(type(message))  --> string
print(type(count))    --> number
print(type(price))    --> number
print(type(is_valid))  --> boolean
print(type(nothing))  --> nil
​

1.3.2 运算符

Lua支持常见的运算符，包括：

• 算术运算符: + (加), - (减), * (乘), / (除), % (取模), ^ (指数), // (floor division - Lua 5.3+，向下取整除法)

  -- 算术运算符示例
  a = 10
  b = 3
  print(a + b)   --> 13
  print(a - b)   --> 7
  print(a * b)   --> 30
  print(a / b)   --> 3.3333333333333335
  print(a % b)   --> 1
  print(a ^ b)   --> 1000
  print(a // b)  --> 3  (Lua 5.3+)
  ​

• 关系运算符: == (等于), ~= (不等于), < (小于), > (大于), <= (小于等于), >= (大于等于)

  关系运算符返回布尔值 true 或 false。

  -- 关系运算符示例
  x = 5
  y = 10
  print(x == y)  --> false
  print(x ~= y)  --> true
  print(x < y)   --> true
  print(x > y)   --> false
  print(x <= y)  --> true
  print(x >= y)  --> false
  ​

• 逻辑运算符: and (逻辑与), or (逻辑或), not (逻辑非)

  逻辑运算符的操作数和返回值都是布尔值。

  • and：当且仅当两个操作数都为真时，结果为真。

  • or：当两个操作数至少有一个为真时，结果为真。

  • not：对操作数取反，真变假，假变真。

  -- 逻辑运算符示例
  p = true
  q = false
  print(p and q)  --> false
  print(p or q)   --> true
  print(not p)    --> false
  print(not q)    --> true
  ​

  短路求值: and 和 or 运算符具有短路求值特性。

  • a and b：如果 a 为假，则直接返回 a，否则返回 b。

  • a or b：如果 a 为真，则直接返回 a，否则返回 b。

  这在编写条件表达式时非常有用。

• 连接运算符: .. (字符串连接)

  -- 连接运算符示例
  str1 = "Hello"
  str2 = "Lua"
  greeting = str1 .. ", " .. str2 .. "!"
  print(greeting)  --> Hello, Lua!
  ​

• 赋值运算符: = (简单赋值), +=, -=, *=, /=, %=, ^= (复合赋值 - Lua 5.3+)

  复合赋值运算符是算术运算符和赋值运算符的组合，例如 a += b 等价于 a = a + b。

  -- 赋值运算符示例
  count = 0
  count = count + 1  -- 等价于 count += 1 (Lua 5.3+)
  count += 1         -- Lua 5.3+
  print(count)       --> 2
  price = 100
  price *= 0.9      -- 等价于 price = price * 0.9 (Lua 5.3+)
  print(price)       --> 90.0
  ​

1.3.3 注释

注释用于在代码中添加说明性文字，提高代码可读性。Lua支持两种注释方式：

• 单行注释: 使用双连字符 -- 开头，直到行末。

  -- 这是一行单行注释
  print("Hello, comment!")  -- 这行代码后面也是注释
  ​

• 多行注释: 使用 --[[ 开始，]] 结束，可以跨越多行。

  --[[
  这是一个多行注释块。
  可以写多行文字进行说明。
  ]]--
  print("Hello, multi-line comment!")
  ​

1.3.4 控制流语句

控制流语句用于控制代码的执行顺序，Lua提供了以下几种控制流语句：

• 条件语句 (if-else): 根据条件判断结果执行不同的代码块。

  -- if 语句
  age = 18
  if age >= 18 then
      print("成年人")
  end
  -- if-else 语句
  score = 75
  if score >= 60 then
      print("及格")
  else
      print("不及格")
  end
  -- if-elseif-else 语句
  grade = 85
  if grade >= 90 then
      print("优秀")
  elseif grade >= 80 then
      print("良好")
  elseif grade >= 70 then
      print("中等")
  elseif grade >= 60 then
      print("及格")
  else
      print("不及格")
  end
  ​

• 循环语句 (while, for): 重复执行代码块。

  • while 循环: 当条件为真时，循环执行代码块。

    -- while 循环
    i = 1
    while i <= 5 do
        print("Count:", i)
        i = i + 1
    end
    ​

  • for 循环 (数值型): 根据数值范围循环执行代码块。

    -- 数值型 for 循环
    for i = 1, 5 do  -- 从 1 循环到 5，步长默认为 1
        print("Number:", i)
    end
    for j = 1, 10, 2 do -- 从 1 循环到 10，步长为 2 (1, 3, 5, 7, 9)
        print("Odd number:", j)
    end
    for k = 10, 1, -1 do -- 从 10 循环到 1，步长为 -1 (倒序循环)
        print("Reverse count:", k)
    end
    ​

  • for 循环 (泛型 for, 迭代器): 用于遍历集合类型 (例如表) 的元素。 （这里先简单提及，更详细的表迭代将在后续章节介绍）

    -- 泛型 for 循环 (遍历表)
    fruits = {"apple", "banana", "orange"}
    for index, fruit in ipairs(fruits) do  -- ipairs 用于遍历数组类型的表
        print(index, fruit)
    end
    ​

1.4 核心数据结构：强大的表 (Table)

表 (Table) 是Lua中最核心、最强大的数据结构。在Lua中，表不仅可以作为数组使用，还可以作为关联数组 (哈希表)、字典、对象等使用，具有极高的灵活性。

1.4.1 表的创建与访问

表使用花括号 {} 创建。可以创建空表，也可以在创建时初始化表中的元素。

-- 创建空表
empty_table = {}
-- 创建并初始化表 (数组形式)
fruits = {"apple", "banana", "orange"}
-- 创建并初始化表 (关联数组/字典形式)
person = {
    name = "Alice",
    age = 30,
    city = "New York"
}
-- 创建混合类型的表
mixed_table = {
    10,
    "hello",
    true,
    key = "value"
}
​

访问表元素可以使用两种方式：

1. 索引访问 (数组形式): 使用方括号 [] 和数字索引访问，索引从 1 开始。

   -- 索引访问 (数组形式)
   print(fruits[1])    --> apple
   print(fruits[2])    --> banana
   print(fruits[3])    --> orange
   fruits[4] = "grape"  -- 添加新元素
   print(fruits[4])    --> grape
   ​

2. 键值访问 (关联数组/字典形式): 使用方括号 [] 和键名 (字符串或数值) 访问，或者使用点号 . 和键名 (当键名为合法的标识符时) 访问。

   -- 键值访问 (关联数组/字典形式)
   print(person["name"])   --> Alice
   print(person.age)      --> 30  (等价于 person["age"])
   print(person["city"])   --> New York
   person["gender"] = "female"  -- 添加新键值对
   person.occupation = "Engineer" -- 添加新键值对 (等价于 person["occupation"] = "Engineer")
   print(person.gender)      --> female
   print(person.occupation)  --> Engineer
   ​

1.4.2 表的操作

• 插入元素: 可以使用索引赋值或 table.insert() 函数在表中插入元素。

  • 索引赋值：对于数组类型的表，可以使用索引直接赋值插入新元素。

  • table.insert(table, [pos,] value)：在表 table 的指定位置 pos 插入值 value。如果省略 pos，则在表末尾插入。

  -- 表元素插入
  numbers = {1, 2, 3}
  numbers[4] = 4  -- 索引赋值，末尾插入
  table.insert(numbers, 1, 0) -- 在索引 1 的位置插入 0 (原来的元素后移)
  table.insert(numbers, 3.5) --  错误！索引必须是整数，或者不指定索引在末尾插入
  print(numbers[1], numbers[2], numbers[3], numbers[4], numbers[5]) --> 0 1 2 3 4
  ​

• 删除元素: 可以使用索引赋值为 nil 或 table.remove() 函数删除表中的元素。

  • 索引赋值为 nil：将指定索引位置的元素设置为 nil，但表中的位置仍然保留，只是值为空。

  • table.remove(table, [pos])：移除表 table 中指定位置 pos 的元素，并返回被移除的元素。如果省略 pos，则移除表末尾的元素。移除元素后，后面的元素会前移。

  -- 表元素删除
  colors = {"red", "green", "blue", "yellow"}
  colors[2] = nil  -- 将索引 2 的元素设置为 nil (但位置还在)
  removed_color = table.remove(colors, 3) -- 移除索引 3 的元素 (blue)，并返回 "blue"
  last_color = table.remove(colors) -- 移除末尾元素 (yellow)，并返回 "yellow"
  print(colors[1], colors[2], colors[3])   --> red nil green
  print(removed_color)                   --> blue
  print(last_color)                      --> yellow
  ​

• 获取表的大小 (长度): 可以使用长度操作符 # 或 table.getn() 函数获取数组类型表的长度 (元素个数)。

  对于关联数组类型的表，长度操作符和 table.getn() 函数可能无法准确返回键值对的数量，因为它们主要针对数组索引部分进行计数。

  -- 获取表长度
  names = {"Alice", "Bob", "Charlie"}
  print(#names)         --> 3
  print(table.getn(names)) --> 3  (Lua 5.1 及更早版本推荐使用 table.getn())
  info = {name = "David", age = 25}
  print(#info)          --> 0 (对于关联数组，长度操作符可能不准确)
  print(table.getn(info))  --> 0 (对于关联数组，table.getn() 也不准确)
  ​

• 迭代表 (遍历表): 可以使用 for 循环和迭代器函数遍历表中的元素。

  • ipairs(table)：用于遍历数组类型的表，按索引顺序迭代，从索引 1 开始，遇到 nil 值或非整数索引时停止。

  • pairs(table)：用于遍历所有类型的表 (包括数组和关联数组)，按任意顺序迭代所有键值对。

  -- 迭代表
  numbers = {10, 20, 30, 40}
  print("ipairs 迭代:")
  for index, value in ipairs(numbers) do
      print(index, value)
  end
  -- 输出:
  -- 1       10
  -- 2       20
  -- 3       30
  -- 4       40
  person_info = {name = "Eve", city = "London", age = 28}
  print("\npairs 迭代:")
  for key, value in pairs(person_info) do
      print(key, value)
  end
  -- 输出 (顺序可能不同):
  -- city    London
  -- age     28
  -- name    Eve
  ​

1.4.3 表的更多应用

表在Lua中用途广泛，除了作为数组和关联数组，还可以模拟其他数据结构，例如：

• 集合 (Set): 可以使用表的键来表示集合中的元素，值可以设置为 true 或 nil (仅关心键的存在)。

• 对象 (Object): 可以使用表来模拟对象，表中的键表示对象的属性和方法。 （面向对象编程将在后续更深入的章节介绍）

表的灵活性和强大功能是Lua语言的核心优势之一。

1.5 函数：代码的模块化与重用

函数 (Function) 是组织和重用代码的基本单元。Lua中的函数也是“第一类值”，可以赋值给变量、作为参数传递、作为返回值返回。

1.5.1 函数的定义与调用

函数定义使用 function 关键字开始，end 关键字结束。函数定义可以包含参数列表和函数体。

-- 函数定义
function greet(name)  -- 函数名：greet，参数：name
    print("Hello, " .. name .. "!")  -- 函数体
end
-- 函数调用
greet("Lua User")  --> Hello, Lua User!
greet("World")     --> Hello, World!
​

1.5.2 函数参数与返回值

函数可以接受零个或多个参数，并可以返回零个或多个值。

-- 带参数和返回值的函数
function add(a, b)
    local sum = a + b
    return sum  -- 返回值
end
result = add(5, 3)
print("Sum:", result)  --> Sum: 8
-- 返回多个值的函数
function calculate_area_perimeter(radius)
    local area = math.pi * radius ^ 2
    local perimeter = 2 * math.pi * radius
    return area, perimeter  -- 返回多个值
end
area, perimeter = calculate_area_perimeter(2)
print("Area:", area)       --> Area: 12.566370614359172
print("Perimeter:", perimeter) --> Perimeter: 12.566370614359172
-- 没有返回值的函数 (默认返回 nil)
function say_hello()
    print("Hello there!")
    -- 没有 return 语句，默认返回 nil
end
return_value = say_hello()  --> Hello there!
print("Return value:", return_value) --> Return value: nil
​

1.5.3 匿名函数与闭包

Lua支持匿名函数 (anonymous function)，也称为 lambda 函数或闭包 (closure)。匿名函数是没有名字的函数，可以直接定义并使用，或者赋值给变量。