【lua学习】lua迭代器和泛型for浅析

最新推荐文章于 2024-09-04 05:49:17 发布

谢健

最新推荐文章于 2024-09-04 05:49:17 发布

阅读量484

点赞数

分类专栏： Lua学习文章标签： Lua 迭代和泛型（for）

本文链接：https://blog.csdn.net/xj178926426/article/details/80793543

版权

Lua学习专栏收录该内容

7 篇文章 2 订阅

订阅专栏

【lua学习】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)
print([[======================]])
while true do
    local element = it()
    if element == nil then
        break
    end
    print(element)
end


--另外一种基于foreach的调用方式(泛型for)
t2 = {15, 25, 35}
print([[======================]])
for element in values(t2) do
    print(element)
end

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

2. 泛型for的语义：

上面示例中的迭代器有一个明显的缺点，即每次循环时都需要创建一个新的closure变量，否则第一次迭代成功后，再将该closure用于新的for循环时将会直接退出。
这里我们还是先详细的讲解一下Lua中泛型(for)的机制，之后再给出一个无状态迭代器的例子，以便于我们的理解。如果我们的迭代器实现为无状态迭代器，那么就不必为每一次的泛型(for)都重新声明一个新的迭代器变量了。
泛型(for)的语法如下：

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

为了便于理解，由于我们在实际应用中通常只是包含一个表达式(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)将会认为本次迭代已经结束。下面我们先看一下实际用例，如：

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"}
for k,v in ipairs2(a) do
    print(k, v)
end

运行结果如下:
这里写图片描述
这个例子中的泛型(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

运行结果同上，对比可知for语句执行的过程：for做的第一件事就是对in后面的表达式求值，这些表达式应该返回3个值供for保存：迭代器函数、恒定状态和控制变量的初值。这里和多重赋值是一样的，只有最后一个表达式才会产生多个结果，并且只会保留前3个值，多余的值会被丢弃；而不够的话，就以nil补足。
在初始化完成以后，for会以恒定状态和控制变量来调用迭代器函数。然后for将迭代器函数的返回值赋予变量列表中的变量。如果第一个返回值为nil，那么循环就终止，否则，for执行它的循环体，随后再次调用迭代器函数，并重复这个过程。

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

--Lua 实现链表  
node={}  
list=node 

--初始化，构建一个空表  
function init()  
    list.data=""  
    list.next=nil  
end  

--向链表的尾部添加数据  
function addRear(d)  
    node.next={}  --建立一个节点，相当于malloc一个节点  
    node=node.next  
    node.next=nil  
    node.data=d  
end  

--清理链表，操作完成后，链表还在，只不过为空，相当刚开始的初始化状态  
function clear()  
    if not list then  
        print('链表不存在')  
    end  

    while true do  
        firstNode=list.next  
        if not firstNode then  --表示链表已为空表了  
            break  
        end  
        t=firstNode.next  
        list.next=nil  
        list.next=t  
    end  
    list.data=""
    print('-- clear ok --')  
end  

--销毁链表  
function destory()  
    clear() --先清除链表  
    list=nil  
end  

init()
--初始化链表中的数据。
for line in io.lines() do
   if(line == 'q')
   then
        break
   end
   addRear(line)
end


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

destory()

运行结果如下：
这里写图片描述
这里使用的技巧是将链表的头结点作为恒定状态(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

--[[
for word in allwords() do
    print(word)
end
]]--