lua中，对table.remove()的改进

^_^内容原创，禁止转载

---

前几天在处理项目某个bug的时候发现代码中使用了ipairs()+table.remove()删除元素，因为历史配置原因，导致这段代码一直没出现错误。lua中，在for循环调用函数ipairs时，ipairs会返回3个值供for保存，迭代函数、不可变状态表、初始控制变量0，for的每次调用，都会把状态表和控制变量传入迭代函数，调用迭代函数，把控制变量+1，再获取状态表中相应元素，并把两者返回，直至遇到nil结束，控制变量不会也不可能因为表的改变而实时刷新；而函数table.remove除了删除、返回指定序列上的元素，还会把后面的元素往前移动。故而知，当表中相邻的两个元素都需要删除的时候，就会发生删除不干净的情况。那像这种情况需要遍历表删除的，该以怎样一种方式去迭代，以达到正确删除元素的目的。首先，如果是无序表，直接把对应位置上的元素置nil；如果是有序表，比较常用的方法有以下3种：

local a = {1, 1, 2, 3, 4, 4}
for i = #a, 1, -1 do
    if a % 2 == 0 then
        table.remove(a, i)
    end
end

local a = {1, 1, 2, 3, 4, 4}
local index = 1
local v = a[index]
while v do
    if v % 2 == 0 then
        table.remove(a, index)
    else
        index = index + 1
    end

    v = a[index]
end

local a = {1, 1, 2, 3, 4, 4}
local tmp = {}
for k, v in ipairs(a) do
    if v % 2 == 0 then
        table.insert(tmp, v)
    end
end
a = tmp

这3种方式都可以实现对表元素的删除，但细想下或许还有更好的方式去实现。首先，回到table.remove()本身，上面说到，table.remove()删除位置上的元素后还会把此位置后面的元素往前移，这里涉及到了一个效率问题。如果是有序表，在某个时刻仅需要删除一个位置上的元素且继续保持有序，table.remove()是必然选择，但是，如果需要遍历表删除，那么选择table.remove()是否会显得有点不够明智？明显地，每一次remove，都移动了后面的元素，而loop+table.remove()，就相当于一步一个脚印的把元素移动到合适的位置，这是一个明显的效率问题。基于此，上面的方式3是否成了最佳选择，其实表的构造也需要时间，虽然基本可以忽略不计，但申请额外的空间来完成删除无论怎样看起来都觉得不太优雅，而且像这种情况不能在新表构造的时候明确具体长度，如果因为原表较大，触发了新表的luaH_resize，即内存重新分配，这也不是我们想看到的情况。那应该以怎样一种方式更好地实现上面loop+table.remove()？

　　在lua中回收一个元素，直接把它置nil即可。于是，对于有序表，是否可以以下面的方式实行替代：

local a = {1, 1, 2, 3, 4, 4}
local index, r_index, length = 1, 1, #a
while index <= length do
    local v = a[index]
    a[index] = nil
    if not (v % 2 == 0) then
        a[r_index] = v
        r_index = r_index + 1
    end

    index = index + 1
end

稍微封装一下：

local tb = {}

function tb.remove(obj, rm_func)
    if type(obj) ~= "table" or type(rm_func) ~= "function" then
        return
    end

    local index, r_index, length = 1, 1, #obj
    while index <= length do
        local v = obj[index]
        obj[index] = nil
        if not rm_func(v) then
            obj[r_index] = v
            r_index = r_index + 1
        end

        index = index + 1
    end
end

return tb

Achieve2彷佛是一种不错的替代loop+table.remove()的方案，既不用在删除元素的时候移动后面的元素，也不需要额外的元素储存空间，时间复杂度妥妥的O(n)，空间复杂度O(1)，下面附上测试代码来看看这几种方式的运行时间对比：

local tb = {}

function tb.remove(obj, rm_func)
    if type(obj) ~= "table" or type(rm_func) ~= "function" then
        return
    end

    local index, r_index, length = 1, 1, #obj
    while index <= length do
        local v = obj[index]
        obj[index] = nil
        if not rm_func(v) then
            obj[r_index] = v
            r_index = r_index + 1
        end

        index = index + 1
    end
end

local a = {}
local b = {}
local c = {}
local d = {}
local length = 1024*128
for i = 1, length do
    a[i] = i
    b[i] = i
    c[i] = i
    d[i] = i
end

rm_func = function(value)
    return value % 2 == 0
end
local start_time = os.clock()

