Lua 篇（二）— Lua 的基本语法和函数

一、Lua 的基本语法

1.注释

代码如下（示例）：

-- 这是一行单行注释
--[[
这是一个
多行注释
]]

2.变量

代码如下（示例）：

-- Lua 是一种动态类型的语言，变量不需要声明类型，可以直接赋值
-- 变量名可以由字母，数字，下划线组成，但不能以数字开头，也不能是 Lua 的保留字
-- Lua 有三种类型的变量：全局变量，局部变量，表的域

-- 全局变量是默认的变量类型，可以在任何地方访问，不需要声明，直接赋值即可
x = 10 -- x 是一个全局变量
print(x) -- 输出 10

-- 局部变量是在函数或者代码块中定义的变量，只在该范围内有效，需要使用 local 关键字声明
local y = 20 -- y 是一个局部变量
print(y) -- 输出 20

-- 表的域是指表中的一个键值对，表是 Lua 的唯一的数据结构，可以用来表示数组，字典，对象等
-- 表的域可以是全局的，也可以是局部的，取决于表本身是如何定义的
z = {} -- z 是一个全局变量，表示一个空表
z.a = 30 -- z.a 是一个全局的表的域，表示表 z 中的一个键值对，键为 a，值为 30
print(z.a) -- 输出 30

local w = {} -- w 是一个局部变量，表示一个空表
w.b = 40 -- w.b 是一个局部的表的域，表示表 w 中的一个键值对，键为 b，值为 40
print(w.b) -- 输出 40

3.数据类型

代码如下（示例）：

-- Lua 支持以下几种数据类型：nil，boolean，number，string，function，userdata，thread，table
-- 可以使用 type 函数来检查一个值的类型

-- nil 表示空值，相当于其他语言的 null，nil 是 Lua 的保留字
print(type(nil)) -- 输出 nil

-- boolean 表示布尔值，只有两个值：true 和 false，它们都是 Lua 的保留字
-- Lua 把 false 和 nil 视为假，其他任何值都视为真
print(type(true)) -- 输出 boolean
print(type(false)) -- 输出 boolean

-- number 表示数字，Lua 默认使用双精度浮点数表示所有的数字，没有整数类型
-- 可以使用科学计数法或者十六进制表示数字
print(type(10)) -- 输出 number
print(type(3.14)) -- 输出 number
print(type(1e10)) -- 输出 number
print(type(0xff)) -- 输出 number

