从一个嵌套表格中删除对象

当你将数据读入表中时，将所读数据的索引值作为表中的键值。这避免了冲突，也方便与另一个表进行比较。

local table1 = {}
local table2 = {}

-- 将你的值作为表中的键读入两张表中
-- 这只是一个例子，我不知道你是如何填充表的，但希望有所帮助
table1 = {['input1'] = 0, ['input6'] = 0, ['input3'] = 0}
table2 = {['input1'] = 0, ['input3'] = 0}
newTable = {}

function tableHasKey(table, key)
    return table[key] ~= nil
end

for key, _ in pairs(table1) do
  if not tableHasKey(table2, key) then
    table.insert(newTable, key)
  end
end

for _, value in pairs(newTable) do
  print(value)
end

运行结果为 'input6'。这意味着在 table1 中不在 table2 中的所有值现在都在 newTable 中。如果表之间的值是唯一的，比较键比比较值更容易。最终的结果是一个索引化的表，其中结果存储在哈希对象的值中。

#! /usr/bin/env lua

local table1 = {1,2,3,4,5,6,7,8,9}
local table2 = {2,4,6,8}

for number = 1, #table1 do
    for delete = 1, #table2 do
        if table1[number] == table2[delete] then
            for i = number,  #table1 -1 do
                table1[i] = table1[i +1]
            end  --  洗牌并把表格的每个条目向下移动
            table1 [#table1] = nil  --  删除最后一个条目
        end  --  number == delete
    end  --  循环遍历 table2
end  --  循环遍历 table1

for i = 1, #table1 do print( table1[i] ) end

1

3

5

7

9

以下其他的回答看起来是正确的，但是它们对内存或时间复杂度过于严格。这是一个针对数字列表优化的过滤函数。

--t1：表，原始值集合
--t2：表，从t1删除的值集合
--返回：表，t1中未在t2中找到的元素的子集
local function filter(t1, t2)

    -- 假设：
    -- 1）t1和t2是数组，而不是字典
    -- 2）t1和t2没有混合的索引或值
    -- 3）t1和t2已排序
    assert(type(t1) == "table", "t1应该是一个表")
    assert(type(t2) == "table", "t2应该是一个表")
    assert(type(next(t1)) == "number" or type(next(t1)) == "nil", "t1应该是一个数组")
    assert(type(next(t2)) == "number" or type(next(t2)) == "nil", "t2应该是一个数组")

    -- 提前返回：
    if #t1 == 0 then
        return {}
    elseif #t2 == 0 then
        return t1
    end

    --逐个列表并比较每个索引
    local filteredT = {}

    local i = 1
    local j = 1
    local sizeT1 = #t1
    local sizeT2 = #t2

    while (i <= sizeT1) and (j <= sizeT2) do
        if t1[i] == t2[j] then
            --找到匹配，从输出中排除
            i = i + 1
            j = j + 1

        elseif t1[i] < t2[j] then
            --没有匹配项，将t1的元素添加
            table.insert(filteredT, t1[i])
            i = i + 1

        else --t1[i] > t2[j]
            --没有匹配项，忽略t2的元素
            j = j + 1

        end
    end

    --我们已经到达了其中一个列表的末尾，添加t1的剩余部分
    for i = i, sizeT1, 1 do
        table.insert(filteredT, t1[i])
    end

    return filteredT
end

这个解决方案没有不必要的循环迭代和一些提前返回的优化。

local a = {1,2,3,4,5,6,7,8,9}
local b = {2,4,6,8}
local result1 = filter(a, b)
print(table.concat(result1, ", ")) -- 1, 3, 5, 7, 9

local c = {"a", "b", "c", "d"}
local d = {"c", "d"}
local result2 = filter(c, d)
print(table.concat(result2, ", ")) -- "a", "b"