--test-(1.数值型for从后往前遍历)
for i = #a, 1, -1 do
    if rm_func(a[i]) then
        table.remove(a, i)
    end
end
print("1.数值型for从后往前遍历 time:", os.clock() - start_time)

--test-(2.while控制下标方式)
start_time = os.clock()
local index = 1
local v = b[index]
while v do
    if rm_func(v) then
        table.remove(b, index)
    else
        index = index + 1
    end
    
    v = b[index]
end
print("2.while控制下标方式 time:", os.clock() - start_time)

--test-(3.构建临时表方式)
start_time = os.clock()
local tmp = {}
for k, v in ipairs(c) do
    if v % 2 == 0 then
        table.insert(tmp, v)
    end
end
c = tmp
print("3.构建临时表方式 time:", os.clock() - start_time)

--test-(tb.remove)
start_time = os.clock()
tb.remove(d, rm_func)
print("tb.remove time:", os.clock() - start_time)

即使事先知道Achieve2具有更高效率，但看到对比输出，依然为Achieve2感到惊讶，即使是通过构建临时表的方式3依然比Achieve2差了9倍左右，而且毫无疑问方式3内存占用更高；当然，实际测试时间还受到具体环境影响，但是Achieve2比loop+table.remove()效率更高已经可以盖棺定论（对于Achieve2的测试本人进行了不下百次，Achieve2的实现绝对是健康的实现）。

---

　　到这里已经明确Achieve2是更好的替代方案，但是否可以让Achieve2变得更健全一点？如果表是无序表，或者表既有无序部分也有有序部分，当中的元素都需要遍历判断删除怎么办，上述的Achieve2只能用于有序表，就是表的元素只存在于table的数组部分，哈希部分为空的情况下，那么是否能进一步更改Achieve2的实现使适用于所有情况？首先，要明确的是，lua提供的运算符和表标准库函数都只能获取表数组部分长度，对于总体长度，是无法直接获取的，所以不在事先遍历一次表的情况下无法判断一个表到底是有序表还是无序表；其次，要使Achieve2适用所有情况，必须使用pairs()遍历，使用pairs()遍历，具体算法是否依然能把Achieve2的时间复杂度控制在O(n)？

　　详细了解一下函数pairs机制，函数pairs在调用的时候会返回lua的一个基本函数next和不可变状态表t，调用next(t, key)时，该函数会以随机次序返回表中的下一个key及其对应的值；调用next(t, nil)时，返回表中的第一个键值对，所有元素遍历完时，函数next返回nil，for循环结束，for循环总是会把表达式列表的结果调整为3个值，所以，在首次调用pairs()的时候，得到的相当于next, t, nil；next函数的底层lua实现luaH_next中，总是先遍历数组部分，再遍历哈希部分，基于pairs的这些具体行为，我们可以得到Achieve3：

local tb = {}

function tb.remove(obj, rm_func)
    if type(obj) ~= "table" or type(rm_func) ~= "function" then
        return
    end

    local r_index, length = 1, #obj
    for k, v in pairs(obj) do        --lua5.3可以通过math.type(k)判断
        if type(k) == "number" and math.floor(k) == k and k > 0 and k <= length then
            local tmp = v
            obj[k] = nil
            if not rm_func(tmp) then
                obj[r_index] = tmp
                r_index = r_index + 1
            end
        else
            if rm_func(v) then
                obj[k] = nil
            end
        end
    end
end

return tb

Achieve3好像是个不错的实现，但是看着那一堆判断就头疼，那还有没有更好的实现方法，有，就是先手动遍历表数组部分，然后自己实现pairs行为，使只遍历哈希部分，下面是Achieve4：

local tb = {}

function tb.remove(obj, rm_func)
    if type(obj) ~= "table" or type(rm_func) ~= "function" then
        return
    end

    local index, r_index, length = 1, 1, #obj
    while index <= length do
        local v = obj[index]
        obj[index] = nil
        if not rm_func(v) then
            obj[r_index] = v
            r_index = r_index + 1
        end

        index = index + 1
    end

    local function _pairs(tb)
        if length == 0 then
            return next, tb, nil
        else
            return next, tb, length
        end
    end

    for k, v in _pairs(obj) do
        if rm_func(v) then
            obj[k] = nil
        end
    end
end

return tb

