Lua 5.1 中的 __call 元方法实际上是如何工作的？

Question

作为练习，我正在尝试在 Lua 中进行一组实现。具体来说，我想采用 Pil2 11.5 的简单集实现，并将其扩展为包括插入值、删除值等的功能。

现在执行此操作（以及工作方式）的明显方法是：

Set = {}
function Set.new(l)
    local s = {}
    for _, v in ipairs(l) do
        s[v] = true
    end
    return s
end
function Set.insert(s, v)
    s[v] = true
end

ts = Set.new {1,2,3,4,5}
Set.insert(ts, 5)
Set.insert(ts, 6)

for k in pairs(ts) do
    print(k)
end

正如预期的那样，我得到打印出数字 1 到 6。但那些对 Set.insert(s, value) 的调用确实相当难看。我更愿意能够调用诸如 ts:insert(value) 之类的东西。

我第一次尝试解决这个问题看起来像这样：

Set = {}
function Set.new(l)
    local s = {
        insert = function(t, v)
            t[v] = true
        end
    }
    for _, v in ipairs(l) do
        s[v] = true
    end
    return s
end

ts = Set.new {1,2,3,4,5}
ts:insert(5)
ts:insert(6)

for k in pairs(ts) do
    print(k)
end

在您看到它的结果之前，它基本上工作正常：

1
2
3
4
5
6
insert

非常明显，正在显示插入函数，它是设置表的成员。这不仅比原来的 Set.insert(s, v) 问题更难看，而且还容易出现一些严重的问题（例如，如果“insert”是某人试图输入的有效密钥，会发生什么情况） ？）。又到了该看书的时候了。如果我尝试这样做会发生什么？：

Set = {}
function Set.new(l)
    local s = {}
    setmetatable(s, {__call = Set.call})
    for _, v in ipairs(l) do
        s[v] = true
    end
    return s
end
function Set.call(f)
    return Set[f]
end
function Set.insert(t, v)
    t[v] = true
end

ts = Set.new {1,2,3,4,5}
ts:insert(5)
ts:insert(6)

for k in pairs(ts) do
    print(k)
end

现在我阅读此代码的方式是：

• 当我调用 ts:insert(5) 时，事实上 insert 不会t存在被调用意味着将在ts元表中搜索<​​code>“__call”。
• ts 元表的 "__call" 键返回 Set.call。
• 现在使用名称 insert 调用 Set.call，这会导致它返回 Set.insert 函数。
• 调用Set.insert(ts, 5)。

真正发生的事情是这样的：

lua: xasm.lua:26: attempt to call method 'insert' (a nil value)
stack traceback:
        xasm.lua:26: in main chunk
        [C]: ?

此时我被难住了。我完全不知道从这里该去哪里。我花了一个小时对这段代码进行了不同程度的、越来越绝望的变体，但最终结果是我没有任何工作。此时我忽略了哪些无疑显而易见的事情？

Answer 1

现在我阅读这段代码的方式是：

• 当我调用 ts:insert(5) 时，insert 不存在可被调用的事实意味着将在 ts 元表中搜索“__call”。

这就是你的问题。当表本身被调用（即，作为一个函数）时，__call元方法被查询：

local ts = {}
local mt = {}

function mt.__call(...)
    print("Table called!", ...)
end

setmetatable(ts, mt)

ts() --> prints "Table called!"
ts(5) --> prints "Table called!" and 5
ts"String construct-call" --> prints "Table called!" and "String construct-call"

Lua中面向对象的冒号调用，如下所示：

ts:insert(5)

仅仅是语法糖

ts.insert(ts,5)

它本身就是语法糖

ts["insert"](ts,5)

，因此，对 ts 采取的操作不是调用，而是一个索引（ts["insert"] 的结果 被称为），它由 __index 元方法控制。

__index 元方法可以是一个表，用于您希望索引“回退”到另一个表的简单情况（请注意，它是 __index 键的值）被索引的元表，而不是元表本身）：

local fallback = {example = 5}
local mt = {__index = fallback}
local ts = setmetatable({}, mt)
print(ts.example) --> prints 5

作为函数的 __index 元方法的工作方式与您期望的 Set.call 签名类似，只是它传递的表是在键之前建立索引：

local ff = {}
local mt = {}

function ff.example(...)
  print("Example called!",...)
end

function mt.__index(s,k)
  print("Indexing table named:", s.name)
  return ff[k]
end

local ts = {name = "Bob"}
setmetatable(ts, mt)
ts.example(5) --> prints "Indexing table named:" and "Bob",
              --> then on the next line "Example called!" and 5

有关元表的更多信息，请参阅手册。

Answer 2

你说：

现在我阅读这段代码的方式是：

• 当我调用 ts:insert(5) 时，事实上 insert 并没有
  存在被调用意味着 ts 元表正在运行
  搜索“__call”。
• ts 元表的“__call”键返回 Set.call。
• 现在使用名称 insert 调用 Set.call ，这会导致
  它返回 Set.insert 函数。
• 调用 Set.insert(ts, 5)。

不，发生的情况是这样的：

• 当在 ts 对象中没有直接找到 insert 时，Lua 会在其元表中查找 __index。
  • 如果它在那里并且是一个表，Lua 将在那里搜索insert。
  • 如果它存在并且是一个函数，它将使用原始表（本例中为 ts）和正在搜索的键（insert）来调用它.
  • 如果不存在（在这种情况下），则将其视为nil。

您遇到的错误是因为您没有在元表中设置 __index ，因此您实际上是在调用 nil 值。

如果您要将方法存储在其中，可以通过将 __index 指向某个表（即 Set）来解决这个问题。

至于__call，它用于将对象作为函数调用时。 IE：

Set = {}
function Set.new(l)
    local s = {}
    setmetatable(s, {__index=Set, __call=Set.call})
    for _, v in ipairs(l) do
        s[v] = true
    end
    return s
end
function Set.call(s, f)
    -- Calls a function for every element in the set
    for k in pairs(s) do
        f(k)
    end
end
function Set.insert(t, v)
    t[v] = true
end

ts = Set.new {1,2,3,4,5}
ts:insert(5)
ts:insert(6)

ts(print) -- Calls getmetatable(ts).__call(ts, print),
          -- which means Set.call(ts, print)

-- The way __call and __index are set,
-- this is equivalent to the line above
ts:call(print)

Answer 3

Set = {}
function Set.new(l)
    local s = {}
    setmetatable(s, {__index=Set})
    for _, v in ipairs(l) do
        s[v] = true
    end
    return s
end
function Set.call(f)
    return Set[f]
end
function Set.insert(t, v)
    t[v] = true
end

ts = Set.new {1,2,3,4,5}
ts:insert(5)
ts:insert(6)

for k in pairs(ts) do
    print(k)
end

Answer 4

我修改了您的第一个版本，该版本将提供我认为您正在寻找的功能。

Set = {}
Set.__index = Set 

function Set:new(collection)
  local o = {}
  for _, v in ipairs(collection) do
    o[v] = true
  end 
  setmetatable(o, self)
  return o
end

function Set:insert(v)
  self[v] = true
end

set = Set:new({1,2,3,4,5})
print(set[1]) --> true
print(set[10]) --> nil
set:insert(10)
print(set[10]) --> true