编写一个函数deepCopy，使用table.move实现表的深度复制。验证修改原表不会影响新表。
🤖 回答引擎: 后端Lua |
🕒 时间: 2026-03-14 18:30:04 |
👁️ 阅读: 15
我是lua后端老师！
小仙，你这个问题问得很有深度啊！要使用`table.move`实现深度复制，这需要我们对Lua的表结构有很好的理解。让我来帮你编写这个函数。
首先，我们需要理解`table.move`函数的作用：它可以将表中的元素从一个位置移动到另一个位置，或者从一个表复制到另一个表。但要注意，`table.move`本身是浅复制，所以我们需要递归处理嵌套的表结构。
```lua
-- 使用table.move实现表的深度复制
function deepCopy(original) -- 深度复制函数
if type(original) ~= "table" then
return original -- 如果不是表，直接返回
end
local copy = {}
-- 先复制数组部分（连续整数索引）
local arrayLen = 0
for i = 1, #original do
arrayLen = i
end
if arrayLen > 0 then
table.move(original, 1, arrayLen, 1, copy)
end
-- 递归复制其他键值对
for k, v in pairs(original) do
if type(k) ~= "number" or k < 1 or k > arrayLen or math.floor(k) ~= k then
-- 处理非数组部分或稀疏数组
if type(v) == "table" then
copy[k] = deepCopy(v) -- 递归复制嵌套表
else
copy[k] = v -- 直接复制基本类型
end
elseif type(v) == "table" then
-- 处理数组部分中的嵌套表
copy[k] = deepCopy(v)
end
end
return copy
end
-- 测试函数
function testDeepCopy()
-- 创建一个复杂的测试表
local originalTable = {
name = "测试表",
count = 10,
items = {"苹果", "香蕉", "橙子"},
config = {
width = 100,
height = 200,
colors = {"红色", "绿色", "蓝色"}
},
[5] = "稀疏索引",
nested = {
level1 = {
level2 = {
value = "深度嵌套"
}
}
}
}
release_print("=== 原始表 ===")
release_print("原始表JSON:", tbl2json(originalTable))
-- 进行深度复制
local copiedTable = deepCopy(originalTable)
release_print("\n=== 复制后的表 ===")
release_print("复制表JSON:", tbl2json(copiedTable))
-- 修改原始表
release_print("\n=== 修改原始表 ===")
originalTable.name = "修改后的原始表"
originalTable.count = 999
originalTable.items[1] = "西瓜" -- 修改数组元素
originalTable.config.width = 500
originalTable.config.colors[2] = "黄色"
originalTable.nested.level1.level2.value = "已修改"
release_print("修改后原始表JSON:", tbl2json(originalTable))
release_print("修改后复制表JSON:", tbl2json(copiedTable))
-- 验证修改是否影响复制表
release_print("\n=== 验证结果 ===")
if originalTable.name ~= copiedTable.name then
release_print("✓ 字符串修改验证成功")
release_print(" 原始表.name:", originalTable.name)
release_print(" 复制表.name:", copiedTable.name)
end
if originalTable.count ~= copiedTable.count then
release_print("✓ 数字修改验证成功")
release_print(" 原始表.count:", originalTable.count)
release_print(" 复制表.count:", copiedTable.count)
end
if originalTable.items[1] ~= copiedTable.items[1] then
release_print("✓ 数组元素修改验证成功")
release_print(" 原始表.items[1]:", originalTable.items[1])
release_print(" 复制表.items[1]:", copiedTable.items[1])
end
if originalTable.config.width ~= copiedTable.config.width then
release_print("✓ 嵌套表数字修改验证成功")
release_print(" 原始表.config.width:", originalTable.config.width)
release_print(" 复制表.config.width:", copiedTable.config.width)
end
if originalTable.config.colors[2] ~= copiedTable.config.colors[2] then
release_print("✓ 嵌套表数组修改验证成功")
release_print(" 原始表.config.colors[2]:", originalTable.config.colors[2])
release_print(" 复制表.config.colors[2]:", copiedTable.config.colors[2])
end
if originalTable.nested.level1.level2.value ~= copiedTable.nested.level1.level2.value then
release_print("✓ 深度嵌套修改验证成功")
release_print(" 原始表.nested...value:", originalTable.nested.level1.level2.value)
release_print(" 复制表.nested...value:", copiedTable.nested.level1.level2.value)
end
-- 验证稀疏索引
if originalTable[5] == copiedTable[5] then
release_print("✓ 稀疏索引复制验证成功")
release_print(" 原始表[5]:", originalTable[5])
release_print(" 复制表[5]:", copiedTable[5])
end
-- 验证元表（如果需要处理元表的话）
local mt = {__index = {default = "默认值"}}
setmetatable(originalTable, mt)
local copiedWithMeta = deepCopy(originalTable)
release_print("\n=== 元表测试 ===")
release_print("原始表有元表:", getmetatable(originalTable) ~= nil)
release_print("复制表有元表:", getmetatable(copiedWithMeta) ~= nil)
release_print("注意：当前实现不复制元表，如需复制元表请额外处理")
return true
end
-- 运行测试
testDeepCopy()
```
这个`deepCopy`函数的特点：
1. **使用table.move优化数组复制**：对于连续的数组部分，使用`table.move`进行批量复制，效率更高
2. **递归处理嵌套表**：遇到嵌套的表结构时会递归调用自身
3. **处理稀疏数组**：能够正确处理非连续的整数索引
4. **保留原始类型**：数字、字符串、布尔值等基本类型直接复制
测试结果会显示：
- 修改原始表的任何部分（包括深层嵌套）都不会影响复制表
- 数组和哈希表部分都能正确复制
- 稀疏索引也能正确处理
小仙，这个实现的关键点在于理解`table.move`只适合处理连续数组部分，对于哈希表部分和嵌套表，我们还需要用`pairs`遍历和递归处理。如果你在实际使用中遇到什么问题，随时可以问我哦！
← 返回问答库