《Lua快速入门》9.元编程

January 21, 2025

元编程

1. Lua 的元表机制

1.1 元表的概念

元表（Metatable）是 Lua 中一种特殊的表，用于定义表的自定义行为。通过元表，可以为表添加运算符重载、访问控制等功能。

1.2 设置元表

使用 setmetatable 函数为表设置元表。

1
2
3


local t = {}
local mt = {}
setmetatable(t, mt)

1.3 获取元表

使用 getmetatable 函数获取表的元表。

1

local mt = getmetatable(t)

1.4 元表的默认行为

元表可以定义表的默认行为，例如访问不存在的键时的处理方式。

1
2
3
4
5
6
7


local mt = {
    __index = function(table, key)
        return "Key not found: " .. key
    end
}
setmetatable(t, mt)
print(t["name"])  -- 输出: Key not found: name

2. 使用元方法实现自定义行为

2.1 元方法的概念

元方法是元表中的特殊键，用于定义表的自定义行为。常见的元方法包括：

元方法	描述
`__index`	定义表的索引访问行为。
`__newindex`	定义表的新键赋值行为。
`__add`	定义表的加法操作。
`__sub`	定义表的减法操作。
`__mul`	定义表的乘法操作。
`__div`	定义表的除法操作。
`__tostring`	定义表的字符串表示。
`__call`	定义表的调用行为。
`__len`	定义表的长度操作。

2.2 `__index` 元方法

__index 用于定义表的索引访问行为。当访问表中不存在的键时，会调用 __index 元方法。

1
2
3
4
5
6
7


local mt = {
    __index = function(table, key)
        return "Key not found: " .. key
    end
}
setmetatable(t, mt)
print(t["name"])  -- 输出: Key not found: name

2.3 `__newindex` 元方法

__newindex 用于定义表的新键赋值行为。当向表中赋值一个不存在的键时，会调用 __newindex 元方法。

1
2
3
4
5
6
7


local mt = {
    __newindex = function(table, key, value)
        print("Assigning " .. key .. " = " .. value)
    end
}
setmetatable(t, mt)
t["name"] = "Lua"  -- 输出: Assigning name = Lua

2.4 `__add` 元方法

__add 用于定义表的加法操作。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


local t1 = {value = 10}
local t2 = {value = 20}
local mt = {
    __add = function(a, b)
        return {value = a.value + b.value}
    end
}
setmetatable(t1, mt)
setmetatable(t2, mt)
local t3 = t1 + t2
print(t3.value)  -- 输出: 30

2.5 `__tostring` 元方法

__tostring 用于定义表的字符串表示。

1
2
3
4
5
6
7
8


local t = {name = "Lua", version = "5.4"}
local mt = {
    __tostring = function(table)
        return table.name .. " " .. table.version
    end
}
setmetatable(t, mt)
print(t)  -- 输出: Lua 5.4

2.6 `__call` 元方法

__call 用于定义表的调用行为。

1
2
3
4
5
6
7
8


local t = {}
local mt = {
    __call = function(table, arg)
        print("Called with:", arg)
    end
}
setmetatable(t, mt)
t("Hello")  -- 输出: Called with: Hello

2.7 `__len` 元方法

__len 用于定义表的长度操作。

1
2
3
4
5
6
7
8


local t = {1, 2, 3}
local mt = {
    __len = function(table)
        return #table + 1
    end
}
setmetatable(t, mt)
print(#t)  -- 输出: 4

3. 元表的实际应用

3.1 实现只读表

通过 __index 和 __newindex 元方法，可以实现只读表。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


local function readOnly(table)
    local mt = {
        __index = table,
        __newindex = function(table, key, value)
            error("Attempt to modify read-only table")
        end
    }
    return setmetatable({}, mt)
end

local t = readOnly({name = "Lua"})
print(t.name)  -- 输出: Lua
t.name = "Python"  -- 报错: Attempt to modify read-only table

3.2 实现默认值表

通过 __index 元方法，可以实现默认值表。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


local function defaultTable(default)
    local mt = {
        __index = function(table, key)
            return default
        end
    }
    return setmetatable({}, mt)
end

local t = defaultTable(0)
print(t["name"])  -- 输出: 0

3.3 实现面向对象编程

通过元表，可以实现简单的面向对象编程。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


local Object = {}
function Object:new(o)
    o = o or {}
    setmetatable(o, self)
    self.__index = self
    return o
end

local Person = Object:new()
function Person:greet()
    print("Hello, my name is " .. self.name)
end

local p = Person:new({name = "Alice"})
p:greet()  -- 输出: Hello, my name is Alice

4. 总结

元表是 Lua 中一种强大的元编程工具，通过元表和元方法，可以为表添加自定义行为，实现运算符重载、访问控制、面向对象编程等功能。掌握元表的使用方法，可以帮助开发者编写更加灵活和高效的 Lua 程序。

元编程