工作中，栽了一个“坑”，特此备录。
【1】遍历table1，每次结果可能都不同
-- 获取value
local table_1 = {id="", name="wang", sage="", addr="xian"}
for k, v in pairs(table_1) do
print(k, v)
end
每次结果可能都不同
【2】遍历table2，每次结果相同
local table_2 = {"", "wang", "", "xian"}
print('len2 : ' .. (#table_2))
local value_idx = {}
for i = , #table_2 do
print(i .. ' '.. table_2[i])
table.insert(value_idx, table_2[i])
end
print(table.concat(value_idx, ","))
for k,v in ipairs(table_2) do
print(k, v)
end
--[[
len2 : 4
1 101
2 wang
3 18
4 xian
101,wang,18,xian
1 101
2 wang
3 18
4 xian
--]]
每次结果相同
【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
示例如上第二节的实例，另外，再如下：
tbtest = {[] = , [] = , [] = , [] = }
for key, value in ipairs(tbtest) do
print('key : ' .. key .. ' value : ' .. value)
end
--[[
key : 1 value : 100
key : 2 value : 200
key : 3 value : 300
--]]
特点：必须要求tbtest中的key为顺序的，且必须是从1开始，ipairs只会从1开始按连续的key顺序遍历到key不连续为止。
（3.3）下标索引方式
形式如下：
for i = , #(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+] = n
end
table.sort(a)
local i =
return function()
i = i +
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）的遍历结果如下：
tbtest = {[] = , [] = , [] = , [] = }
function pairsByKeys(t)
local a = {}
for n in pairs(t) do
print('n : ' .. n)
a[#a+] = n
end
table.sort(a)
local i =
return function()
i = i +
return a[i], t[a[i]]
end
end
print('-------------方式（3.1）-------------')
for k, v in pairs(tbtest) do
if <= k then
print('pairs : ' .. k .. ' value : ' .. v)
break
end
end
print('-------------方式（3.4）-------------')
for key, value in pairsByKeys(tbtest) do
print('key : ' .. key .. ' value : ' .. value)
if <= key then
print('pairsByKeys : ' .. key .. ' value : ' .. value)
return
end
end
--[[
-------------方式（3.1）-------------
pairs : 12 value : 200
-------------方式（3.4）-------------
n : 4
n : 12
n : 8
n : 16
key : 4 value : 500
key : 8 value : 300
pairsByKeys : 8 value : 300
--]]
原因分析：因为方式（1）是按照key值的hash值进行遍历的，而不是按照key值的大小顺序进行遍历。
而方式（4）对方式（1）做了改进，先对所有的key值进行了排序，然后再依次遍历，满足预期的效果。
综上所述：方式（4）是对方式（1）的不足进行了弥补，具体应用过程中，根据实际情况，择优选择遍历方法。
Good Good Study, Day Day Up.
顺序 选择 循环 总结