lua语言中是不是可以在table中存储函数

Posted

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了lua语言中是不是可以在table中存储函数相关的知识,希望对你有一定的参考价值。

table可不可以存储函数(无论有没有返回值)呢?
例如
---------
list
list[1]= function()
--dosometing and return nothing

--例如调用其他函数或者使用协程

end
--------
那么直接执行list[1]()会不会有任何效果呢?

如果没有效果那么在lua中是怎样实现类似Csharp中代理的功能的呢?

--写一个我常用的table教学的sample

local a = 1,2,3
--常用的储存方式
a[4] = 9
--元素添加
table.insert(a,4)
--元素添加
a[6] = function (a) print(a) end
--元素可以是函数
a['asd'] = 'asd'
--index可以是字符串,元素可以是字符串

for i,v in pairs(a) do
    -- ipairs 和 pairs 的区别在于index是否为连续整数
    print(v)
end

参考技术A

可以用数字下标放 但我们更常用的方法是以字符串做下标

local t = 
t.fun = function() print(123) end
t.fun()

参考技术B 经测试,可以。 参考技术C 可以,你不会自己试试? 详见lua程序设计

lua迭代器和泛型for浅析

(一) 首要概念要理清:

1. 在lua中,函数是一种"第一类值",他们具有特定的词法域."第一类值"表示在lua中函数与其他传统类型的值(例如数字和字符串)具有相同的权利.

2. 函数可以存储到变量中(无论全局变量还是局部变量)或table中,可以作为实参传递给其他函数,还是作为其他函数的返回值;

3. "词法域"是指:一个函数可以嵌套在另一个函数中,内部的函数可以访问外部函数中的变量;

一个语言如果支持闭包,那么通常都会具有第2点和第3点的特性.下面给出lua中创建函数的一个例子:

-- 一个函数定义实际就是一条赋值语句
foo = function(x) return 2*x end
-- 使用"语法糖"简化
function foo(x) return 2*x end
-- 高阶函数:接受另一个函数作为实参,如下sort接受一个匿名函数
table.sort(tbl, function(a, b) return (a.name > b.name) end)

(二) closure(闭合函数)

1. 考虑如下函数:

names = {"Peter", "Paul", "Mary"}
grades = {Mary = 10, Paul = 7, Peter = 8}
function sortbygrade(names, grades)
    table.sort(names, function(n1, n2)
        return grades[n1] > grades[n2]
    end)
end

上面代码中,传递给sort的匿名函数可以访问参数grades,而grades是外部函数sortbygrades的局部变量.在这个匿名函数内部,grades既不是全局变量也不是局部变量,将其称为一个"非局部的变量(non-local variable, 也叫upvalue)".lua通过closure来处理内部函数访问upvalue:一个closure就是一个函数加上改函数所需访问的所有"非局部变量upvalue".

2. 非局部的函数

函数作为"第一类值",也可以存储在table的字段中和局部变量中.只要将一个函数存储到一个局部变量中,即得到一个"局部函数".

在定义递归的局部函数时,需要注意下面的情况:

local fact = function(n)
    if n == 0 then return 1
    else return n*fact(n-1)    -- 错误
    end
end

当lua编译到函数中调用fact(n-1)的地方时,由于局部的fact尚未定义完毕,因此这句表达式其实是调用了一个全局的fact,而非此函数自身.为了解决这个问题,可以先定义一个局部变量,然后再定义函数本身:

local fact
fact = function(n)
    if n == 0 then return 1
    else return n*fact(n-1) 
    end
end

现在函数中的fact调用就表示了局部变量.即使在函数定义时,这个局部变量的值尚未完成定义,但之后在函数执行时,fact则肯定已经拥有了正确的值.

当lua展开局部函数定义的"语法糖"时,并不是使用基本函数定义语法.而是对于局部函数定义:

local function foo(<参数>) <函数体> end

lua将其展开为:

local foo

foo = function(<参数>) <函数体> end

因此,使用这种语法来定义递归函数不会产生错误:

local function fact(n)
    if n == 0 then return 1
    else return n*fact(n-1)   
    end
end

当然,这个技巧对于间接递归的函数而言是无效的.在间接递归的情况中,必须使用一个明确的前向声明:

local f, g      -- 前向声明

function g()
    <一些代码> f() <一些代码>
end

function f()
    <一些代码> g() <一些代码>
end

注意,别把第二个函数定义写为"local function f". 如果那样的话,lua会创建一个全新的局部变量f,而将原来声明的f(函数g中所引用的那个)置于未定义的状态.

(三) 尾调用(proper tail call)

当一个函数调用是另一个函数的最后一个动作时,该调用才算是一条"尾调用".如下:

-- 正确的尾调用
function f(x) return g(x) end
-- 不是尾调用, 还需要丢弃g返回的临时结果
function f(x) g(x) end
-- 不是, 必须做一次加法
return g(x)+1         
-- 不是, 必须调整为一个返回值
return x or g(x)
-- 不是, 必须调整为一个返回值
return (g(x))

当f调用完g之后就再无其他事情可做了. 因此在这种情况下,程序就不需要返回那个"尾调用"所在的函数了.所以在"尾调用"之后,程序也就不需要保存任何关于该函数的栈信息了.但g返回时,执行控制权可以直接返回到调用f的那个点上,使得在进行"尾调用"是不耗费任何栈空间.将这种实现称为支持"尾调用消除".

在lua中,只有"return <func>(<args>)"这样的调用形式才算是一条"尾调用".

 (四) 迭代器和closure

1. 迭代器与Closure:  

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

 1 function values(t)
2 local i = 0
3 return function()
4 i = i + 1
5 return t[i]
6 end
7 end
8 t = {10, 20, 30}
9 it = values(t)
10 while true do
11 local element = it()
12 if element == nil then
13 break
14 end
15 print(element)
16 end
17 --另外一种基于foreach的调用方式(泛型for)
18 t2 = {15, 25, 35}
19 for element in values(t2) do
20 print(element)
21 end
22 --输出结果为:
23 --10
24 --20
25 --30
26 --15
27 --25
28 --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),因此简单起见,这里的说明将只是包含一个表达式,而不是表达式列表。现在我们先给出表达式的原型和实例,如:

1 function ipairs2(a)
2 return iter,a,0
3 end

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

1 local function iter(a, i)
2 i = i + 1
3 local v = a[i]
4 if v then
5 return i, v
6 else
7 return nil, nil
8 end
9 end

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

 1 function ipairs2(a)
2 return iter,a,0
3 end
4
5
6 local function iter(a, i)
7 i = i + 1
8 local v = a[i]
9 if v then
10 return i, v
11 else
12 return nil, nil
13 end
14 end
15
16 a = {"one","two","three"}
17 for k,v in ipairs2(a) do
18 print(k, v)
19 end
20 --输出结果为:
21 --1 one
22 --2 two
23 --3 three

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

 1 local function iter(a, i)
2 i = i + 1
3 local v = a[i]
4 if v then
5 return i, v
6 else
7 return nil, nil
8 end
9 end
10
11 function ipairs2(a)
12 return iter,a,0
13 end
14
15 a = {"one","two","three"}
16 do
17 local _it,_s,_var = ipairs2(a)
18 while true do
19 local var_1,var_2 = _it(_s,_var)
20 _var = var_1
21 if _var == nil then --注意,这里只判断迭代器函数返回的第一个是否为nil。
22 break
23 end
24 print(var_1,var_2)
25 end
26 end
27 --输出结果同上。


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

 1 local function getnext(list, node)  --迭代器函数。
2 if not node then
3 return list
4 else
5 return node.next
6 end
7 end
8
9 function traverse(list) --泛型(for)的expression
10 return getnext,list,nil
11 end
12
13 --初始化链表中的数据。
14 list = nil
15 for line in io.lines() do
16 line = { val = line, next = list}
17 end
18
19 --以泛型(for)的形式遍历链表。
20 for node in traverse(list) do
21 print(node.val)
22 end

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

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

 1 local iterator
2 function allwords()
3 local state { line = io.read(), pos = 1 }
4 return iterator, state
5 end
6 --iterator函数将是真正的迭代器
7 function iterator(state)
8 while state.line do
9 local s,e = string.find(state.line,"%w+",state.pos)
10 if s then
11 state.pos = e + 1
12 return string.sub(state.line,s,e)
13 else
14 state.line = io.read()
15 state.pos = 1
16 end
17 end
18 return nil
19 end

以上是关于lua语言中是不是可以在table中存储函数的主要内容,如果未能解决你的问题,请参考以下文章

Lua遍历table

Lua极简入门(六)——函数的参数

lua迭代器和泛型for浅析

lua学习之深入函数第一篇

Lua之table(表)

撰写 C 函数的技巧