lua

《Lua高级编程》7.1 使用 ffi.cdef 声明 C 函数、结构体与枚举

在跨语言编程中，LuaJIT 的 FFI 模块为 Lua 代码提供了直接调用 C 语言接口的能力，使得在不牺牲开发效率的前提下获得接近原生 C 代码的高性能成为可能。而在 FFI 模块中，ffi.cdef 是最核心的接口之一，它用于在 Lua 中声明 C 语言中的函数原型、数据结构以及枚举类型...

Leeting Yan 14 分钟阅读 6747 字

一、引言

在跨语言编程中，LuaJIT 的 FFI 模块为 Lua 代码提供了直接调用 C 语言接口的能力，使得在不牺牲开发效率的前提下获得接近原生 C 代码的高性能成为可能。而在 FFI 模块中，ffi.cdef 是最核心的接口之一，它用于在 Lua 中声明 C 语言中的函数原型、数据结构以及枚举类型，为后续调用和交互建立起一座桥梁。本文将详细讲解如何使用 ffi.cdef 来声明 C 函数、结构体与枚举，并结合大量实例介绍其使用细节、扩展用法以及常见问题的排查方法，从而帮助开发者准确、高效地在 LuaJIT 环境下进行跨语言开发。

二、ffi.cdef 的基本概念与作用

2.1 ffi.cdef 的定义

ffi.cdef 是 LuaJIT FFI 模块提供的一个函数，其主要作用是将 C 语言的声明（例如函数原型、结构体、枚举、宏定义等）导入到 LuaJIT 内部，使得 LuaJIT 能够识别并操作这些 C 语言中的数据类型和函数。通过这种方式，开发者可以在 Lua 脚本中直接使用这些接口，而无需编写额外的 C 语言包装代码。

例如，通过下面的代码可以声明一个简单的 C 函数和结构体：

local ffi = require("ffi")
ffi.cdef[[
    typedef struct {
        int x;
        int y;
    } Point;

    int add(int a, int b);
]]

在上述声明中，我们利用 ffi.cdef 告诉 LuaJIT，有一个名为 Point 的结构体，其包含两个整型字段 x 和 y；同时还声明了一个名为 add 的函数，其接受两个 int 参数，返回 int 类型结果。

2.2 ffi.cdef 的作用与优势

利用 ffi.cdef 声明 C 接口的主要优势有：

  • 直接性：直接在 Lua 代码中嵌入 C 语言声明，无需编写中间层代码，降低了开发复杂度。
  • 性能优势：由于声明的 C 接口直接映射到底层 C 库，调用时无需经过 Lua C API 的额外包装，从而极大减少了函数调用开销。
  • 灵活性：开发者可以自由声明任意复杂的 C 数据类型（结构体、联合体、枚举等），甚至可以声明函数指针和回调函数，使得跨语言调用更为灵活。
  • 易于维护：所有 C 接口声明集中管理，便于统一更新和维护，同时也可以借助外部工具从 C 头文件自动生成 ffi.cdef 声明，确保接口一致性。

三、使用 ffi.cdef 声明 C 函数

3.1 声明 C 函数的基本语法

在 C 语言中，每个函数都有一个返回值、参数列表以及函数名。在 LuaJIT FFI 中，通过 ffi.cdef 可以将这些信息以字符串的形式描述出来。基本语法格式如下：

ffi.cdef[[
    返回值类型 函数名(参数类型 参数名, ...);
]]

例如，声明一个返回两个整数之和的函数：

ffi.cdef[[
    int add(int a, int b);
]]

这样，LuaJIT 内部就会知道有一个名为 add 的函数，其接受两个 int 类型的参数并返回一个 int 类型的结果。

3.2 声明带有指针参数的函数

在 C 语言中，函数参数常常以指针形式传递。使用 ffi.cdef 声明此类函数时，需要明确指针的类型。示例如下：

ffi.cdef[[
    void process_data(double* data, int length);
]]

上述声明表示有一个名为 process_data 的函数，接受一个指向 double 类型数据的指针和一个整型长度。开发者在 Lua 中调用时，可以使用 ffi.new 创建相应的数据数组，再将其传入函数调用。

3.3 声明返回指针类型的函数

有些 C 函数返回一个指针，表示返回动态分配的内存地址或数据结构。示例如下：

ffi.cdef[[
    const char* get_message();
]]

这里 get_message 函数返回一个指向常量字符数组的指针，通常表示一个字符串。使用 ffi.string 可以将该 C 字符串转换为 Lua 字符串，方便后续使用。

3.4 复杂函数声明示例

对于较复杂的 C 函数，声明时需要准确描述所有参数和返回值的类型。例如，声明一个计算二维数组元素之和的函数：

ffi.cdef[[
    int sum_matrix(const int* matrix, int rows, int cols);
]]

在这个声明中，matrix 参数为指向常量 int 的指针，rows 和 cols 分别表示矩阵的行数和列数。这样的声明需要确保在调用时传入的数据结构与声明完全匹配，否则可能导致内存错误或计算错误。

四、使用 ffi.cdef 声明结构体

4.1 结构体声明的基本语法

在 C 语言中，结构体是一种用户自定义的数据类型，用于组合多个不同类型的数据。通过 ffi.cdef，可以在 LuaJIT 中声明结构体，从而创建和操作这些数据结构。基本语法格式如下：

ffi.cdef[[
    typedef struct {
        类型 字段名;
        类型 字段名;
        ...
    } 结构体名;
]]

例如，声明一个表示二维坐标的结构体：

ffi.cdef[[
    typedef struct {
        int x;
        int y;
    } Point;
]]

这样，LuaJIT 就会知道 Point 结构体包含两个 int 类型的字段 x 和 y，可以通过 ffi.new 创建该结构体的实例。

4.2 结构体内存布局与对齐

在声明结构体时，需要注意内存布局和对齐问题。C 语言编译器通常会根据数据类型的大小和对齐要求，在结构体中插入填充字节。ffi.cdef 声明时应保持与实际 C 语言编译结果一致。若 C 代码中使用了特殊的对齐方式（如 #pragma pack 或 attribute((packed))），在 ffi.cdef 中也应声明相应信息，以确保 LuaJIT 内部结构与实际内存布局一致。例如：

ffi.cdef[[
    typedef struct __attribute__((packed)) {
        char c;
        int i;
    } PackedStruct;
]]

这种声明确保 PackedStruct 结构体不会因对齐而产生额外填充字节。

4.3 嵌套结构体的声明

在实际应用中，结构体往往会嵌套其他结构体。使用 ffi.cdef 时可以分层次进行声明。例如，声明一个表示矩形的结构体，其中包含两个 Point 结构体：

ffi.cdef[[
    typedef struct {
        int x;
        int y;
    } Point;

    typedef struct {
        Point top_left;
        Point bottom_right;
    } Rectangle;
]]

通过这种方式，LuaJIT 能够正确解析嵌套结构体，并允许开发者通过 ffi.new 创建复合结构体。

4.4 指针与结构体结合

在许多 C 函数中，结构体参数常常以指针形式传递。通过 ffi.cdef 声明时，只需指定结构体名称后跟上指针符号。例如：

ffi.cdef[[
    typedef struct {
        int id;
        double value;
    } Data;

    void process_data(Data* d);
]]

在 Lua 中，使用 ffi.new 创建 Data 结构体实例后，可以直接将其传递给 process_data 函数。注意，对于数组或多个结构体，可以使用 ffi.new(“Data[10]”) 进行创建。

4.5 实例演示：声明与操作结构体

以下示例展示了如何声明一个表示点的结构体，并创建其实例：

local ffi = require("ffi")
ffi.cdef[[
    typedef struct {
        int x;
        int y;
    } Point;
]]

-- 创建一个 Point 实例
local pt = ffi.new("Point", { x = 100, y = 200 })
print("Point:", pt.x, pt.y)

-- 修改字段
pt.x = 150
pt.y = 250
print("更新后的 Point:", pt.x, pt.y)

通过上述示例，开发者可以看到 ffi.cdef 如何使得 Lua 中直接使用 C 结构体成为可能。

五、使用 ffi.cdef 声明枚举类型

5.1 枚举的基本概念

枚举（enum）在 C 语言中用于定义一组命名常量，每个枚举成员具有一个整型值。枚举使代码更具可读性，开发者可以使用有意义的名字代替硬编码的数值。利用 ffi.cdef，同样可以在 LuaJIT 中声明枚举，使得 Lua 代码中能够使用这些常量。

5.2 基本语法

声明枚举的基本语法格式如下：

