Lua table遍历

工作中，栽了一个“坑”，特此备录。

【1】遍历table1，每次结果可能都不同

-- 获取value
local table_1 = {id="101", name="wang", sage="18", addr="xian"}
for k, v in pairs(table_1) do
    print(k, v)
end

每次结果可能都不同

【2】遍历table2，每次结果相同

 1 local table_2 = {"101", "wang", "18", "xian"}
 2 
 3 print('len2 : ' .. (#table_2))
 4 
 5 local value_idx = {}
 6 for i = 1, #table_2 do
 7     print(i .. ' '.. table_2[i])
 8     table.insert(value_idx, table_2[i])
 9 end
10 print(table.concat(value_idx, ","))
11 
12 for k,v in ipairs(table_2) do
13     print(k, v)
14 end
15 
16 --[[
17 len2 : 4
18 1 101
19 2 wang
20 3 18
21 4 xian
22 101,wang,18,xian
23 1    101
24 2    wang
25 3    18
26 4    xian
27 --]]

每次结果相同

【3】table遍历的方法

经学习，总结一下table遍历的四种方法：

（3.1）利用迭代器pairs的方式

形式如下：

for key, value in pairs(tbtest) do      
    -- TODO  
end

示例如上第一节的实例，不再赘述。

特点：一定会遍历所有的元素，但并非按tbtest中key的排列顺序，而是根据tbtest中key的hash值排列的顺序来遍历的。

（3.2）利用迭代器ipairs的方式

形式如下：

for key, value in ipairs(tbtest) do
    -- TODO 
end

示例如上第二节的实例，另外，再如下：

 1 tbtest = {[1] = 100, [2] = 200, [3] = 300, [5] = 500} 
 2 
 3 for key, value in ipairs(tbtest) do
 4     print('key : ' .. key .. ' value : ' .. value)
 5 end
 6 
 7 --[[
 8 key : 1 value : 100
 9 key : 2 value : 200
10 key : 3 value : 300
11 --]]

特点：必须要求tbtest中的key为顺序的，且必须是从1开始，ipairs只会从1开始按连续的key顺序遍历到key不连续为止。

（3.3）下标索引方式

形式如下：

for i = 1, #(tbtest) do
    -- TODO  
end

示例如上第二节的实例，不再赘述。

特点：只能遍历当tbtest中存在key为1的场景，而且是严格按照key从1开始依次递增1的顺序来遍历，找不到下一个递增是1的key时候就结束遍历，无论后面是否是顺序的key

（3.4）自定义迭代器

形式如下：

function pairsByKeys(t)
    local a = {}  
    for n in pairs(t) do
        a[#a+1] = n  
    end
    table.sort(a)
    local i = 0  
    return function()  
        i = i + 1  
        return a[i], t[a[i]]  
    end  
end

for key, value in pairsByKeys(tbtest) do
    if destKey <= key then
        -- TODO
    end
end

应用场景：

网上有个实际的应用场景，感觉挺应景的。比如，学校按照班级排名顺序给学生发奖金，规则如下：

1.1 排名前4（1,2,3,4）的学生奖励500元

1.2 排名前8（5,6,7,8）的学生奖励300元

1.3 排名前12（9,10,11,12）的学生奖励200元

1.4 排名前16（13,14,15,16）的学生奖励100元

现在，准备给小王发奖金，小王排名第7名，理论应该发奖金是300元。

但是，对比方式（1）和方式（4）的遍历结果如下：

 1 tbtest = {[4] = 500, [8] = 300, [12] = 200, [16] = 100} 
 2 
 3 function pairsByKeys(t)  
 4     local a = {}  
 5     for n in pairs(t) do
 6         print('n : ' .. n)
 7         a[#a+1] = n  
 8     end
 9     table.sort(a)
10     local i = 0  
11     return function()  
12         i = i + 1  
13         return a[i], t[a[i]]  
14     end  
15 end
16 
17 print('-------------方式（3.1）-------------')
18 for k, v in pairs(tbtest) do
19     if 7 <= k then
20         print('pairs : ' .. k .. ' value : ' .. v)
21         break
22     end
23 end
24 
25 print('-------------方式（3.4）-------------')
26 for key, value in pairsByKeys(tbtest) do
27     print('key : ' .. key .. ' value : ' .. value)
28     if 7 <= key then
29         print('pairsByKeys : ' .. key .. ' value : ' .. value)
30         return
31     end
32 end
33 
34 --[[
35 -------------方式（3.1）-------------
36 pairs : 12 value : 200
37 -------------方式（3.4）-------------
38 n : 4
39 n : 12
40 n : 8
41 n : 16
42 key : 4 value : 500
43 key : 8 value : 300
44 pairsByKeys : 8 value : 300
45 --]]

原因分析：因为方式（1）是按照key值的hash值进行遍历的，而不是按照key值的大小顺序进行遍历。

而方式（4）对方式（1）做了改进，先对所有的key值进行了排序，然后再依次遍历，满足预期的效果。

综上所述：方式（4）是对方式（1）的不足进行了弥补，具体应用过程中，根据实际情况，择优选择遍历方法。

 

Good Good Study, Day  Day  Up.

顺序 选择 循环 总结

 

转载于:https://www.cnblogs.com/Braveliu/p/10750574.html