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
