工作中，栽了一个“坑”，特此备录。
【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.
顺序 选择 循环 总结