Lua 迭代器

迭代器（iterator）是一种对象，它能够用来遍历标准模板库容器中的部分或全部元素，每个迭代器对象代表容器中的确定的地址。

在 Lua 中迭代器是一种支持指针类型的结构，它可以遍历集合的每一个元素。

泛型 for 迭代器

泛型 for 在自己内部保存迭代函数，实际上它保存三个值：迭代函数、状态常量、控制变量。

泛型 for 迭代器提供了集合的 key/value 对，语法格式如下：

  1. for k, v in pairs(t) do
  2.     print(k, v)
  3. end

上面代码中，k, v为变量列表；pairs(t)为表达式列表。

查看以下实例:

实例

  1. array = {"Google", "Jishuchi"}
  3. for key,value in ipairs(array) 
  4. do
  5.    print(key, value)
  6. end

以上代码执行输出结果为：

  1. 1  Google
  2. 2  Jishuchi

以上实例中我们使用了 Lua 默认提供的迭代函数 ipairs。

下面我们看看泛型 for 的执行过程：

  • 首先，初始化，计算 in 后面表达式的值，表达式应该返回泛型 for 需要的三个值：迭代函数、状态常量、控制变量；与多值赋值一样，如果表达式返回的结果个数不足三个会自动用 nil 补足，多出部分会被忽略。
  • 第二，将状态常量和控制变量作为参数调用迭代函数（注意：对于 for 结构来说，状态常量没有用处，仅仅在初始化时获取他的值并传递给迭代函数）。
  • 第三，将迭代函数返回的值赋给变量列表。
  • 第四，如果返回的第一个值为nil循环结束，否则执行循环体。
  • 第五，回到第二步再次调用迭代函数

在Lua中我们常常使用函数来描述迭代器，每次调用该函数就返回集合的下一个元素。Lua 的迭代器包含以下两种类型：

  • 无状态的迭代器
  • 多状态的迭代器

无状态的迭代器

无状态的迭代器是指不保留任何状态的迭代器，因此在循环中我们可以利用无状态迭代器避免创建闭包花费额外的代价。

每一次迭代，迭代函数都是用两个变量（状态常量和控制变量）的值作为参数被调用，一个无状态的迭代器只利用这两个值可以获取下一个元素。

这种无状态迭代器的典型的简单的例子是 ipairs，它遍历数组的每一个元素。

以下实例我们使用了一个简单的函数来实现迭代器，实现 数字 n 的平方：

实例

  1. function square(iteratorMaxCount,currentNumber)
  2.    if currentNumber<iteratorMaxCount
  3.    then
  4.       currentNumber = currentNumber+1
  5.    return currentNumber, currentNumber*currentNumber
  6.    end
  7. end
  9. for i,n in square,3,0
  10. do
  11.    print(i,n)
  12. end

以上实例输出结果为：

  1. 1    1
  2. 2    4
  3. 3    9

迭代的状态包括被遍历的表（循环过程中不会改变的状态常量）和当前的索引下标（控制变量），ipairs 和迭代函数都很简单，我们在 Lua 中可以这样实现：

  1. function iter (a, i)
  2.     i = i + 1
  3.     local v = a[i]
  4.     if v then
  5.        return i, v
  6.     end
  7. end
  9. function ipairs (a)
  10.     return iter, a, 0
  11. 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 内，所以迭代函数通常不需要第二个参数。

以下实例我们创建了自己的迭代器：

实例

  1. array = {"Google", "Jishuchi"}
  3. function elementIterator (collection)
  4.    local index = 0
  5.    local count = #collection
  6.    -- 闭包函数
  7.    return function ()
  8.       index = index + 1
  9.       if index <= count
  10.       then
  11.          --  返回迭代器的当前元素
  12.          return collection[index]
  13.       end
  14.    end
  15. end
  17. for element in elementIterator(array)
  18. do
  19.    print(element)
  20. end

以上实例输出结果为：

  1. Google
  2. Jishuchi

以上实例中我们可以看到，elementIterator 内使用了闭包函数，实现计算集合大小并输出各个元素。

pairs 和 ipairs区别

  • pairs: 迭代 table，可以遍历表中所有的 key 可以返回 nil
  • ipairs: 迭代数组，不能返回 nil,如果遇到 nil 则退出

实例

  1. local tab= { 
  2. [1] = "a", 
  3. [3] = "b", 
  4. [4] = "c" 
  5. } 
  6. for i,v in pairs(tab) do        -- 输出 "a" ,"b", "c"  ,
  7.     print( tab[i] ) 
  8. end 
  10. for i,v in ipairs(tab) do    -- 输出 "a" ,k=2时断开 
  11.     print( tab[i] ) 
  12. end

pairs 和 ipairs异同

同：都是能遍历集合（表、数组）

异：ipairs 仅仅遍历值，按照索引升序遍历，索引中断停止遍历。即不能返回 nil,只能返回数字 0，如果遇到 nil 则退出。它只能遍历到集合中出现的第一个不是整数的 key。

pairs 能遍历集合的所有元素。即 pairs 可以遍历集合中所有的 key，并且除了迭代器本身以及遍历表本身还可以返回 nil。

实例1

  1. local tabFiles = {
  2.         [1] = "test2",
  3.         [6] = "test3",
  4.         [4] = "test1"
  5.     }
  7. for k, v in ipairs(tabFiles) do    --输出"test2",在key等于2处断开
  8.     print(k, v)
  9. end

实例2

  1. local tabFiles = {
  2.     [2] = "test2",
  3.     [6] = "test3",
  4.     [4] = "test1"
  5. }
  7. for k, v in ipairs(tabFiles) do  --[[什么都没输出，为什么？因为控制变量初始值是按升序来遍历的，当key为1时，value为nil，此时便停止了遍历， 所有什么结果都没输出]]--
  8.     print(k, v)
  9. end

实例3

  1. local tabFiles = {
  2.     [2] = "test2",
  3.     [6] = "test3",
  4.     [4] = "test1"
  5. }
  7. for k, v in pairs(tabFiles) do  --输出2 test2, 6 test3, 4 test1
  8.     print(k, v)
  9. end

实例4

  1. local tabFiles = {"alpha", "beta", [3] = "no", ["two"] = "yes"}  for i,v in ipairs(tabFiles ) do    --输出前三个   备注：因为第四个key不是整数
  2.     print( tabFiles [i] )   
  3. end   
  5. for i,v in pairs(tabFiles ) do    --全部输出   
  6.     print( tabFiles [i] )   
  7. end

字符串分割函数

  1. function split(str,delimiter)
  2.     local dLen = string.len(delimiter)
  3.     local newDeli = ''
  4.     for i=1,dLen,1 do
  5.         newDeli = newDeli .. "["..string.sub(delimiter,i,i).."]"
  6.     end
  8.     local locaStart,locaEnd = string.find(str,newDeli)
  9.     local arr = {}
  10.     local n = 1
  11.     while locaStart ~= nil
  12.     do
  13.         if locaStart>0 then
  14.             arr[n] = string.sub(str,1,locaStart-1)
  15.             n = n + 1
  16.         end
  18.         str = string.sub(str,locaEnd+1,string.len(str))
  19.         locaStart,locaEnd = string.find(str,newDeli)
  20.     end
  21.     if str ~= nil then
  22.         arr[n] = str
  23.     end
  24.     return arr
  25. end    
  26. t = split("php,js", ",")
  27. for k, v in pairs(t) do
  28.     print(k, v)
  29. end

执行输出结果为：

  1. 1 php
  2. 2 js