ffi.cdef[[
    typedef enum {
        ENUM_MEMBER1 = 值1,
        ENUM_MEMBER2 = 值2,
        ...
    } EnumType;
]]

例如，声明一个表示颜色的枚举：

ffi.cdef[[
    typedef enum {
        COLOR_RED = 0,
        COLOR_GREEN = 1,
        COLOR_BLUE = 2
    } Color;
]]

上述代码中，定义了 Color 枚举类型，其中 COLOR_RED、COLOR_GREEN 和 COLOR_BLUE 分别对应 0、1、2 三个值。

5.3 枚举的默认赋值规则

在 C 语言中，如果枚举成员未显式赋值，则默认从 0 开始递增。ffi.cdef 同样支持这种默认规则。例如：

ffi.cdef[[
    typedef enum {
        MODE_A,
        MODE_B,
        MODE_C
    } Mode;
]]

在这个声明中，MODE_A 默认值为 0，MODE_B 为 1，MODE_C 为 2。开发者在使用时可以直接引用这些枚举常量。

5.4 枚举的扩展应用

枚举在实际开发中常用于状态码、选项标志、配置项等场景。利用 ffi.cdef 声明枚举后，可以在 Lua 中直接使用这些常量，而不必手动定义。例如，在网络编程中，可以声明一个表示连接状态的枚举：

ffi.cdef[[
    typedef enum {
        CONN_DISCONNECTED = 0,
        CONN_CONNECTING = 1,
        CONN_CONNECTED = 2,
        CONN_ERROR = -1
    } ConnectionStatus;
]]

这样，Lua 代码中可以使用 CONN_CONNECTED 等常量，增强代码可读性和维护性。

5.5 枚举与函数接口结合

枚举常常与 C 函数接口配合使用。例如，一个 C 函数可能根据传入的枚举参数执行不同操作。示例如下：

ffi.cdef[[
    typedef enum {
        OP_ADD,
        OP_SUBTRACT,
        OP_MULTIPLY,
        OP_DIVIDE
    } Operation;

    double calculate(double a, double b, Operation op);
]]

在这种情况下，calculate 函数根据 op 参数的不同进行加、减、乘、除运算。Lua 中调用时，可以直接传入 OP_ADD、OP_SUBTRACT 等枚举常量，从而使代码逻辑更加直观。

六、综合示例：ffi.cdef 声明 C 函数、结构体与枚举的应用

为了更直观地展示 ffi.cdef 的综合用法，下面给出一个综合示例，结合 C 函数、结构体与枚举类型，构建一个简单的数学运算模块。

6.1 需求描述

假设我们有一个 C 库提供了一系列数学运算接口，包括：

  • 一个表示二维向量的结构体 Vector2。
  • 枚举类型 Operation，用于表示加、减、乘、除四种运算。
  • 一个函数 calculate_vector，用于根据指定的运算符计算两个向量的结果。

6.2 ffi.cdef 声明

首先，在 Lua 中使用 ffi.cdef 声明 C 接口，如下所示：

local ffi = require("ffi")

ffi.cdef[[
    // 定义二维向量结构体
    typedef struct {
        double x;
        double y;
    } Vector2;

    // 定义枚举类型 Operation
    typedef enum {
        OP_ADD = 0,
        OP_SUBTRACT,
        OP_MULTIPLY,
        OP_DIVIDE
    } Operation;

    // 声明计算向量的函数
    // calculate_vector 根据 op 运算两个向量的各分量，返回结果存入 result 中
    void calculate_vector(Vector2 a, Vector2 b, Operation op, Vector2* result);
]]

在这个声明中，我们分别声明了 Vector2 结构体、Operation 枚举以及 calculate_vector 函数。注意，在 calculate_vector 函数中，最后一个参数为指向 Vector2 的指针，用于存储运算结果。

6.3 加载动态库

假设我们的动态库名为 “mathops”，则使用 ffi.load 加载动态库：

local mathops = ffi.load("mathops")

确保该库文件位于系统的动态库搜索路径中，或使用绝对路径加载。

6.4 使用 ffi.new 创建结构体实例

利用 ffi.new，我们可以创建 Vector2 结构体的实例：

local v1 = ffi.new("Vector2", { x = 3.0, y = 4.0 })
local v2 = ffi.new("Vector2", { x = 1.0, y = 2.0 })
local result = ffi.new("Vector2")

