lua学习之迭代器与泛型for第一篇

迭代器与泛型 for 1

迭代器与 closure

1. 「迭代器」是一种能够遍历一种集合中的全部元素的机制
2. 在 lua 中一般将迭代器表示为函数
3. 每调用一次函数，即返回集合中的「下一个」元素
4. 每一个迭代器都须要在每次成功调用之间保存一些状态
5. 这样就知道它如今所在的位置以及如何步进到一下位置
6. 一个 closure 就是一种能够访问其外部嵌套环境中的局部变量的函数
7. 这些变量可用于在成功调用之间保持状态值
8. 从而使 closure 能够记住它在一次遍历中所在的位置
9. 建立一个 closure 必须建立它的「非局部变量」

10. 一个closure 结构一般包含两个函数

    1. closure 自己
    2. 建立该 closure 的工厂函数

while

1. values 就是工厂，每次调用这个工厂，就会建立一个新的 closure 即迭代器其自己
2. 这个 closure 将它的想要保存在其外部变量 t 和 i 中
3. 每当调用这个迭代器时，它就从列表 t 中返回下一个值
4. 直到最后一个元素返回后，迭代器会返回 nil，表示迭代的结束

function values(t)
    local i = 0
    return function () 
        i = i + 1
        return t[i]
    end
end
t = {123, 333, 444}
iter = values(t) -- 建立迭代器
while true do
    local element = iter() -- 调用迭代器
    if element == nil then
        break
       end
    print(element)
end

泛型 for

1. 泛型 for 记录了每一次迭代循环
2. 它在内部保存了迭代器函数，所以不须要 iter 变量
3. 它在每次新迭代时调用迭代器，并在迭代器返回 nil 时循环结束

function values(t)
    local i = 0
    return function () 
        i = i + 1
        return t[i]
    end
end
t = {123, 333, 444}
-- 泛型 for
t = {123, 333, 444}
for element in values(t) do
    print(element)
end

高级用法

1. 遍历当前输入文件中全部单词的迭代器

2. 须要保持的值

   1. 当前行的内容
   2. 以及该行所处的位置
3. 使用 string.find 在当前行中调用，以当前位置做为起始位置来搜索一个单词
4. 使用模式 %w+ 用来表示一个「单词」， 英语匹配一个或多个文字或数字字符
5. 若是找到了一个单词，迭代器将当前位置更新为该单词以后的第一个字符，并返回该单词
6. 不然，迭代器读取新的一行并重复这个搜索过程
7. 若没有剩余的行，则返回 nil, 以此表示迭代的结束。

-- 编写迭代器
function allwords()
    local line = io.read() -- 当前行
    local pos = 1 -- 一行中的位置
    return function () -- 迭代器函数
       while line do --  只要 line 不为 nil 循环执行
            -- 返回开始位置和结束位置 
            local start, end = string.find(line, "%w+", pos)
            if s then -- 是否找到一个单词
                pos = e + 1 -- 找到一个单词，则移到这个单词的下一个位置
                return string.sub(line, s) -- 返回该单词
            else
                line = io.read() -- 这一行没找到，尝试读取下一行
                pos = 1
            end
       end
       return nil -- 没有剩余行了，遍历结束
    end
end

-- 调用迭代器
for word in allwords() do
    print(word)
end

泛型 for 的语义

1. 上述的迭代器须要为每个新的循环建立一个新的 closure，开销很大
2. 泛型 for 在循环过程内保存了迭代器函数

3. 保存了 3 个值

   1. 一个迭代器函数
   2. 一个恒定状态
   3. 一个控制变量

-- var-list 变量列表 , exp-list 表达式列表, 多个元素可用 , 逗号分割
-- 一般表达式列表只有一个元素，即只有一句对迭代器工厂的调用
for <var-list> in <exp-list> do
    <code block>
end

for k, v in pairs(t) do
    print(k, v)
end

for line in io.lines() do
    io.write(line, "\n")
end

1. 变量列表的第一元素称为「控制变量」，在循环过程当中该值毫不会为 nil，当它为 nil 时循环结束

2. for 首先会先对 in 后面的表达式求值，这些表达式应返回 3 个值供 for 保存

   1. 迭代器函数
   2. 恒定状态
   3. 控制变量的初值
3. 相似多重赋值，即只有最后一个表达式才会产生多个结果
4. 且只会保留前 3 个值，多余的值被丢弃，不足的话，用 nil 补足
5. 在初始化步骤后，for 会以恒定状态和控制变量来调用迭代器函数
6. 而后 for 将迭代器函数的返回值赋予变量列表中的变量
7. 若是变量列表中的第一个元素（即控制变量）的返回值为 nil，则循环终止
8. 不然，for 执行循环体，而后再次调用迭代器函数，并重复这个过程
9. 从 for 构建的角度来讲，恒定状态的内容与 for 自己是彻底无关的。for 只是保存了初始化中返回的值，并在调用迭代器函数时传入该值。

for var_1, ..., var_n in <exp-list> do
    <code clock>
end

-- 上述代码等价于以下代码s
do
   -- _f 为迭代器函数，_s 为恒定状态，控制变量的初值为 a0
   local _f, _s, _var = <exp-list>
   while true do
        local var_1, ... var_n = _f(_s, _var)
        _var = var_1
        if _var == nil then
            break
        end
    end
    <code block>
end

1. _f 为迭代器函数，_s 为恒定状态，控制变量的初值为 a₀
2. 在循环过程当中控制变量的值依次为 a₁ = f(s, a₀) 、a₂ = f(s, a₁) 以此类推
3. 直至 ai 为 nil 结束循环
4. 若是 for 还有其余变量，那么 他们也会在每次调用 f 后得到额外的值