Lua中对自定义二维表进行添加、修改、计算、删除、判断是否存在操作

引言：

最近刚稍微深入了解一下Lua，正好最近需要用到Lua中对表的操作，于是借助现有的了解实现了对一个简单的二维表进行添加、修改、计算、删除及判断存在的操作

表的创建及相关方法：

1. 创建表及自定义一个迭代器：

--1.当作这是一个操作类/表；该表为一个二维列表，每一个元素代表一个表
--2.每一个元素（表）中包含 id 和 num
operationList = {}

--1.列表元素迭代器，仅返回列表中每一个元素，改列表索引必须为连续的数字
function listIterator(list)
    local index = 0;
    local listLen = #list
    return function ()
        index = index + 1
        if index <= listLen then
            return list[index]
        end
    end
end

2. 向表中添加数据

--1.向操作类/表中添加数据，oId代表标识ID，onum代表值当前值
--2.当 oId 已在列表中存在时，不进行添加操作
--2.当 oId 为nil时，默认为 “1”，当 onum 为nil时，默认为 1
--3.oId 类型为string，oNum 类型为number
--4.添加成功返回 true，失败则返回 false
function operationList:add(oId, oNum)
    if not operationList:exist(oId) then
        table.insert(self, {id = oId or "1", num = oNum or 1})
        return true
    end
    return false
end

3. 修改表中数据

--1.修改operationList指定 ID 的值
--2.oId为指定ID，oNum为修改值，ifNum为指定ID的指定值，oCreate为是否新建值
--2.oId 类型为string，oNum 类型为number，ifNum类型为number，oCreate类型为boolean
--3.当该 ID 不存在时且参数 oCreate = true，则创建
--4.若当前 ID 存在， oNum 为 nil，ifNum 不存在，返回当前 ID 的 num 值
--5.若当前 ID 存在， oNum 不为 nil，ifNum 不存在，则为修改后的 num 值
--6.若当前 ID 存在， oNum 不为 nil，ifNum 存在，则为修改后的 num 值
--7.若当前 ID 存在， oNum 不为 nil，ifNum 不存在，返回当前 ID 的 num 值
--8.若当前 ID 不存在，且 oCreate = false 或 = nil，则返回数字 -1
--9.若当前 ID 不存在，且 ocreate = true，则创建对应 ID 和 num = 1 的新子列，再返回数字 0
function operationList:alter(oId, oNum, ifNum, oCreate)
    if not ifNum then
        for ol in listIterator(operationList) do
            if ol.id == oId then        --若与要修改的ID相同
                if oNum then            --若修改值不为nil
                    ol.num = oNum       --修改值
                end
                return ol.num           --返回当前值，若无修改值，则返回原来的值
            end
        end
    else
        for ol in listIterator(operationList) do
            if ol.id == oId then        --若与要修改的ID相同且 该ID的值 = 判定值
                if  ol.num == ifNum then
                    ol.num = oNum       --修改值
                end
                return ol.num           --返回当前值，若原来的值不等于ifNum的值，则返回原来的值
            end
        end
    end
    if not oCreate then                 --若列表不存在 oId，且 oCreate的值为false
        return -1                       --返回 -1
    end
    operationList:add(oId, 1)           --若列表不存在 oId，且 oCreate的值为true
    return 0                            --返回 0
end

3.1. 修改表略微修改版

--1.修改operationList指定 ID 的值
--2.oId为指定ID，oNum为修改值，ifNum为指定ID的指定值，oCreate为是否新建值
--2.oId 类型为string，oNum 类型为number，ifNum类型为number，oCreate类型为boolean
--3.当该 ID 不存在时且参数 oCreate = true，则创建
--4.若当前 ID 存在， oNum 为 nil，ifNum 不存在，返回当前 ID 的 num 值
--5.若当前 ID 存在， oNum 不为 nil，ifNum 不存在，则为修改后的 num 值
--6.若当前 ID 存在， oNum 不为 nil，ifNum 存在，则为修改后的 num 值
--7.若当前 ID 存在， oNum 不为 nil，ifNum 不存在，则返回 -2
--8.若当前 ID 不存在，且 oCreate = false 或 = nil，则返回数字 -1
--9.若当前 ID 不存在，且 ocreate = true，则创建对应 ID 和 num = 1 的新子列，再返回数字 0
function operationList:alter(oId, oNum, ifNum, oCreate)
    if not ifNum then
        for ol in listIterator(operationList) do
            if ol.id == oId then        --若与要修改的ID相同
                if oNum then            --若修改值不为nil
                    ol.num = oNum       --修改值
                end
                return ol.num           --返回当前值，若无修改值，则返回原来的值
            end
        end
    else
        for ol in listIterator(operationList) do
            if ol.id == oId then        --若与要修改的ID相同且 该ID的值 = 判定值
                if  ol.num == ifNum then
                    ol.num = oNum       --修改值
                    return ol.num       --返回修改后的值
                end
                return -2
            end
        end
    end
    if not oCreate then                 --若列表不存在 oId，且 oCreate的值为false
        return -1                       --返回 -1
    end
    operationList:add(oId, 1)           --若列表不存在 oId，且 oCreate的值为true
    return 0                            --返回 0