-- string 表示字符串，可以使用单引号或者双引号表示字符串
-- 可以使用 .. 连接两个字符串，可以使用 # 获取字符串的长度
-- 可以使用 [[]] 表示多行字符串，也可以用来表示正则表达式
print(type("Hello")) -- 输出 string
print(type('World')) -- 输出 string
print("Hello" .. "World") -- 输出 HelloWorld
print(#"Hello") -- 输出 5


-- function 表示函数，Lua 是一种函数式编程语言，函数可以作为值存储，传递，返回
-- 可以使用 function 关键字定义一个函数，也可以使用匿名函数
-- 函数的参数和返回值都可以是多个，使用逗号分隔
print(type(print)) -- 输出 function
print(type(type)) -- 输出 function
print(type(function() end)) -- 输出 function

-- userdata 表示一种用户自定义的数据，用来表示一种由应用程序或者 C 语言库所创建的类型
-- userdata 可以存储任意的 C 语言数据，Lua 无法直接操作它们，只能通过元表（metatable）来访问
--

4.控制结构

代码如下（示例）：

-- Lua 支持以下几种控制结构：if，while，repeat，for，break，return，goto
-- 可以使用 end 关键字结束一个控制结构

-- if 用来进行条件判断，可以使用 elseif 和 else 分支，也可以使用 and，or，not 逻辑运算符
-- Lua 中没有 switch 语句，可以用 if 来模拟
local a = 10
local b = 20
if a > b then
  print("a is greater than b")
elseif a < b then
  print("a is less than b")
else
  print("a is equal to b")
end

-- while 用来进行循环，当条件为真时执行循环体，否则跳出循环
local i = 1
while i <= 10 do
  print(i)
  i = i + 1
end

-- repeat 用来进行循环，与 while 相反，当条件为假时执行循环体，否则跳出循环
-- repeat 相当于其他语言的 do-while
local j = 1
repeat
  print(j)
  j = j + 1
until j > 10

-- for 用来进行循环，有两种形式：数值 for 和泛型 for
-- 数值 for 用来遍历一个数字区间，有三个参数：初始值，终止值，步长
-- 泛型 for 用来遍历一个迭代器，可以是一个表，一个字符串，或者一个自定义的函数
for k = 1, 10, 2 do -- 从 1 到 10，每次增加 2
  print(k)
end

local t = {a = 1, b = 2, c = 3} -- 定义一个表
for key, value in pairs(t) do -- 遍历表中的键值对
  print(key, value)
end

local s = "Hello" -- 定义一个字符串
for char in string.gmatch(s, ".") do -- 遍历字符串中的字符
  print(char)
end

-- break 用来跳出循环，可以使用在 while，repeat，for 中
for l = 1, 10 do
  if l == 5 then
    break -- 当 l 等于 5 时，跳出循环
  end
  print(l)
end

-- return 用来从函数中返回值，可以返回多个值，使用逗号分隔
-- return 也可以用来跳出循环，相当于 break
function add(x, y) -- 定义一个函数，接受两个参数
  return x + y -- 返回两个参数的和
end

local m = 1
while true do
  m = m + 1
  if m == 10 then
    return m -- 当 m 等于 10 时，返回 m 并跳出循环
  end
end

-- goto 用来无条件地跳转到一个标签，标签由双冒号包围
-- goto 可以用来实现多重跳出循环，或者模拟 continue 语句
local n = 1
::start:: -- 定义一个标签
n = n + 1
if n < 10 then
  goto start -- 当 n 小于 10 时，跳转到 start 标签
end
print(n) -- 输出 10

二、Lua 的函数

1.函数定义

代码如下（示例）：

-- Lua 中的函数是一种值，可以赋值给变量，也可以作为参数或返回值传递
-- 可以使用 function 关键字定义一个函数，也可以使用匿名函数
-- 函数的参数和返回值都可以是多个，使用逗号分隔

-- 定义一个名为 add 的函数，接受两个参数，返回它们的和
function add(x, y)
  return x + y
end

-- 定义一个匿名函数，接受一个参数，返回它的平方，然后赋值给变量 square
local square = function(x)
  return x * x
end

-- 定义一个名为 power 的函数，接受两个参数，返回第一个参数的第二个参数次方，使用匿名函数作为返回值
function power(x, y)
  return function()
    local result = 1
    for i = 1, y do
      result = result * x
    end
    return result
  end
end

2.函数调用

代码如下（示例）：

-- 函数调用使用圆括号，可以传递多个参数，也可以接收多个返回值
-- 如果传递的参数多于函数定义的参数，多余的参数会被忽略
-- 如果传递的参数少于函数定义的参数，缺少的参数会被赋值为 nil
-- 如果接收的返回值多于函数返回的值，多余的返回值会被赋值为 nil
-- 如果接收的返回值少于函数返回的值，多余的返回值会被丢弃

-- 调用 add 函数，传递两个参数，接收一个返回值
local sum = add(10, 20) -- sum 为 30

-- 调用 square 函数，传递一个参数，接收一个返回值
local sq = square(5) -- sq 为 25

-- 调用 power 函数，传递两个参数，接收一个返回值，该返回值是一个函数
local pow = power(2, 3) -- pow 为一个函数

-- 调用 pow 函数，不传递参数，接收一个返回值
local result = pow() -- result 为 8

-- 定义一个名为 swap 的函数，接受两个参数，返回它们的交换值
function swap(x, y)
  return y, x
end

-- 调用 swap 函数，传递两个参数，接收两个返回值
local a, b = swap(1, 2) -- a 为 2，b 为 1

-- 调用 swap 函数，传递两个参数，接收一个返回值
local c = swap(3, 4) -- c 为 4，多余的返回值被丢弃

-- 调用 swap 函数，传递两个参数，接收三个返回值
local d, e, f = swap(5, 6) -- d 为 6，e 为 5，f 为 nil，缺少的返回值被赋值为 nil

3.变长参数

代码如下（示例）：

-- Lua 支持变长参数，即函数可以接受任意个数的参数
-- 可以使用 ... 表示变长参数，也可以使用 table.pack 和 table.unpack 函数来操作变长参数

-- 定义一个名为 sum 的函数，接受变长参数，返回它们的和
function sum(...)
  local args = table.pack(...) -- 将变长参数打包成一个表
  local result = 0
  for i = 1, args.n do -- 遍历表中的所有参数
    result = result + args[i]
  end
  return result
end

-- 调用 sum 函数，传递任意个数的参数，接收一个返回值
local s1 = sum(1, 2, 3) -- s1 为 6
local s2 = sum(4, 5, 6, 7, 8) -- s2 为 30
local s3 = sum() -- s3 为 0

-- 定义一个名为 concat 的函数，接受变长参数，返回它们的连接
function concat(...)
  local args = {...} -- 将变长参数转换成一个表
  local result = ""
  for i, v in ipairs(args) do -- 遍历表中的所有参数
    result = result .. tostring(v) -- 将参数转换成字符串并连接
  end
  return result
end

-- 调用 concat 函数，传递任意个数的参数，接收一个返回值
local c

---

4.表（Table）

代码如下（示例）：

-- 在 Lua 中，表（table）是唯一的数据结构，可以用来模拟数组，字典，集合等
-- 表使用 {} 来创建，可以包含任意类型的值，使用 [] 来访问元素

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

-- 使用数字索引创建一个数组
local array = {1, 2, 3, 4, 5}
print(array[1]) -- 输出 1

-- 使用字符串索引创建一个字典
local dict = {a = 1, b = 2, c = 3}
print(dict["a"]) -- 输出 1
print(dict.b) -- 输出 2，也可以使用 . 来访问

-- 使用表来模拟集合
local set = {apple = true, banana = false}
print(set["apple"]) -- 输出 true
print(set["banana"]) -- 输出 false

-- 表也可以包含函数，用来模拟对象的方法
local obj = {
  value = 0,
  add = function(self, x)
    self.value = self.value + x
  end
}
obj:add(5)
print(obj.value) -- 输出 5

5.模块和包

代码如下（示例）：

-- Lua 支持模块和包，可以将代码组织成可重用的单元
-- 可以使用 require 函数来加载一个模块，模块可以是一个文件或者一个预编译的 C 语言库

-- 创建一个名为 mymodule 的 Lua 文件，内容如下
-- mymodule.lua
local M = {}

function M.add(x, y)
  return x + y
end

return M

-- 在另一个 Lua 文件中，使用 require 来加载 mymodule
local mymodule = require("mymodule")
print(mymodule.add(10, 20)) -- 输出 30

---

三、总结

Lua 是一种简单而强大的脚本语言，它的设计哲学是提供足够的功能来支持通用编程，同时保持小巧和易学。Lua 的表（table）是一个非常灵活的数据结构，可以用来实现各种复杂的数据模型。Lua 的函数支持高阶函数和闭包，使得函数式编程成为可能。Lua 的模块和包机制可以帮助我们更好地组织代码，提高代码的可维护性和可重用性。