Lua中如何检测嵌套表及其所有子表的任意修改操作

实现原理 #

你之前仅对最外层表设置了代理，访问到内层原生子表后，后续修改操作直接作用在原生表上，自然无法触发回调。解决方案是递归为所有嵌套表（包括原表内置的子表、后续新赋值的子表）统一包裹代理层，所有修改操作都会经过代理的__newindex元方法，从而触发回调。

完整实现代码 #

local function create_tracked_table(original, callback)
    -- 代理缓存，避免同一个表重复生成代理
    local proxy_cache = {}

    -- 递归生成代理，支持路径记录
    local function create_proxy(obj, current_path)
        current_path = current_path or ""
        -- 非表类型直接返回原值
        if type(obj) ~= "table" then
            return obj
        end
        -- 已生成过代理的表直接返回缓存
        if proxy_cache[obj] then
            return proxy_cache[obj]
        end

        local proxy = {}
        local mt = {
            __newindex = function(_, key, new_val)
                -- 拼接完整修改路径
                local full_path = current_path == "" and key or current_path .. "." .. key
                -- 新赋值的是表的话先包装成代理
                if type(new_val) == "table" then
                    new_val = create_proxy(new_val, full_path)
                end
                -- 写入原始表
                obj[key] = new_val
                -- 触发回调，传入修改路径、新值，可按需增加旧值等参数
                callback(full_path, new_val)
            end,
            __index = function(_, key)
                local val = obj[key]
                local full_path = current_path == "" and key or current_path .. "." .. key
                -- 访问的是子表，返回包装后的代理
                if type(val) == "table" then
                    return create_proxy(val, full_path)
                end
                return val
            end,
            -- 可选：支持pairs遍历代理表
            __pairs = function()
                return next, obj, nil
            end
        }
        setmetatable(proxy, mt)
        proxy_cache[obj] = proxy
        return proxy
    end

    return create_proxy(original)
end

使用示例 #

-- 你的原始嵌套表
local original_a = {
  b = {
    c = {
      d = 'e'
    }
  },
  f = {
    g = {
      h = {
        i = 'j'
      }
    }
  }
}

-- 定义修改回调，这里可以写你的缓存更新逻辑
local function update_cache(modify_path, new_val)
    print(string.format("检测到路径 %s 被修改为 %s，更新缓存", modify_path, tostring(new_val)))
end

-- 生成监控代理表，后续所有操作都使用这个a，不要直接操作原始表original_a
local a = create_tracked_table(original_a, update_cache)

-- 测试修改，所有操作都会触发回调
a.b = {1,2,3} -- 触发回调，路径为b
a.b.c.d = 'new value' -- 触发回调，路径为b.c.d
a.f.g.h.new_key = 'test' -- 触发回调，路径为f.g.h.new_key

注意事项 #

• a = {xxx}这类直接修改变量引用的操作Lua元表无法拦截，因为这是修改变量本身而不是修改表内容。如果需要监控这类操作，可以把a作为另一个父表的属性，给父表也加上代理即可。
• 不要直接操作原始表，所有修改都要走生成的代理表，否则会出现修改不触发回调、数据不一致的问题。
• 可以根据业务需求调整回调的传参，比如增加旧值、整个表对象等参数，方便缓存更新逻辑处理。

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