end

4. 计算表中值数据

--1.计算operationList指定 ID 的值
--2.oId为指定ID，computeNum为计算值，ifNum为指定ID的指定值，oCreate为是否新建值
--2.oId 类型为string，computeNum 类型为number，ifNum类型为number，oCreate类型为boolean
--3.当该 ID 不存在时且参数 oCreate = true，则创建
--4.若当前 ID 存在， computeNum 为 nil，ifNum 不存在，返回当前 ID 的 num + 1 值
--5.若当前 ID 存在， computeNum 不为 nil，ifNum 不存在，则为修改后的 num + computeNum 值
--6.若当前 ID 存在， computeNum 不为 nil，ifNum 存在，则为修改后的 num + computeNum 值
--7.若当前 ID 存在， computeNum 不为 nil，ifNum 不存在，则返回当前 ID 的 num 值
--8.若当前 ID 不存在，且 oCreate = false 或 = nil，则返回数字 -1
--9.若当前 ID 不存在，且 ocreate = true，则创建对应 ID 和 num = 1 的新子列，再返回数字 0
function operationList:compute(oId, computeNum, ifNum, oCreate)
    if not ifNum then                   --如果相等判定值不存在
        for ol in listIterator(operationList) do
            if ol.id == oId then
                if not computeNum then  --如果计算值为空，那么原值默认 + 1
                    ol.num = ol.num + 1
                else
                    ol.num = ol.num + computeNum    --计算值不为空，那么原值 + 计算值
                end
                return ol.num
            end
        end
    else
        for ol in listIterator(operationList) do
            if ol.id == oId then
                if ol.num == ifNum and computeNum then
                    ol.num = ol.num + computeNum
                end
                return ol.num
            end
        end
    end
    if not oCreate then                 --若列表不存在 oId，且 oCreate的值为false
        return -1                       --返回 -1
    end
    operationList:add(oId, 1)           --若列表不存在 oId，且 oCreate的值为true
    return 0
end

4.1. 计算表略微修改版

--1.计算operationList指定 ID 的值
--2.oId为指定ID，computeNum为计算值，ifNum为指定ID的指定值，oCreate为是否新建值
--2.oId 类型为string，computeNum 类型为number，ifNum类型为number，oCreate类型为boolean
--3.当该 ID 不存在时且参数 oCreate = true，则创建
--4.若当前 ID 存在， computeNum 为 nil，ifNum 不存在，返回当前 ID 的 num + 1 值
--5.若当前 ID 存在， computeNum 不为 nil，ifNum 不存在，则为修改后的 num + computeNum 值
--6.若当前 ID 存在， computeNum 不为 nil，ifNum 存在，则为修改后的 num + computeNum 值
--7.若当前 ID 存在， computeNum 不为 nil，ifNum 不存在，则返回 -2
--8.若当前 ID 不存在，且 oCreate = false 或 = nil，则返回数字 -1
--9.若当前 ID 不存在，且 ocreate = true，则创建对应 ID 和 num = 1 的新子列，再返回数字 0
function operationList:compute(oId, computeNum, ifNum, oCreate)
    if not ifNum then                   --如果相等判定值不存在
        for ol in listIterator(operationList) do
            if ol.id == oId then
                if not computeNum then  --如果计算值为空，那么原值默认 + 1
                    ol.num = ol.num + 1
                else
                    ol.num = ol.num + computeNum    --计算值不为空，那么原值 + 计算值
                end
                return ol.num
            end
        end
    else
        for ol in listIterator(operationList) do
            if ol.id == oId then
                if ol.num == ifNum and computeNum then
                    ol.num = ol.num + computeNum
                    return ol.num
                end
                return -2
            end
        end
    end
    if not oCreate then                 --若列表不存在 oId，且 oCreate的值为false
        return -1                       --返回 -1
    end
    operationList:add(oId, 1)           --若列表不存在 oId，且 oCreate的值为true
    return 0
