如何在不创建元表外代理索引的情况下记录Lua嵌套表读写操作

我之前找到一种给原表设置代理的方法，但打印原表时会显示t["proxy"]，不符合需求。我想要实现支持嵌套表的日志代理功能，类似下面这种单级代理的逻辑，但要能处理嵌套表：

local Settings = {}
Settings.example = "Value"

local proxyTable = setmetatable({}, {
    __index = Settings,
    
    __newindex = function(t, k, v)
        print(t, k, v)
        
        Settings[k] = v
    end,
})

proxyTable.example = "value"

我自己尝试了下面的实现，但不确定是否正确：

local table1 = {
    table2 = {}
}

local function newProxy(tbl)
    local mt = {}
    mt.__index = tbl
    
    mt.__newindex = function(t, k, v)
        print(t, k, v)

        if (type(v) == "table") then
            v = newProxy(v)
        end

        rawset(t,k,v)
    end
    
    local newProxy = setmetatable(tbl, mt)
    return newProxy
end

local proxyTable = setmetatable({},{
    __index = table1,

    __newindex = function(t, k, v)
        print(t, k, v)

        if (type(v) == "table") then
            v = newProxy(v)
        end

        rawset(t,k,v)
    end,
})

for k,v in pairs(table1) do
    if (type(v) == "table") then
        v = newProxy(v)
    end
    
    rawset(proxyTable, k, v)
end

proxyTable.table2.a = {val = "value"}
proxyTable.table2.a.b = {a="a"}
proxyTable.table2.a.b.c = "hi"

for k,v in pairs(proxyTable) do
    print(k,v)
end

这里遇到的问题是：如果把newProxy里的setmetatable(tbl, mt)改成setmetatable({}, mt)，执行proxyTable.table2.a.b = {a="a"}时，之前设置的proxyTable.table2.a = {val = "value"}会被重置为空表。

我想确认两个点：

1. 我的方案是否仍属于代理实现？
2. 使用setmetatable(tbl, mt)是否违背了需求初衷？因为我认为只需要让proxyTable作为table1的代理就够了。

解答 #

1. 你的方案属于代理实现，但存在缺陷 #

你的代码确实是一种代理实现，但不是隔离式代理——它直接修改了原表（table1以及它的子表）的元表，相当于把原表本身变成了代理的一部分，而不是创建一个完全独立的代理对象来包裹原表。

2. setmetatable(tbl, mt)确实违背了“仅proxyTable作为table1代理”的初衷 #

你的需求是让proxyTable作为table1的代理，原表应该保持“纯净”，不被修改元表。但你现在的newProxy函数直接给原表（比如table1.table2）设置了元表，这会导致原表本身带上代理的行为，后续直接操作原表也会触发日志打印，这显然不是你想要的。

正确的嵌套代理实现思路 #

要实现隔离式的嵌套代理，应该让每个代理都是独立的空表，元表的__index指向原表，__newindex负责同步修改到原表并创建子代理，同时读取子表时返回对应的代理而不是原表：

local function createNestedProxy(original)
    local proxy = {}
    local mt = {
        __index = function(_, key)
            local val = original[key]
            -- 如果值是表，返回它的代理而不是原表
            if type(val) == "table" then
                val = createNestedProxy(val)
                -- 缓存代理，避免重复创建
                rawset(proxy, key, val)
            end
            return val
        end,
        __newindex = function(_, key, val)
            print("修改:", key, val)
            -- 如果赋值的是表，先创建它的代理
            if type(val) == "table" then
                val = createNestedProxy(val)
            end
            -- 同步修改到原表
            original[key] = val
            -- 缓存到代理中
            rawset(proxy, key, val)
        end
    }
    setmetatable(proxy, mt)
    return proxy
end

-- 测试代码
local table1 = {
    table2 = {}
}

local proxyTable = createNestedProxy(table1)

proxyTable.table2.a = {val = "value"}
proxyTable.table2.a.b = {a="a"}
proxyTable.table2.a.b.c = "hi"

-- 打印代理内容
for k, v in pairs(proxyTable) do
    print(k, v)
end

-- 直接操作原表不会触发日志，符合隔离需求
table1.table2.a.b.c = "hello"

这个实现的核心特点：

• 代理是独立于原表的空表，不会修改原表的元表
• 读取原表中的子表时，自动创建子代理并缓存，避免重复创建
• 修改操作会同步到原表，同时触发日志
• 直接操作原表不会触发代理逻辑，保持原表的纯净性

内容的提问来源于stack exchange，提问作者karl-police