上述代码创建了两个向量 v1、v2 以及用于存储结果的 result。这样，我们可以将 v1 和 v2 传递给 C 函数进行运算。

6.5 调用 calculate_vector 函数

调用 calculate_vector 函数，并根据 Operation 枚举传入不同的运算符：

-- 调用加法运算
mathops.calculate_vector(v1, v2, ffi.C.OP_ADD, result)
print("加法结果：", result.x, result.y)

-- 调用减法运算
mathops.calculate_vector(v1, v2, ffi.C.OP_SUBTRACT, result)
print("减法结果：", result.x, result.y)

-- 调用乘法运算（假设向量乘法定义为对应分量相乘）
mathops.calculate_vector(v1, v2, ffi.C.OP_MULTIPLY, result)
print("乘法结果：", result.x, result.y)

-- 调用除法运算（假设向量除法定义为对应分量相除）
mathops.calculate_vector(v1, v2, ffi.C.OP_DIVIDE, result)
print("除法结果：", result.x, result.y)

在上述示例中，通过 ffi.C.OP_ADD 等方式引用枚举常量，调用 calculate_vector 函数完成不同运算，并将结果存入 result 中。注意，ffi.C 表示从 C 端导入的全局符号，因此可以直接访问通过 ffi.cdef 声明的枚举常量。

6.6 综合封装为 Lua 模块

为了便于后续使用，可以将所有 ffi.cdef 声明、动态库加载以及常用操作封装为一个独立的 Lua 模块。例如创建文件 mathops_ffi.lua，内容如下：

local ffi = require("ffi")

ffi.cdef[[
    typedef struct {
        double x;
        double y;
    } Vector2;

    typedef enum {
        OP_ADD = 0,
        OP_SUBTRACT,
        OP_MULTIPLY,
        OP_DIVIDE
    } Operation;

    void calculate_vector(Vector2 a, Vector2 b, Operation op, Vector2* result);
]]

local mathops = ffi.load("mathops")

local M = {}

function M.newVector(x, y)
    return ffi.new("Vector2", { x = x or 0, y = y or 0 })
end

function M.calculate(v1, v2, op)
    local result = ffi.new("Vector2")
    mathops.calculate_vector(v1, v2, op, result)
    return result
end

function M.add(v1, v2)
    return M.calculate(v1, v2, ffi.C.OP_ADD)
end

function M.subtract(v1, v2)
    return M.calculate(v1, v2, ffi.C.OP_SUBTRACT)
end

function M.multiply(v1, v2)
    return M.calculate(v1, v2, ffi.C.OP_MULTIPLY)
end

function M.divide(v1, v2)
    return M.calculate(v1, v2, ffi.C.OP_DIVIDE)
end

return M

通过上述封装模块，用户只需 require 此模块，即可直接使用封装好的函数完成向量计算，而无需关心底层 ffi.cdef 的细节。这样的封装不仅提高了代码可维护性，还增强了模块的复用性。

七、常见问题与调试技巧

7.1 声明不匹配问题

在使用 ffi.cdef 声明 C 接口时，常见问题之一就是声明与实际 C 库不匹配。例如：

  • 数据类型错误：例如将 int 错误地声明为 double。
  • 结构体布局不一致：例如 C 语言中使用了不同的对齐方式。
  • 枚举成员名称或数值不一致。

解决方法：

  • 仔细核对 C 头文件，确保 ffi.cdef 中的声明完全一致；
  • 对于结构体对齐问题，可使用 attribute((packed)) 或 #pragma pack；
  • 使用调试工具（如 nm、Dependency Walker）检查动态库中导出的符号，确认符号名称和类型。

7.2 内存管理问题

在使用 ffi.new 创建结构体或数组时，必须注意内存分配和释放。虽然 LuaJIT 会自动管理通过 ffi.new 分配的内存，但当这些内存涉及到底层资源（例如通过 C 库分配的内存）时，开发者需要调用相应的释放函数，否则可能引起内存泄露。

调试技巧：

  • 在不再使用对象时，明确调用 C 库提供的释放函数；
  • 通过监控内存占用情况，检查是否存在内存泄露；
  • 编写单元测试验证对象创建与销毁的正确性。

7.3 调试 ffi.cdef 声明