end

5. 删除指定ID的数据

--1.从表移除指定 ID 的子列
--2.oId 类型为string
--3.移除成功返回 true，失败返回 false（只有当oId不存在时才会失败）
function operationList:remove(oId)
    local removeIndex
    for olI, olV in pairs(operationList) do
        if olV.id == oId then       --如果找到ID，则将对应索引传递给removeIndex
            removeIndex = olI
            break
        end
    end
    if not removeIndex then
        return false
    end
    table.remove(operationList, removeIndex)
    return true
end

6. 判断指定ID是否存在表中

--1.判断指定 ID 在operationList中是否存在
--2.oId 类型为string
function operationList:exist(oId)
    for ol in listIterator(operationList) do
        if ol.id == oId then
            return true
        end
    end
    return false
end

对以上方法进行测试：

1. 测试代码：

--下面是向表operation中插入数据及输出结果
operationList:add("test1", 100)
operationList:add("test2", 200)
operationList:add("test3", 300)
operationList:add("test4")
operationList:add(nil, 500)

--下面是操作表
operationList:remove("test3")                                   --移除数据
print(operationList:exist("11"))                                --判断 ID = 11 的子列是否存在，输出false
print(operationList:exist("1"))                                 --判断 ID = 1 的子列是否存在，输出true
print(tostring(operationList:alter("test3")))                   --通过修改值方法向列表添加新值，输出 -1
print(tostring(operationList:alter("test3", nil, nil, true)))   --通过修改值方法向列表添加新值，输出 0
print(tostring(operationList:alter("1")))                       --获取 ID = 1 的值，因为存在，输出当前 ID 的值
print(tostring(operationList:alter("11")))                      --获取 ID = 11 的值，因为不存在，输出 -1
print(tostring(operationList:alter("test1", 99)))               --修改 ID = test1 的值为 99，因为存在，输出修改后的值
print(tostring(operationList:alter("11", 99)))                  --修改 ID = 11 的值为 99，因为不存在，输出 -1
print(tostring(operationList:alter("test1", 999, 100)))         --修改 ID = test1 且当前值 = 100 的值为 999，因为ID存在 但 值判断值不相同，输出当前值
print(tostring(operationList:alter("test1", 999, 99)))          --修改 ID = test1 且当前值 = 99 的值为 999，因为ID存在 且 值判断值相同，输出修改后的值
print(tostring(operationList:alter("11", 666, 999)))            --修改 ID = 11 且当前值 = 999 的值为 666，因为ID不存在，输出 -1
print(tostring(operationList:compute("1")))                     --计算 ID = 1 的值，其他参数为空，获得原值 + 1
print(tostring(operationList:compute("1", -2)))                 --计算 ID = 1 的值，计算值 = -2，获得原值 - 2
print(tostring(operationList:compute("1", -2, 499)))            --计算 ID = 1 的值，计算值 = -2，且当前值 = 499 获得原值 - 2
print(tostring(operationList:compute("1", nil, 497)))           --计算 ID = 1 的值，计算值 = nil，且当前值 = 497 获得原值
print(tostring(operationList:compute("1", -2, 499)))            --计算 ID = 1 的值，计算值 = -2，但当前值 ~= 499 获得原值
print(tostring(operationList:compute("test6", -2, 499)))        --计算 ID = test6 的值，计算值 = -2，但当前值 ~= 499 且 oCreate = nil ，不创建新子列，获得返回值 -1
print(tostring(operationList:compute("test6", -2, 499, true)))  --计算 ID = test6 的值，计算值 = -2，但当前值 ~= 499 且 oCreate = true 创建新子列，获得返回值 0

--输出列表
print("\n")
for thisoL in listIterator(operationList) do
    print("this ID is "..thisoL.id.."\nthis Num is "..thisoL.num.."\n")
end

2. 测试结果图：

以上就是全部内容了