Lua教程（五）：迭代器和泛型for

1. 迭代器与Closure：

在Lua中，迭代器通常为函数，每调用一次函数，即返回集合中的“下一个”元素。每个迭代器都需要在每次成功调用之间保持一些状态，这样才能知道它所在的位置和下一次遍历时的位置。从这一点看，Lua中closure机制为此问题提供了语言上的保障，见如下示例：

代码如下:

function values(t)
    local i = 0
    return function()
        i = i + 1
        return t[i]
    end
end
t = {10, 20, 30}
it = values(t)
while true do
    local element = it()
    if element == nil then
        break
    end
    print(element)
end
--另外一种基于foreach的调用方式(泛型for)
t2 = {15, 25, 35}
for element in values(t2) do
    print(element)
end
--输出结果为：
--10
--20
--30
--15
--25
--35

从上面的应用示例来看，相比于while方式，泛型for的方式提供了更清晰的实现逻辑。因为Lua在其内部替我们保存了迭代器函数，并在每次迭代时调用该隐式的内部迭代器，直到迭代器返回nil时结束循环。

    2. 泛型for的语义：

上面示例中的迭代器有一个明显的缺点，即每次循环时都需要创建一个新的closure变量，否则第一次迭代成功后，再将该closure用于新的for循环时将会直接退出。

这里我们还是先详细的讲解一下Lua中泛型(for)的机制，之后再给出一个无状态迭代器的例子，以便于我们的理解。如果我们的迭代器实现为无状态迭代器，那么就不必为每一次的泛型(for)都重新声明一个新的迭代器变量了。
    泛型(for)的语法如下：
 

代码如下:

for <var-list> in <exp-list> do
        <body>
    end

为了便于理解，由于我们在实际应用中<exp-list>通常只是包含一个表达式(expr)，因此简单起见，这里的说明将只是包含一个表达式，而不是表达式列表。现在我们先给出表达式的原型和实例，如：

代码如下:

function ipairs2(a)
    return iter,a,0
end

该函数返回3个值，第一个为实际的迭代器函数变量，第二个是一个恒定对象，这里我们可以理解为待遍历的容器，第三个变量是在调用iter()函数时为其传入的初始值。
    下面我们再看一下iter()函数的实现，如：

代码如下:

local function iter(a, i)
    i = i + 1
    local v = a[i]
    if v then
        return i, v
    else
        return nil, nil
    end
end

在迭代器函数iter()中返回了两个值，分别对应于table的key和value，其中key(返回的i)如果为nil，泛型(for)将会认为本次迭代已经结束。下面我们先看一下实际用例，如：

代码如下:

function ipairs2(a)
    return iter,a,0
end

local function iter(a, i)
    i = i + 1
    local v = a[i]
    if v then
        return i, v
    else
        return nil, nil
    end
end

a = {"one","two","three"}
for k,v in ipairs2(a) do
    print(k, v)
end
--输出结果为：
--1       one
--2       two
--3       three

这个例子中的泛型(for)写法可以展开为下面的基于while循环的方式，如：

代码如下:

local function iter(a, i)
    i = i + 1
    local v = a[i]
    if v then
        return i, v
    else
        return nil, nil
    end
end

function ipairs2(a)
    return iter,a,0
end

a = {"one","two","three"}
do
    local _it,_s,_var = ipairs2(a)
    while true do
        local var_1,var_2 = _it(_s,_var)
        _var = var_1
        if _var == nil then  --注意，这里只判断迭代器函数返回的第一个是否为nil。
            break
        end
        print(var_1,var_2)
    end
end
--输出结果同上。

3. 无状态迭代器的例子：
    这里的示例将实现遍历链表的迭代器。

代码如下:

local function getnext(list, node)  --迭代器函数。
    if not node then
        return list
    else
        return node.next
    end
end

function traverse(list)  --泛型(for)的expression
    return getnext,list,nil
end

--初始化链表中的数据。
list = nil
for line in io.lines() do
    line = { val = line, next = list}
end

--以泛型(for)的形式遍历链表。
for node in traverse(list) do
    print(node.val)
end

这里使用的技巧是将链表的头结点作为恒定状态(traverse返回的第二个值)，而将当前节点作为控制变量。第一次调用迭代器函数getnext()时，node为nil，因此函数返回list作为第一个结点。在后续调用中node不再为nil了，所以迭代器返回node.next，直到返回链表尾部的nil结点，此时泛型(for)将判断出迭代器的遍历已经结束。

最后需要说明的是，traverse()函数和list变量可以反复的调用而无需再创建新的closure变量了。这主要是因为迭代器函数(getnext)实现为无状态迭代器。

    4. 具有复杂状态的迭代器：