当调用 ffi.load 或 ffi.new 后出现错误时，常常是由于 ffi.cdef 声明有误。建议：

  • 使用 pcall 捕获错误，并输出详细错误信息；
  • 将 ffi.cdef 声明逐步拆分，逐一验证每个部分是否正确；
  • 利用调试日志记录函数调用前后的状态，确认符号是否正确加载。

例如：

local status, err = pcall(function()
    ffi.cdef[[
        typedef struct {
            int x;
            int y;
        } Point;
    ]]
end)
if not status then
    print("ffi.cdef 声明错误：", err)
end

这种方式有助于快速定位问题所在。

八、最佳实践与扩展建议

8.1 模块化管理

将所有 ffi.cdef 声明统一放入一个或多个模块文件中，便于后续维护和版本控制。例如：

  • 创建一个文件 types.h.lua，专门用于声明所有 C 数据类型；
  • 创建一个文件 funcs.h.lua，声明所有 C 函数接口；
  • 将枚举声明与其他声明分开管理，使得代码结构更清晰。

8.2 版本兼容性

在跨平台和跨版本开发过程中，确保 ffi.cdef 声明与所调用的 C 库版本完全匹配十分重要。建议：

  • 将 C 库的头文件作为参考，定期更新 ffi.cdef 声明；
  • 在动态库加载时检查版本信息，并在加载失败时提供详细提示；
  • 使用自动化工具生成 ffi.cdef 声明，减少手工修改错误。

8.3 性能与安全性

虽然 FFI 提供了高性能接口，但直接操作 C 内存也存在安全风险。建议：

  • 严格验证所有输入数据，防止缓冲区溢出或非法内存访问；
  • 在可能出错的地方使用断言和错误处理代码，确保程序不会因为 C 代码错误而崩溃；
  • 对频繁调用的接口进行性能测试，确保 FFI 调用带来的性能提升符合预期。

8.4 文档与测试

详细的文档和单元测试对于维护 ffi.cdef 声明至关重要。建议：

  • 为每个 ffi.cdef 声明添加详细注释，说明每个类型、函数和枚举的用途和参数；
  • 编写单元测试覆盖所有声明的接口，确保在代码修改后不会引入兼容性问题；
  • 维护一份动态库符号清单，与 ffi.cdef 声明对比检查，确保符号一致。

九、进阶使用技巧

9.1 使用宏定义与内联代码

虽然 ffi.cdef 不直接支持 C 宏，但可以通过常量定义实现类似功能。例如，可以在 C 头文件中将常量定义为枚举成员，或者在 ffi.cdef 中直接写出数值：

ffi.cdef[[
    enum { MAX_BUFFER_SIZE = 1024 };
]]

这样，Lua 代码中就可以使用 ffi.C.MAX_BUFFER_SIZE 表示常量 1024。

9.2 处理复杂数据结构

在声明嵌套、指针、联合体等复杂数据结构时，ffi.cdef 提供了强大的灵活性。例如，声明一个联合体：

ffi.cdef[[
    typedef union {
        int i;
        float f;
        char c[4];
    } MyUnion;
]]

使用联合体时，可以根据需要访问不同字段，充分利用 C 数据结构的优势。

9.3 混合编程与回调机制

利用 ffi.cdef 声明函数指针和回调函数，可以在 Lua 中实现与 C 库的紧密集成。例如，声明一个回调函数类型：

ffi.cdef[[
    typedef int (*callback_t)(int, int);
    void register_callback(callback_t cb);
]]

然后，可以将 Lua 函数转换为 C 回调：

local function my_callback(a, b)
    return a + b
end

local cb = ffi.cast("callback_t", my_callback)
mylib.register_callback(cb)

这种方式使得 Lua 与 C 的混合编程更为灵活。

十、总结

