Lua 语言系列：1.2 metatable 深挖——__index、__newindex 与运算符重载

-- 形态一：__index 指向一张表 → 查不到就去那张表里找
local proto = {kind = "animal", speak = function() return "..." end}
local dog = setmetatable({}, {__index = proto})

print(dog.kind)                  -- 自己没有，去 proto 找
dog.kind = "dog"                 -- 写进自己身上（此时不触发任何元方法）
print(dog.kind, rawget(dog, "kind"))
print(rawget(dog, "speak") == nil)   -- rawget 绕过元表，看真实存储

local bad = setmetatable({}, {
    __index = function(t, k) return t[k] end   -- 致命：t[k] 又会触发 __index
})
print(pcall(function() return bad.x end))

-- 正确写法：用 rawget 自查，避免二次触发
local defaults = {host = "127.0.0.1", port = 6379}
local conf = setmetatable({}, {
    __index = function(t, k)
        local v = rawget(t, k)
        if v ~= nil then return v end
        return defaults[k]          -- 只有自己确实没有，才回退默认值
    end
})
print(conf.host, conf.port)

local log = {}
local t = setmetatable({}, {
    __newindex = function(t, k, v)
        log[#log + 1] = k
        rawset(t, k, v)      -- 必须 rawset，否则值根本不会落进表里
    end
})

t.a = 1     -- 键不存在 → 触发 __newindex
t.a = 2     -- 键已存在（上一步 rawset 过）→ 不触发！
print(#log, table.concat(log, ","))

-- 只读表：读走 __index，写直接报错
local function readonly(t)
    return setmetatable({}, {
        __index = t,
        __newindex = function() error("attempt to modify a read-only table", 2) end
    })
end

local cfg = readonly({host = "localhost"})
print(cfg.host)
print(pcall(function() cfg.host = "x" end))

local defaults = {a = 1, b = 2}
local t = setmetatable({c = 3}, {__index = defaults})

local n = 0
for _ in pairs(t) do n = n + 1 end
print("pairs count:", n)
print("t.a via index:", t.a)

local Vec = {}
Vec.__index = Vec
function Vec.new(x, y) return setmetatable({x = x, y = y}, Vec) end
function Vec.__add(a, b) return Vec.new(a.x + b.x, a.y + b.y) end
function Vec.__tostring(v) return ("Vec(%d, %d)"):format(v.x, v.y) end
function Vec.__len(v) return 2 end                       -- 维度
function Vec.__eq(a, b) return a.x == b.x and a.y == b.y end
function Vec.__lt(a, b)                                  -- 按模长比较
    return (a.x * a.x + a.y * a.y) < (b.x * b.x + b.y * b.y)
end

local a, b = Vec.new(1, 2), Vec.new(10, 20)
print(tostring(a + b))            -- 走 __add
print(a == Vec.new(1, 2))         -- 走 __eq
print(#a)                         -- 走 __len
print(a < b)                      -- 走 __lt

local x = setmetatable({}, {__eq = function() return true end})
local y = setmetatable({}, {__eq = function() return false end})

print("x==y:", x == y)   -- 用 x 的元方法 → true
print("y==x:", y == x)   -- 用 y 的元方法 → false

local z = setmetatable({}, {__eq = function() return true end})
print("z==0:", z == 0)   -- 类型不同，不调用 __eq
print("z==z:", z == z)   -- 同一个对象，原生相等，也不调用

local mt = {}
mt.__index = mt
function mt.__lt(a, b) return a.v < b.v end

local p = setmetatable({v = 1}, mt)
local q = setmetatable({v = 2}, mt)
print("p<q:", p < q)
print("p<=q:", pcall(function() return p <= q end))   -- 只定义了 __lt

local arr = setmetatable({1, 2, 3}, {__len = function() return 99 end})
print("#arr:", #arr)
print("rawlen:", rawlen(arr))

local counter = setmetatable({n = 0}, {
    __call = function(self, step)
        self.n = self.n + (step or 1)      -- 第一个参数就是表自己
        return self.n
    end
})
print(counter(), counter(), counter(10))

local W = {}
function W.__concat(a, b) return tostring(a) .. tostring(b) end
function W.__tostring(t) return t.v end

local w = setmetatable({v = "world"}, W)
print("hello " .. w)      -- a="hello "（字符串），b=w（表）

local account = setmetatable({balance = 100}, {
    __tostring = function(a) return ("Account(balance=%d)"):format(a.balance) end,
    __metatable = "protected"        -- 元表"锁"
})
print(account)
print(getmetatable(account))
print(pcall(setmetatable, account, {}))

-- ① 正常：元表在 setmetatable 时就带 __gc
local mt = {__gc = function(o) print("gc: " .. o.name) end}
local obj = setmetatable({name = "res"}, mt)
obj = nil
collectgarbage("collect")
print("after collect")

-- ② 事后补 __gc：无效！
local late = setmetatable({}, {})
getmetatable(late).__gc = function() print("late gc fired") end
late = nil
collectgarbage("collect")
print("late done")

-- ③ 对象还活着就不会触发
local keep = setmetatable({name = "alive"}, mt)
collectgarbage("collect")
print("still alive:", keep ~= nil)
keep = nil
collectgarbage("collect")
print("released")

local Animal = {}
function Animal:speak() return "..." end

local Dog = setmetatable({}, {__index = Animal})
function Dog:speak() return "woof" end

local Puppy = setmetatable({}, {__index = Dog})
local p = setmetatable({}, {__index = Puppy})

print(p:speak())     -- 沿链往上找：Puppy 没有 → Dog 有 → 用 Dog 的

local Base = {kind = "base"}
Base.__index = Base
local inst = setmetatable({}, Base)
print("before:", inst.kind, rawget(inst, "kind"))
inst.kind = "own"                       -- 只落在实例自身，Base 不受影响
print("after:", inst.kind, rawget(inst, "kind"))