lua tutorial 09

迭代器

模板

--[[
    for k,v in ipairs(t) do
        print(k,v)
    end
--]]
    array = {"Lua","Tutorial"}
    for k,v in ipairs(array) do
        print(k,v)
    end

无状态迭代器

定义：不保留任何状态的迭代器，因此在循环中我们可以利用无状态迭代器避免创建闭包花费额外的代价。每一次迭代，迭代函数都是用两个变量的值作为参数调用。无状态迭代器，使用这两个值机可以获取下一个元素。ipairs就是无状态迭代器，他遍历数组的每一个元素。

代码

    function square(itorMaxCount,curNum)
        if curNum < itorMaxCount then
            curNum = curNum + 1
            return curNum,curNum * curNum
        end
    end

    for i,n in square,3,0 do
        print(i,n)
    end

    function squares(max)
        return square,max,0
    end

    for i,n in squares(5) do
        print(i,n)
    end

多状态迭代器

代码

   array = {"lua","tutorial"}

   function eleItor(collection)
        local idx = 0
        local count = #collection
        --闭包函数
        return function()
            idx = idx + 1
            if idx <= count then
                return collection(idx)
            end
        end
   end
   for element in eleItor(array) do
        print("Test01",element)
   end

闭包

定义：子函数可以使用父函数中的局部变量，这种行为称为闭包

代码

    function counter()
        local idx = 0
        return function()
            idx = idx + 1
            return idx
        end
    end
    c1 = counter()
    c2 = counter()
    print(c1())
    print(c1())
    print(c2())
    print(c1())

自己的理解：

关于闭包我是这样理解的，将函数看成是一个对象，而函数中的局部变量就是这个对象的属性，相对于同一个对象来数，属性的值变化是会被保存下来的。通过上面的测试代码，可以看出，闭包针对的是固定内存地址的函数，我们对c1操作，他内部的局部变量并不影响c2中的局部变量。所以，将函数当作对象来看，闭包函数就是他的属性方法。

内嵌函数

内嵌函数，顾名思义，就是嵌套在函数内部的函数。跟上面说过的闭包函数类似，这个也可以当作对象的方法来理解。

代码

    function fun1()
        local iVal = 10
        function InnerFun1()
            print(iVal)
        end
        function InnerFun2()
            iVal = iVal + 10
        end
        return InnerFun1,InnerFun2
    end

    local a,b = fun1()
    a()
    b()
    a()
    b()

代码解析:
上面的代码a是InnerFun1,b是InnerFun2,在程序中调用a,b实际上就是执行那两个函数，a负责输出，b负责改变iVal的值，这里的操作更是把函数当作一个对象来对待了。