Lua元表基础 - 元素码农

发布时间: 2025-03-24 12:05

↑

# Lua元表基础

本文将介绍Lua中元表（Metatable）的概念和基本用法，帮助你理解这个强大的元编程特性。

## 元表概念

元表（Metatable）是Lua中一个强大的特性，它允许我们修改一个值在面对未知操作时的行为。每个值都可以有一个元表，这个元表定义了原始值的行为。

### 1. 设置和获取元表

```lua
-- 创建一个表
local t = {}

-- 创建元表
local mt = {
    -- 元表定义将在这里
}

-- 设置元表
setmetatable(t, mt)

-- 获取元表
local currentMt = getmetatable(t)
print(currentMt == mt)  -- 输出：true
```

### 2. 元表的工作原理

```lua
-- 示例：使用元表定义加法行为
local vector = {x = 10, y = 20}
local mt = {
    __add = function(v1, v2)
        return {
            x = v1.x + v2.x,
            y = v1.y + v2.y
        }
    end
}
setmetatable(vector, mt)

-- 现在可以对向量进行加法运算
local v2 = {x = 5, y = 10}
local result = vector + v2
print(result.x, result.y)  -- 输出：15 30
```

## 元方法

元方法是定义在元表中的特殊函数，它们定义了表在特定操作下的行为。

### 1. 算术运算元方法

```lua
-- 定义一个复数类
local Complex = {}
Complex.__index = Complex

function Complex.new(real, imag)
    local self = {real = real, imag = imag}
    return setmetatable(self, Complex)
end

-- 定义加法
function Complex.__add(c1, c2)
    return Complex.new(
        c1.real + c2.real,
        c1.imag + c2.imag
    )
end

-- 定义乘法
function Complex.__mul(c1, c2)
    return Complex.new(
        c1.real * c2.real - c1.imag * c2.imag,
        c1.real * c2.imag + c1.imag * c2.real
    )
end

-- 使用示例
local c1 = Complex.new(1, 2)
local c2 = Complex.new(3, 4)
local sum = c1 + c2
local product = c1 * c2
```

### 2. 索引相关元方法

```lua
-- __index元方法
local prototype = {
    speak = function(self)
        return "Hello, " .. self.name
    end
}

local mt = {
    __index = prototype
}

local person = setmetatable({name = "Alice"}, mt)
print(person:speak())  -- 输出：Hello, Alice

-- __newindex元方法
local protected = {}
local mt = {
    __newindex = function(t, key, value)
        error("Cannot modify protected table")
    end
}
setmetatable(protected, mt)
```

## 常用元方法

### 1. __tostring

```lua
-- 自定义对象的字符串表示
local Point = {}
Point.__index = Point

function Point.new(x, y)
    return setmetatable({x = x, y = y}, Point)
end

Point.__tostring = function(p)
    return string.format("Point(%d, %d)", p.x, p.y)
end

local p = Point.new(10, 20)
print(p)  -- 输出：Point(10, 20)
```

### 2. __call

```lua
-- 让表可以像函数一样调用
local Counter = {
    value = 0
}

local mt = {
    __call = function(t)
        t.value = t.value + 1
        return t.value
    end
}

setmetatable(Counter, mt)
print(Counter())  -- 输出：1
print(Counter())  -- 输出：2
```

### 3. __len

```lua
-- 自定义长度计算
local List = {}
List.__index = List

function List.new(...)
    return setmetatable({...}, List)
end

List.__len = function(t)
    local count = 0
    for _ in pairs(t) do
        count = count + 1
    end
    return count
end

local list = List.new(1, 2, 3, nil, 5)
print(#list)  -- 输出：4
```

## 实际应用

### 1. 实现面向对象编程

```lua
-- 创建类
local function createClass(name)
    local class = {}
    class.__index = class
    class.__name = name
    
    -- 构造函数
    function class.new(...)
        local instance = {}
        setmetatable(instance, class)
        if instance.init then
            instance:init(...)
        end
        return instance
    end
    
    return class
end

-- 使用示例
local Animal = createClass("Animal")

function Animal:init(name)
    self.name = name
end

function Animal:speak()
    return "My name is " .. self.name
end

local cat = Animal.new("Kitty")
print(cat:speak())  -- 输出：My name is Kitty
```

### 2. 实现代理模式

```lua
-- 创建代理表
local function createProxy(t)
    local proxy = {}
    
    local mt = {
        __index = function(_, key)
            print("Accessing: " .. tostring(key))
            return t[key]
        end,
        
        __newindex = function(_, key, value)
            print("Setting: " .. tostring(key) .. " = " .. tostring(value))
            t[key] = value
        end
    }
    
    return setmetatable(proxy, mt)
end

-- 使用示例
local data = {x = 10, y = 20}
local proxy = createProxy(data)
print(proxy.x)      -- 输出：Accessing: x\n10
proxy.z = 30        -- 输出：Setting: z = 30
```

### 3. 实现懒加载

```lua
-- 创建懒加载表
local function lazyLoad(loader)
    local data = {}
    local loaded = {}
    
    local mt = {
        __index = function(t, key)
            if not loaded[key] then
                data[key] = loader(key)
                loaded[key] = true
            end
            return data[key]
        end
    }
    
    return setmetatable({}, mt)
end

-- 使用示例
local heavyData = lazyLoad(function(key)
    print("Loading data for: " .. key)
    -- 模拟耗时操作
    return key:upper()
end)

print(heavyData.test)  -- 输出：Loading data for: test\nTEST
```

## 常见问题解答

### Q1: 为什么需要元表？

元表提供了一种机制来自定义表的行为，使得我们可以：
- 实现面向对象编程
- 重载运算符
- 实现代理和懒加载
- 控制表的访问和修改

### Q2: __index和__newindex的区别是什么？

```lua
-- __index用于读取操作
local mt1 = {
    __index = function(t, k)
        return "默认值"
    end
}

-- __newindex用于写入操作
local mt2 = {
    __newindex = function(t, k, v)
        rawset(t, k:upper(), v)
    end
}
```

### Q3: 如何防止元表被修改？

```lua
-- 保护元表
local t = {}
local mt = {}
setmetatable(t, mt)

-- 防止元表被修改
mt.__metatable = "protected"

-- 尝试获取或修改元表
print(getmetatable(t))     -- 输出：protected
setmetatable(t, {})        -- 错误：不能修改受保护的元表
```

## 下一步

现在你已经掌握了Lua元表的基础知识，可以继续学习[操作符重载](/article/lua/advanced/operator-overloading)来了解如何使用元表实现自定义运算符。

## 参考资源

- [Lua 5.4 参考手册 - 元表](http://www.lua.org/manual/5.4/manual.html#2.4)
- [Programming in Lua - 元表和元方法](http://www.lua.org/pil/13.html)
- [Lua元表教程](http://lua-users.org/wiki/MetatableEvents)