nav_path: lua

    Lua 是一种轻量级、高效、可嵌入的脚本语言。

    以下是 Lua 的一些主要特点和基本用法：

    1. 基本语法：
    1. -- 这是单行注释
    3. --[[
    4.     这是多行注释
    5. ]]
    7. -- 变量声明（默认为全局变量）
    8. x = 10
    10. -- 局部变量声明
    11. local y = 20
    13. -- 条件语句
    14. if x > y then
    15.     print("x is greater than y")
    16. elseif x < y then
    17.     print("x is less than y")
    18. else
    19.     print("x is equal to y")
    20. end
    22. -- 循环
    23. for i = 1, 5 do
    24.     print(i)
    25. end
    27. -- 函数定义
    28. function greet(name)
    29.     print("Hello, " .. name)
    30. end
    32. greet("Lua")
    1. 数据类型：

    Lua 有 8 种基本数据类型：nil、boolean、number、string、function、userdata、thread 和 table。

    1. -- 表（table）是 Lua 中唯一的复合数据类型
    2. local t = {
    3.     name = "Lua",
    4.     version = 5.4,
    5.     features = {"lightweight", "embeddable"}
    6. }
    8. print(t.name)  -- 访问表中的元素
    1. 面向对象编程：

    Lua 不直接支持类，但可以使用表和元表来模拟面向对象编程。

    1. -- 创建一个简单的类
    2. Person = {name = "", age = 0}
    4. function Person:new(o)
    5.     o = o or {}
    6.     setmetatable(o, self)
    7.     self.__index = self
    8.     return o
    9. end
    11. function Person:introduce()
    12.     print("My name is " .. self.name .. " and I'm " .. self.age .. " years old.")
    13. end
    15. -- 使用类
    16. local p = Person:new({name = "Alice", age = 30})
    17. p:introduce()
    1. 模块：

    Lua 使用 require 函数来加载模块。

    1. -- 在 mymodule.lua 文件中
    2. local M = {}
    4. function M.sayHello()
    5.     print("Hello from module")
    6. end
    8. return M
    10. -- 在主文件中
    11. local mymodule = require("mymodule")
    12. mymodule.sayHello()
    1. 错误处理：
    1. -- 使用 pcall 进行错误处理
    2. local success, result = pcall(function()
    3.     -- 可能会抛出错误的代码
    4.     error("An error occurred")
    5. end)
    7. if success then
    8.     print("Operation succeeded")
    9. else
    10.     print("Error: " .. result)
    11. end
    1. 协程：

    Lua 支持协程，允许非抢占式多任务处理。

    1. local co = coroutine.create(function()
    2.     for i = 1, 3 do
    3.         print("coroutine", i)
    4.         coroutine.yield()
    5.     end
    6. end)
    8. coroutine.resume(co)  -- 输出: coroutine 1
    9. coroutine.resume(co)  -- 输出: coroutine 2
    10. coroutine.resume(co)  -- 输出: coroutine 3

    这些只是 Lua 的基础知识。

    Lua 还有许多高级特性，如元表（metatable）、弱引用表、协程等。由于其轻量级和易嵌入的特性，Lua 常被用于游戏开发、嵌入式系统和配置文件等场景。我们将把内容精简为8章,聚焦于Lua的核心概念和基础应用。以下是精简后的目录:

    Lua - 图1

    详细目录如下:

    1. Lua简介与环境搭建
      1.1 Lua的历史和特点
      1.2 Lua的应用场景
      1.3 安装和配置Lua环境
      1.4 第一个Lua程序
    2. Lua基础语法与数据类型
      2.1 注释和标识符
      2.2 变量和作用域
      2.3 基本数据类型 (nil, boolean, number, string)
      2.4 运算符
      2.5 复杂数据类型简介 (function, table)
    3. 控制结构与函数
      3.1 条件语句 (if-else)
      3.2 循环 (while, repeat-until, for)
      3.3 函数定义和调用
      3.4 参数和返回值
      3.5 闭包和递归
    4. 表与数组
      4.1 表的创建和访问
      4.2 表作为数组
      4.3 表的遍历技巧
      4.4 表操作函数
      4.5 元表基础
    5. 模块与包
      5.1 模块的概念
      5.2 创建和使用模块
      5.3 require函数
      5.4 包的概念和使用
      5.5 模块的加载路径
    6. 面向对象编程
      6.1 使用表实现类
      6.2 方法和self参数
      6.3 继承的实现
      6.4 多态
      6.5 私有成员的模拟
    7. 错误处理与协程
      7.1 错误类型和异常
      7.2 pcall和xpcall函数
      7.3 自定义错误
      7.4 协程的基本概念
      7.5 创建和管理协程
    8. Lua标准库与应用实例
      8.1 字符串库
      8.2 表处理库
      8.3 数学库
      8.4 输入输出库
      8.5 操作系统库
      8.6 实例：配置文件解析
      8.7 实例：简单的文本游戏

    附录A: Lua关键字和符号参考
    附录B: 常见问题解答
    附录C: 进阶学习资源