但是我们可能会面临着一种具体情况，那就是我们希望在对表的有序部分删除元素后，后面的元素保持不动，于是再度改写Achieve4，得到Achieve5（如果项目中有封装table的操作文件，可以把_pair单独拿出来，这样就不用每次运行都创建一个闭包）：

local tb = {}

function tb.remove(obj, rm_func, to_sequence)
    if type(obj) ~= "table" or type(rm_func) ~= "function" then
        return
    end

    local length = 0
    if to_sequence then
        length = #obj
        local index, r_index = 1, 1
        while index <= length do
            local v = obj[index]
            obj[index] = nil
            if not rm_func(v) then
                obj[r_index] = v
                r_index = r_index + 1
            end

            index = index + 1
        end
    end

    local function _pairs(tb)
        if length == 0 then
            return next, tb, nil
        else
            return next, tb, length
        end
    end

    for k, v in _pairs(obj) do
        if rm_func(v) then
            obj[k] = nil
        end
    end
end

return tb

---

　　好了，到此文章已经差不多结束，上述内容都是本人在工作中的实际见解，纯属原创。这也是本人的第一次写博，水平有限，以后还会继续把自己的经验分享出来，如果有错误和可以改进的地方还请不吝指出。下面附上本人写的一些拓展table函数（主要用于个人测试）：

local tb = {}

--to_sequence可选且只会在表有序部分起作用，时间复杂度O(n)
function tb.remove(obj, rm_func, to_sequence)
    if type(obj) ~= "table" or type(rm_func) ~= "function" then
        return
    end

    local length = 0
    if to_sequence then
        length = #obj
        local index, r_index = 1, 1
        while index <= length do
            local v = obj[index]
            obj[index] = nil
            if not rm_func(v) then
                obj[r_index] = v
                r_index = r_index + 1
            end

            index = index + 1
        end
    end

    local function _pairs(tb) --lua_next实现是迭代完数组部分再迭代哈希部分
        if length == 0 then
            return next, tb, nil
        else
            return next, tb, length
        end
    end

    for k, v in _pairs(obj) do
        if rm_func(v) then
            obj[k] = nil
        end
    end
end

function tb.duplicate(obj)
    local tb_note = {} --使指向行为与原表一致
    local copy_func
    copy_func = function(obj)
        if type(obj) ~= "table" then
            return obj
        elseif tb_note[obj] then
            return tb_note[obj]
        end

        local dup = {}
        tb_note[obj] = dup
        for k, v in pairs(obj) do
            dup[copy_func(k)] = copy_func(v)
        end
        setmetatable(dup, getmetatable(obj))
        return dup
    end

    return copy_func(obj)
end

function tb.tostring(obj)
    local tb_note = {} --防止相同表转换多次
    local function serialize(value)
        if tb_note[value] then
            return tb_note[value]
        elseif type(value) == "number" then
            return string.format("%d", value) --%a
        elseif type(value) == "string" then
            return string.format("%q", value) --5.3.3版本后可以使用%q转化number,nil,boolean
        elseif type(value) == "table" then
            local str = "{"
            local index_tb = tb.getsortedindexlist(value)
            for _, v in ipairs(index_tb) do
                str = str.."["..serialize(v).."]="..serialize(value[v])..","
            end
            local mt = getmetatable(value)
            if mt then str = str.."[\"metatable\"]="..serialize(mt).."," end
            str = str.."}"
            
            tb_note[value] = str
            return str
        else
            return tostring(value)
        end
    end

    return serialize(obj)
end

local type_value = {["number"] = 1, ["string"] = 2, ["userdata"] = 3, ["function"] = 4, ["table"] = 5}
function tb.getsortedindexlist(obj)
    local index_tb = {}
    for k in pairs(obj) do
        table.insert(index_tb, k)
    end

    local sort_func = function(a, b)
        local type_a = type_value[type(a)]
        local type_b = type_value[type(b)]
        if type_a ~= type_b then
            return type_a < type_b
        else
            if type_a == 1 or type_a == 2 then
                return a < b
            elseif type_a == 5 then
                return tb.getlen(a) < tb.getlen(b)
            else
                return false
            end
        end
    end

    table.sort(index_tb, function(a, b) return sort_func(a, b) end)
    return index_tb
end

function tb.getlen(obj)
    local count = 0
    for k, v in pairs(obj) do
        count = count + 1
    end

    return count
end

function tb.show(obj)
    for k, v in pairs(obj) do
        print(k, v)
    end
    local mt = getmetatable(obj)
    if mt then
        print("metatable", mt)
    end
end

return tb