Lua 迭代器
Lua 迭代器
迭代器（iterator）是一种对象，它能够用来遍历标准模板库容器中的部分或全部元素，每个迭代器对象代表容器中的确定的地址。
在 Lua 中迭代器是一种支持指针类型的结构，它可以遍历集合的每一个元素。
泛型 for 迭代器
泛型 for 在自己内部保存迭代函数，实际上它保存三个值：迭代函数、状态常量、控制变量。
泛型 for 迭代器提供了集合的 key/value 对，语法格式如下：
for k, v in pairs(t) do
print(k, v)
end
上面代码中，k, v为变量列表；pairs(t)为表达式列表。
查看以下实例:
array = {"Google", "Runoob"}
for key,value in ipairs(array)
do
print(key, value)
end
以上代码执行输出结果为：
1 Google
2 Runoob
以上实例中我们使用了 Lua 默认提供的迭代函数 ipairs。
下面我们看看泛型 for 的执行过程：
- 首先，初始化，计算 in 后面表达式的值，表达式应该返回泛型 for 需要的三个值：迭代函数、状态常量、控制变量；与多值赋值一样，如果表达式返回的结果个数不足三个会自动用 nil 补足，多出部分会被忽略。
- 第二，将状态常量和控制变量作为参数调用迭代函数（注意：对于 for 结构来说，状态常量没有用处，仅仅在初始化时获取他的值并传递给迭代函数）。
- 第三，将迭代函数返回的值赋给变量列表。
- 第四，如果返回的第一个值为nil循环结束，否则执行循环体。
- 第五，回到第二步再次调用迭代函数
在Lua中我们常常使用函数来描述迭代器，每次调用该函数就返回集合的下一个元素。Lua 的迭代器包含以下两种类型：
- 无状态的迭代器
- 多状态的迭代器
无状态的迭代器
无状态的迭代器是指不保留任何状态的迭代器，因此在循环中我们可以利用无状态迭代器避免创建闭包花费额外的代价。
每一次迭代，迭代函数都是用两个变量（状态常量和控制变量）的值作为参数被调用，一个无状态的迭代器只利用这两个值可以获取下一个元素。
这种无状态迭代器的典型的简单的例子是 ipairs，它遍历数组的每一个元素。
以下实例我们使用了一个简单的函数来实现迭代器，实现 数字 n 的平方：
实例
function square(iteratorMaxCount,currentNumber)
if currentNumber<iteratorMaxCount
then
currentNumber = currentNumber+1
return currentNumber, currentNumber*currentNumber
end
end
for i,n in square,3,0
do
print(i,n)
end
以上实例输出结果为：
1 1
2 4
3 9
迭代的状态包括被遍历的表（循环过程中不会改变的状态常量）和当前的索引下标（控制变量），ipairs 和迭代函数都很简单，我们在 Lua 中可以这样实现：
function iter (a, i)
i = i + 1
local v = a[i]
if v then
return i, v
end
end
function ipairs (a)
return iter, a, 0
end
当 Lua 调用 ipairs(a) 开始循环时，他获取三个值：迭代函数 iter、状态常量 a、控制变量初始值 0；然后 Lua 调用 iter(a,0) 返回 1, a[1]（除非 a[1]=nil）；第二次迭代调用 iter(a,1) 返回 2, a[2]……直到第一个 nil 元素。
多状态的迭代器
很多情况下，迭代器需要保存多个状态信息而不是简单的状态常量和控制变量，最简单的方法是使用闭包，还有一种方法就是将所有的状态信息封装到 table 内，将 table 作为迭代器的状态常量，因为这种情况下可以将所有的信息存放在 table 内，所以迭代函数通常不需要第二个参数。
以下实例我们创建了自己的迭代器：
array = {"Google", "Runoob"}
function elementIterator (collection)
local index = 0
local count = #collection
-- 闭包函数
return function ()
index = index + 1
if index <= count
then
-- 返回迭代器的当前元素
return collection[index]
end
end
end
for element in elementIterator(array)
do
print(element)
end
以上实例输出结果为：
Google
Runoob
以上实例中我们可以看到，elementIterator 内使用了闭包函数，实现计算集合大小并输出各个元素。
笔记
- pairs 和 ipairs区别
- pairs: 迭代 table，可以遍历表中所有的 key 可以返回 nil
- ipairs: 迭代数组，不能返回 nil,如果遇到 nil 则退出
代码示例：
local tab= {
[1] = "a",
[3] = "b",
[4] = "c"
}
for i,v in pairs(tab) do -- 输出 "a" ,"b", "c" ,
print( tab[i] )
end
for i,v in ipairs(tab) do -- 输出 "a" ,k=2时断开
print( tab[i] )
end
- pairs 和 ipairs异同
- 同：都是能遍历集合（表、数组）
- 异：ipairs 仅仅遍历值，按照索引升序遍历，索引中断停止遍历。即不能返回 nil,只能返回数字 0，如果遇到 nil 则退出。它只能遍历到集合中出现的第一个不是整数的 key。
- pairs 能遍历集合的所有元素。即 pairs 可以遍历集合中所有的 key，并且除了迭代器本身以及遍历表本身还可以返回 nil。
- 例子1：
local tabFiles = {
[1] = "test2",
[6] = "test3",
[4] = "test1"
}
for k, v in ipairs(tabFiles) do --输出"test2",在key等于2处断开
print(k, v)
end
- 例子2：
local tabFiles = {
[2] = "test2",
[6] = "test3",
[4] = "test1"
}
--[[什么都没输出，为什么？因为控制变量初始值是按升序来遍历的，当key为1时，value为nil，此时便停止了遍历， 所有什么结果都没输出]]--
for k, v in ipairs(tabFiles) do
print(k, v)
end
- 例子3：
local tabFiles = {
[2] = "test2",
[6] = "test3",
[4] = "test1"
}
for k, v in pairs(tabFiles) do --输出2 test2, 6 test3, 4 test1
print(k, v)
end
- 例子4：
local tabFiles = {"alpha", "beta", [3] = "no", ["two"] = "yes"} for i,v in ipairs(tabFiles ) do --输出前三个 备注：因为第四个key不是整数
print( tabFiles [i] )
end
for i,v in pairs(tabFiles ) do --全部输出
print( tabFiles [i] )
end
- 字符串分割函数：
function split(str,delimiter)
local dLen = string.len(delimiter)
local newDeli = ''
for i=1,dLen,1 do
newDeli = newDeli .. "["..string.sub(delimiter,i,i).."]"
end
local locaStart,locaEnd = string.find(str,newDeli)
local arr = {}
local n = 1
while locaStart ~= nil
do
if locaStart>0 then
arr[n] = string.sub(str,1,locaStart-1)
n = n + 1
end
str = string.sub(str,locaEnd+1,string.len(str))
locaStart,locaEnd = string.find(str,newDeli)
end
if str ~= nil then
arr[n] = str
end
return arr
end
t = split("php,js", ",")
for k, v in pairs(t) do
print(k, v)
end
执行输出结果为：
1 php
2 js
- 泛型 for 在迭代的时候每次调用的是闭包函数，迭代函数只是开始的时候调用一次。例如:
```lua
function eleiter(t)
local index = 0
--> 每次调用迭代函数都说一句：in eleiter function
print('in eleiter function')
return function()
print('I am here.') --> 每次调用闭包函数都说一句：I am here
index = index + 1
return t[index]
end
end
t = {'one','two','three','four','five'}
for ele in eleiter(t) do
print(ele)
end
```
输出为:
in eleiter function
I am here.
one
I am here.
two
I am here.
three
I am here.
four
I am here.
five
I am here.
- 泛 for 内维持 3 个要素：
- 1.迭代函数本身，如 pairs(tab)
- 2.迭代函数的状态常量，如 tab
- 3.迭代函数的控制变量，如 idx,
- 要求：每次调用一次迭代函数，函数执行过程后改变一次控制变量，但控制变量满足条件后，终止再次调用迭代函数。
- 举例:
function iter (a, i)
i = i + 1
local v = a[i]
if v then
return i, v
end
end
function ipairss (a)
i=0;
while(true) do
k,v=iter(a,i)
if k=nil then
break;
end
end
t={"asdf1","asdf2","asdf3","asdf4"}
//--内部维持iter,t,i三个要素,其中i隐含--这是我的理解
for k,v in ipairss(t) do
print(k,v)
end
end
- 泛 for 中k，v的作用，k作为变量存放索引，v作为变量存放索引对应的值。类似于C语言中的数组索引和数值值的概念。（C语音：a[1]="a"，1是索引，"a"是值）。
- 不论是pairs 还是ipairs都是顺序遍历 t 其中索引存放在k中，对应值放在v中，从1开始。
- 不同的是pairs会遍历所有输出，ipairs遇到nil值中止。下面例子中我用"a"~"d"作为索引，pairs会全部输出。
- ipairs会在一开始，因为t[1]值为nil的情况中止输出。
for k, v in pairs(t) do
print(k, v)
end
local t={}
t["a"]=1
t["b"]=2
t["c"]=3
t["d"]=4
print("pairs:") -- 以pairs输出
for k,v in pairs(t) do
print(k .." , ".. v)
end
print("ipairs:") -- 以ipairs输出
for g,b in ipairs(t) do
print(g .." , ".. b)
end
结果：
pairs:
a , 1
d , 4
c , 3
b , 2
ipairs: