如何泛化Lua函数以支持N维数组？

好问题！要实现支持任意维度（最多7维）的通用数组操作函数，我们可以利用Lua的可变参数特性和递归遍历，摆脱固定维度函数的重复代码。下面是一套完整的实现方案，包含通用的初始化、值递增和打印功能：

1. 动态解析维度参数：将传入的维度上下界（如i_low,i_high,j_low,j_high）分组，记录每个维度的范围和元素数量。
2. 计算线性索引步长：每个维度的步长等于后续所有维度的元素数乘积，用来将多维坐标转换为一维线性索引（Lua表的天然存储方式）。
3. 递归遍历坐标：用递归代替多层嵌套for循环，不管多少维度都能自动遍历所有可能的坐标组合。
4. 元表存储元数据：把数组的维度信息存在元表里，让数组自身携带维度属性，后续操作无需重复传递维度参数。

-- 辅助函数：解析维度参数，返回维度信息、步长数组和总元素数
local function parseDimensions(...)
    local dims = {}
    local steps = {}
    local total = 1
    -- 每两个参数对应一个维度的low和high
    for i = 1, select('#', ...), 2 do
        local low = select(i, ...)
        local high = select(i+1, ...)
        local size = high - low + 1
        table.insert(dims, {low=low, high=high, size=size})
        -- 先累积后续维度的乘积，最后反转得到正确步长
        steps[#dims] = total
        total = total * size
    end
    -- 验证维度数不超过7维
    assert(#dims <= 7, "最多支持7维数组")
    -- 反转步长数组：第一个维度的步长是后续所有维度的元素数乘积
    local reversed_steps = {}
    for i = #steps, 1, -1 do
        table.insert(reversed_steps, steps[i])
    end
    return dims, reversed_steps, total
end

-- 通用数组初始化函数
-- 参数：数组table, 维度1_low,维度1_high, ..., 维度N_low,维度N_high, 初始值
function initArray(t, ...)
    local args = {...}
    local init_value = table.remove(args) -- 最后一个参数是初始值
    local dims, steps = parseDimensions(unpack(args))
    -- 将维度和步长信息存入元表，方便后续函数调用
    setmetatable(t, {__index = {dims = dims, steps = steps}})
    
    -- 递归遍历所有坐标组合，初始化数组
    local function traverseCoords(coords, current_dim)
        if current_dim > #dims then
            -- 计算线性索引（Lua表索引从1开始）
            local idx = 1
            for i = 1, #coords do
                idx = idx + (coords[i] - dims[i].low) * steps[i]
            end
            t[idx] = init_value
            return
        end
        -- 遍历当前维度的所有可能值
        local current_dim_info = dims[current_dim]
        for val = current_dim_info.low, current_dim_info.high do
            coords[current_dim] = val
            traverseCoords(coords, current_dim + 1)
        end
    end
    traverseCoords({}, 1)
end

-- 通用数组值递增函数
-- 参数：数组table, 坐标1,坐标2,...,坐标N, 增量值
function incrValue(t, ...)
    local args = {...}
    local increment = table.remove(args) -- 最后一个参数是增量
    local dims = getmetatable(t).__index.dims
    local steps = getmetatable(t).__index.steps
    
    -- 验证坐标数量与维度数匹配
    assert(#args == #dims, string.format("坐标数量错误：需要%d个坐标，传入了%d个", #dims, #args))
    
    -- 计算线性索引并验证坐标合法性
    local idx = 1
    for i = 1, #args do
        local coord = args[i]
        local dim_info = dims[i]
        assert(coord >= dim_info.low and coord <= dim_info.high, 
               string.format("第%d个坐标%d超出范围[%d,%d]", i, coord, dim_info.low, dim_info.high))
        idx = idx + (coord - dim_info.low) * steps[i]
    end
    -- 执行递增操作
    t[idx] = t[idx] + increment
end

-- 通用数组打印函数
-- 参数：数组table, 标题
function printArray(t, title)
    local dims = getmetatable(t).__index.dims
    local steps = getmetatable(t).__index.steps
    print(title .. "\n")
    
    -- 递归遍历所有坐标并打印
    local function printCoords(coords, current_dim)
        if current_dim > #dims then
            -- 计算线性索引
            local idx = 1
            for i = 1, #coords do
                idx = idx + (coords[i] - dims[i].low) * steps[i]
            end
            -- 打印坐标和对应值
            for _, coord in ipairs(coords) do
                io.write(coord .. "\t")
            end
            io.write(t[idx] .. "\n")
            -- 最后一个维度遍历完后换行分隔
            if current_dim - 1 == #dims then
                print("\n")
            end
            return
        end
        -- 遍历当前维度的所有值
        local current_dim_info = dims[current_dim]
        for val = current_dim_info.low, current_dim_info.high do
            coords[current_dim] = val
            printCoords(coords, current_dim + 1)
        end
    end
    printCoords({}, 1)
end

-- 二维数组测试
local myArray_two = {}
initArray(myArray_two, 2, 4, 3, 7, 0)
incrValue(myArray_two, 2, 3, 11)
incrValue(myArray_two, 2, 3, 13)
incrValue(myArray_two, 4, 7, 5)
printArray(myArray_two, "A 2-D Array")

-- 三维数组测试
local myArray_three = {}
initArray(myArray_three, 2, 4, 3, 7, 1, 3, 1)
incrValue(myArray_three, 2, 3, 1, 9)
incrValue(myArray_three, 2, 3, 1, 17)
printArray(myArray_three, "A 3-D Array")

-- 四维数组测试（演示扩展能力）
local myArray_four = {}
initArray(myArray_four, 1, 2, 1, 2, 1, 2, 1, 2, 10)
incrValue(myArray_four, 1, 1, 1, 1, 5)
printArray(myArray_four, "A 4-D Array")

• 自动识别维度：通过参数数量自动判断维度数（每两个参数对应一个维度），最多支持7维（可通过修改parseDimensions里的断言调整上限）。
• 简洁调用：初始化后，递增和打印函数无需重复传递维度范围，因为数组元表已经存储了这些信息。
• 健壮性：加入了坐标合法性验证和参数数量检查，避免非法操作导致的错误。
• 可扩展性：如果需要支持更多维度，只需修改parseDimensions中的维度上限断言即可。

内容的提问来源于stack exchange，提问作者DLyons