本文详细介绍了如何使用 ffi.cdef 声明 C 函数、结构体与枚举，内容涵盖以下主要部分：

  1. ffi.cdef 的基本概念与作用

    • 介绍了 ffi.cdef 在 LuaJIT FFI 模块中的地位与作用，说明其如何将 C 语言声明导入到 Lua 环境中，为后续跨语言调用奠定基础。

  2. 声明 C 函数

    • 详细说明了如何使用 ffi.cdef 声明简单和复杂的 C 函数，包括带指针参数、返回指针和多参数函数的声明方法，并提供了示例代码。

  3. 声明结构体

    • 分析了结构体声明的基本语法、内存布局、对齐问题及嵌套结构体的声明方法，展示了如何利用 ffi.cdef 创建和操作 C 数据结构，详细举例说明了常见用法。

  4. 声明枚举类型

    • 讲解了枚举的基本概念、默认赋值规则以及如何在 ffi.cdef 中声明枚举常量，讨论了枚举在实际项目中用于状态码、选项标志等场景的应用。

  5. 综合示例

    • 通过一个数学运算模块的综合示例，展示了如何同时声明 C 函数、结构体与枚举，并利用 ffi.load 加载动态库、ffi.new 创建实例、ffi.string 处理 C 字符串，最后封装成 Lua 模块供上层调用。

  6. 常见问题与调试技巧

    • 总结了在使用 ffi.cdef 时可能遇到的符号不匹配、内存管理、结构体对齐和类型转换等常见问题，并提供了调试和排查方法，帮助开发者高效定位和解决问题。

  7. 最佳实践与进阶使用

    • 提出了模块化管理、版本兼容性、性能优化、安全性以及详细文档和单元测试等最佳实践建议，同时介绍了如何利用宏定义、处理复杂数据结构和回调机制进一步提升开发效率。

  8. 跨语言集成与未来展望

    • 强调了 ffi.cdef 在跨语言编程中的重要作用，指出随着 C 库和 LuaJIT 技术不断发展，利用 ffi 进行高性能跨平台开发将成为一种主流趋势，为游戏开发、网络通信、科学计算等领域提供强大支持。

总之，使用 ffi.cdef 声明 C 函数、结构体与枚举是 LuaJIT FFI 模块的核心功能之一，它不仅简化了跨语言编程流程，还大大提升了系统的执行效率。通过掌握本章介绍的基本语法、使用方法、调试技巧和最佳实践，开发者可以在 Lua 项目中灵活调用 C 语言接口，构建出高性能、易维护的跨语言应用系统。希望本文能够为广大开发者提供深入、准确的参考资料，助力他们在实际项目中充分发挥 LuaJIT FFI 的强大功能，实现更高效的开发和更卓越的性能表现。

常见问题解答（FAQ）

以下问题与答案基于本文内容整理，帮助读者快速回顾核心要点。这些结构化问答也有助于搜索引擎与大模型更好地理解文章主题。

Q1: 引言的核心内容是什么？

在跨语言编程中，LuaJIT 的 FFI 模块为 Lua 代码提供了直接调用 C 语言接口的能力，使得在不牺牲开发效率的前提下获得接近原生 C 代码的高性能成为可能。而在 FFI 模块中，ffi.cdef 是最核心的接口之一，它用于在 Lua 中声明 C 语言中的函数原型、数据结构以及枚举类型，为后续调用和交互建立起一座桥梁。本文将详细讲解如何使用 ffi.cdef 来声明 C 函数、结构体与枚举，并结合大量实例介绍其使用细节、扩展用法以及常见问题的排查方法，从而帮助开发者准确、高效地在 LuaJIT 环境下进行跨语言开发。

Q2: 为什么ffi.cdef 的基本概念与作用很重要？

ffi.cdef 是 LuaJIT FFI 模块提供的一个函数，其主要作用是将 C 语言的声明（例如函数原型、结构体、枚举、宏定义等）导入到 LuaJIT 内部，使得 LuaJIT 能够识别并操作这些 C 语言中的数据类型和函数。通过这种方式，开发者可以在 Lua 脚本中直接使用这些接口，而无需编写额外的 C 语言包装代码。

Q3: 如何理解和实践ffi.cdef 的定义？

ffi.cdef 是 LuaJIT FFI 模块提供的一个函数，其主要作用是将 C 语言的声明（例如函数原型、结构体、枚举、宏定义等）导入到 LuaJIT 内部，使得 LuaJIT 能够识别并操作这些 C 语言中的数据类型和函数。通过这种方式，开发者可以在 Lua 脚本中直接使用这些接口，而无需编写额外的 C 语言包装代码。

继续阅读

探索更多技术文章

浏览归档，发现更多关于系统设计、工具链和工程实践的内容。

全部文章 返回首页

「lua」更多文章

  1. 现代 Lua 工具链：LuaLS 类型注解、Stylua 与工程化实践
  2. Unity xLua 实战指南：接入、绑定与热更新全流程
  3. Redis Lua 脚本实战：原子操作、限流与分布式锁