在上面介绍的迭代器实现中，迭代器需要保存许多状态，可是泛型(for)却只提供了恒定状态和控制变量用于状态的保存。一个最简单的办法是使用closure。当然我们还以将所有的信息封装到一个table中，并作为恒定状态对象传递给迭代器。虽说恒定状态变量本身是恒定的，即在迭代过程中不会换成其它对象，但是该对象所包含的数据是否变化则完全取决于迭代器的实现。就目前而言，由于table类型的恒定对象已经包含了所有迭代器依赖的信息，那么迭代器就完全可以忽略泛型(for)提供的第二个参数。下面我们就给出一个这样的实例，见如下代码：
 

代码如下:

local iterator
function allwords()
    local state { line = io.read(), pos = 1 }
    return iterator, state
end
--iterator函数将是真正的迭代器
function iterator(state)
    while state.line do
        local s,e = string.find(state.line,"%w+",state.pos)
        if s then
            state.pos = e + 1
            return string.sub(state.line,s,e)
        else
            state.line = io.read()
            state.pos = 1
        end
    end
    return nil
end

赞 (0)

相关推荐

  • Lua中的迭代器和泛型for介绍

    任何一种结构,只要允许你遍历集合中所有元素的都可称之为迭代器.lua中常常使用函数来描述迭代器,每次调用该函数都返回集合的下一个元素.每一个迭代器都需要保存一些状态来知道当前处于什么位置和如何进行下一次迭代.对于这样的任务,闭包提供了很好的机制来完成.一个典型的闭包结构包含两个函数:一个是闭包自身,一个是创建闭包的工厂. 例如,我们可以写过简单的list迭代器,让他仅仅返回值. 复制代码 代码如下: function values( t )      local i = 0;      retu

  • Lua的迭代器使用中应该避免的问题和技巧

    关于迭代器的内容,还有一点点,不过已经无关紧要了,应该算是一种扩展吧,就一起来开开眼界好了~ 1.避免创建闭合函数 我们之前一直在说的迭代器,都是要创建闭合函数,但,大家有没有想过,有了恒定状态和控制变量之后,是不是就不需要闭合函数了? 先来回顾一下之前的迭代器函数: 复制代码 代码如下: function dieDaiQi(t)     local i = 0;     return function(s, var)         i = i + 1;                 if

  • 深入解读Lua中迭代器与泛型for的使用

    泛型for原理 迭代器是一种可以遍历集合中所有元素的机制,在Lua中通常将迭代器表示为函数,每调用一次函数,就返回集合中"下一个"元素.每个迭代器都需要在每次成功调用之间保持一些状态,这样才能知道它所在的位置及如何步进到下一个位置,closure就可以完成此项工作.下面的示例是列表的一个简单的迭代器: function values(t) local i = 0 return function() i = i + 1; return t[i] end end 循环调用: t = {10

  • Lua中的迭代器和泛型for学习总结

    前言 迭代器就是一种可以遍历一种集合中所有元素的机制,在Lua中,通常将迭代器表示为函数.每调用一次函数,就返回集合中的"下一个"元素.每个迭代器都需要在每次成功调用之后保存一些状态,这样才能知道它所在的位置及如何走到下一个位置,通过之前博文的总结,闭包对于这样的任务提供了极佳的支持.现在我们就用代码来实现一个简单的迭代器. 复制代码 代码如下: function values(tb)      local i = 0      return function ()          

  • Lua中的迭代器浅析

    今天学习的内容还蛮有意思的,让我兴奋了一下~ 1.迭代器 什么是迭代器?别傻了,我最讨厌的就是名词解释了,反正就是用来遍历集合的一种方式. 比如,我们最常用的pairs,如下代码: 复制代码 代码如下: local t = {"fdsd", "445"};        for k, v in pairs(t) do         print("k=" .. k .. ", v=" .. v);     end 这是一次遍历

  • Lua中的迭代器（iterator）浅析

    Lua有迭代器的概念,通过不同的迭代器,几乎可以遍历所有的东西.标准库提供的几种迭代器:io.lines(迭代文件中的每行), pairs(迭代table元素),ipairs(迭代数组元素), string.gmatch(迭代字符串中单词)等. 另外,可以自定义迭代器 使用pairs迭代器变量table 复制代码 代码如下: > t = {2,3,4,5} > for i,v in pairs(t) do >> print(i .. ' = ' .. v) >> end

  • Lua中的for循环和迭代器的秘密探究

    上一篇我们介绍了,可以使用for循环来完成迭代器的调用,十分简洁. 那么,具体这for循环做了什么呢?我当然没有去看源码,我只是看书而已. 资料来源于<Lua程序设计>第二版,如果这本书的内容没有错的话,那么,本篇文章理论上也不会有错~ 1.返回两个值的迭代器 pairs是能遍历table的key和value的,而我们之前写的dieDaiQi函数只能返回value. 所以,我们要改改dieDaiQi函数,如下: 复制代码 代码如下: function dieDaiQi(t)     local

  • 浅析Lua中的迭代器

    迭代器是一种结构,使能够遍历所谓的集合或容器中的元素.在Lua中,这些集合通常是指那些用于创建各种数据结构,如数组表. 一般对于迭代器 一个通用的迭代器提供的键值对集合中的每个元素.下面一个简单的实例. 复制代码 代码如下: array = {"Lua", "Tutorial"} for key,value in ipairs(array) do    print(key, value) end 当我们运行上面的代码之后将得到下面的输出 复制代码 代码如下: 1 

  • Lua中的迭代器和泛型for实例

    1.迭代器与closure 在lua中,迭代器通常为函数,每调用一次函数,会返回集合中的下一个元素.每个迭代器在成功调用的时候,都需要保存一些状态,closure(闭包)完美为迭代器运用而生. 复制代码 代码如下: function values(t)     local i=0     return function() --匿名函数     i=i+1     return t[i]     end end t1 ={10, 20, 30} it=values(t1)   --创建闭包变量的

  • Lua教程（五）：迭代器和泛型for

    1. 迭代器与Closure: 在Lua中,迭代器通常为函数,每调用一次函数,即返回集合中的"下一个"元素.每个迭代器都需要在每次成功调用之间保持一些状态,这样才能知道它所在的位置和下一次遍历时的位置.从这一点看,Lua中closure机制为此问题提供了语言上的保障,见如下示例: 复制代码 代码如下: function values(t)     local i = 0     return function()         i = i + 1         return t[i

  • Lua教程（一）：在C++中嵌入Lua脚本

    Lua教程（一）：在C++中嵌入Lua脚本

    本系列教程主要介绍如何在C/C++程序里面嵌入Lua脚本,我打算从以下几个方面来介绍: 1.如何在C/C++里面嵌入Lua脚本 2.Lua访问C/C++数据结构(这里面要介绍类,结构体,函数,变量,枚举等数据类型在lua里面如何访问) 3.C/C++访问Lua的数据,主要是基本数据类型,函数和Table 4.Cocos2D-X里面的Lua绑定(含自动绑定与手动绑定) 5.Cocos2D-x里面Lua和C/C++相互调用 6.Cocos2D-x里面Lua和Java相互调用 7.Cocos2D-x里

  • MyBatis学习教程(五)-实现关联表查询方法详解

    MyBatis学习教程(五)-实现关联表查询方法详解

    一.一对一关联  1.1.提出需求 根据班级id查询班级信息(带老师的信息) 1.2.创建表和数据 创建一张教师表和班级表,这里我们假设一个老师只负责教一个班,那么老师和班级之间的关系就是一种一对一的关系. CREATE TABLE teacher( t_id INT PRIMARY KEY AUTO_INCREMENT, t_name VARCHAR() ); CREATE TABLE class( c_id INT PRIMARY KEY AUTO_INCREMENT, c_name VAR

  • Go语言七篇入门教程五文件及包

    Go语言七篇入门教程五文件及包

    目录 1. 文件处理 1.1 JSON文件 1.1.1 已知JSON结构 1.1.2 未知JSON结构 1.1.3 Encoder & Decoder 1.2 XML文件 1.3 二进制文件 1.4 zip文件 1.4.1 创建zip 1.4.2 读取zip文件 2. 包管理 2.1 包路径 2.2 包声明 如何学习Go 1. 文件处理 1.1 JSON文件 什么是json? JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式. 也是在web开发中的前后

  • Lua教程（十五）：输入输出库（I/O库）

    Lua教程（十五）：输入输出库（I/O库）

    I/O库为文件操作提供了两种不同的模型,简单模型和完整模型.简单模型假设一个当前输入文件和一个当前输出文件,他的I/O操作均作用于这些文件.完整模型则使用显式的文件句柄,并将所有的操作定义为文件句柄上的方法.     1. 简单模型:     I/O库会将进程标准输入输出作为其缺省的输入文件和输出文件.我们可以通过io.input(filename)和io.output(filename)这两个函数来改变当前的输入输出文件.     1). io.write函数:     函数原型为io.wri

  • Lua教程（五）：C/C++操作Lua数组和字符串示例

    本文将介绍如何在C/C++里面操作Lua的数组和字符串类型,同时还会介绍如何在C/C++函数里面存储Lua状态(registry和upvalue),而registry在使用C/C++自定义类型时非常有用,可以方便地为userdata指定metatable. C/C++操作Lua数组 Lua数组Overview 在Lua里面,数组只不过是key为整数的table而已.比如一个table为array = {12,"Hello", "World"},它是一个数组,可以用下

随机推荐