Lua中的表和函数比较重要,正是因为二者的结合才完成了很多很多的功能,Lua才变得如此的强大,所以有必要仔细的学习一下表和函数,以下的代码体现了表的用法。

--表
--可以使用构造器来初始化表,表是Lua特有的功能强大的东西。最简单的构造函数是{},用来创建一个空表。
local days = {"xiao", "ta", "hello", "lua"}
--第一个元素索引为1,以后的类推,这一点和其他语言的第一个元素索引是0不同,要特别注意,小心掉到坑里边。
print(days[4])       --> lua

--构造函数可以使用任何表达式初始化
local num = {1,2,3,4,5}
--其实num的初始化等价于如下
local num = {[1]=1,[2]=2,[3]=3,[4]=4,[5]=5}
--访问元素的时候使用中括号
print(num[1]) -->1

--还可以在初始化表的时候为元素提供一个索引
local tab = {a=1,b=2}
--等价于如下的初始化
local tab = {["a"]=1,["b"]=2}
print(tab["a"]) -->1
--当索引值是字符串的时候可以使用tab.a的形式来访问元素,其实代表的就是tab["a"],要务必理解这种用法,当你访问表中元素出错的时候不妨看看是不是这个知识点没有掌握好,本人在这里就遇到了坑,所以只有多实践才能深刻体会。
print(tab.a) -->1
--注意区分tab["a"]和tab[a]这俩种形式,第一种代表的索引是字符串a,可以使用等价的形式tab.a来访问它的值
--第二种代表的是使用a这个变量的值作为索引来访问
local a = "haha"
local tab2 = {a="hello",[a]="lua"}
print(tab2.a) -->hello
print(tab2[a]) -->lua

--向表中添加元素
tab2.x = 3
tab2[5] = 4
--删除元素
tab2.a = nil

--一个表中可以混合各种类型的值,可以是boolean,字符串,表,函数,等等
local tab3 = {color="blue",{x=0,   y=0},thickness=2, npoints=false,
              {x=-10, y=0},
              {x=-30, y=1},
              {x=0,   y=1}
}
--没有添加索引的时候索引默认从1开始
print(tab3[2].x)     --> -10

--在构造函数的最后的","是可选的,可以方便以后的扩展
local a = {[1]="red", [2]="green", [3]="blue",}
--在构造函数中域分隔符逗号(",")可以用分号(";")替代,通常我们使用分号用来分割不同类型的表元素
local tab4 = {x=10, y=45; "one", "two", "three"}

接下来学习Lua函数的用法,函数涉及的东西比较多,不着急,慢慢来。

--函数
--如下是基本的函数的写法 local代表函数a是局部变量,接下来的function当然是函数的说明符了,a是函数的名称
--括号中写参数,最后的end代表函数的结束 中间的函数体当然是我们要完成的函数功能了
local function a()
    print("function")
end
--等价于如下的写法,前面已经说过函数是第一类值,所以就是把函数赋值给一个变量,然后调用这个变量
local a = function()
    print("function")
end
--函数的调用
a()
--我们也可以将函数作为一个表的数据成员
local tab = {1}
--函数的前边不需要local的修饰符,因为这个函数就是这个表里边的一个数据,只能用这个表来访问,所以当然是local的了,不需要使用local声明了。
tab.func = function()
    print("tab.func")
end
--或者可以简写为
function tab.func()
    print("tab.func")
end
tab.func()

--还有一种写法,这里使用的是冒号,代表的是func有一个默认的参数self,这个参数的值就是tab
function tab:func(a,b,c)
    print(self[1]) -->1
end
--调用的时候使用冒号的形式来调用,代表的是默认传递一个值到这个函数中,这个值就是tab
tab:func()

--Lua的函数可以接受可变数目的参数,和C语言类似,在函数参数列表中使用三个点(...)表示函数有可变的参数。
--Lua将函数的参数放在一个叫arg的表中,除了参数以外,arg表中还有一个域n表示参数的个数。
local function func3(...)
    print(arg.n)
end
--在控制台下可以正常输出3,但是在IDE中这里说arg是个空值,不知道哪里设置的不对
--func3(1,2,3)

--下面是cocos中cclog函数的实现
local cclog = function(...)
    print(string.format(...))
end

--固定参数加可变参数
local function func4(a,b,...)
end

--多返回值
--Lua函数可以返回多个结果值,比如string.find,其返回匹配串“开始和结束的下标”(如果不存在匹配串返回nil)
--接收多返回值的时候采用如下的方式进行接收
local s, e = string.find("hello Lua users", "Lua")
print(s, e)       --> 7  9

--下面是多返回值的写法
local function func4(a,b)
    return a,b
end
print(func4(1,2)) -->1,2

--当作为表达式调用函数时,有以下几种情况:
--1. 当调用作为表达式最后一个参数或者仅有一个参数时,根据变量个数函数尽可能多地返回多个值,不足补nil,超出舍去。
--2. 其他情况下,函数调用仅返回第一个值(如果没有返回值为nil)
--说的有点模糊,具体看例子
local function foo0 () end                   -- returns no results
local function foo1 () return 'a' end        -- returns 1 result
local function foo2 () return 'a','b' end    -- returns 2 results
--返回值的个数不够的情况下补nil
local x,y = foo0()             -- x=nil, y=nil
local x,y = foo1()             -- x='a', y=nil
local x,y,z = foo2()           -- x='a', y='b', z=nil
print(foo0())            -->
print(foo1())            --> a
print(foo2())            --> a   b
--不是作为表达式的最后一个参数,这个时候只返回第一个值
print(foo2(), 1)         --> a   1
print(foo2() .. "x")     --> ax
a = {foo0(), foo2(), 4}  -- a[1] = nil, a[2] = 'a', a[3] = 4

--可以使用圆括号强制使调用返回一个值
print((foo0()))      --> nil
print((foo1()))      --> a
print((foo2()))      --> a
--一个return语句如果使用圆括号将返回值括起来也将导致返回一个值

--命名参数:在cocos中,有时候我们需要给一个sprite设置位置,我们想将某个值赋给x,另一个值赋给y
--以下就是这种函数调用,但是结果是做不到的,实现这种思想的方法是通过表来实现,这个就叫命名参数,Cocos中有很多
--务必理解
--setPosition(x=1,y=2)

local function setPostion(point)
    print(point.x,point.y)
end

--正确的调用
setPostion({x=1,y=2})

Lua表和函数

上边说明了函数的基本用法,接下来说明函数高级一点的东西,主要就是函数的闭包和尾调用。

--函数闭包
--当一个函数内部嵌套另一个函数定义时,内部的函数体可以访问外部的函数的局部变量
local function newCounter()
    local i = 0
    return function()     -- anonymous function
        i = i+1
        print(i)
    end
end

--在newCounter的匿名函数内部i不是全局变量也不是局部变量,我们称作外部的局部变量或者upvalue
--简单的说,闭包是一个函数以及它的upvalues。
local c1 = newCounter()
c1() -->1
--虽然第二次调用的时候newCounter在第一次的时候已经返回,但是i的值却是上次的值
c1() -->2
--如果我们再次调用newCounter,将创建一个新的局部变量i,因此我们得到了一个作用在新的变量i上的新闭包。
local c2 = newCounter()
c2() -->1

--因为函数是第一类值,所以函数可以放到表中
local func = {}
--将函数f1放到了func表中
function func:f1()
end
--在表的构造器中直接放入函数,这些东西也不稀奇,在cocos中经常用到。
local func2 = {
    f1 = function()
    end
}
local func2 = {
    function()
    end
}
--以下是错误的语法 func2[1]对应的到底是一个函数还是f1,在cocos中做完动作以后我们经常会调用一个Callfunc动作,这个动作经常这样写cc.CallFunc:create(function()end)
--local func2 = {
--    function f1()
--    end
--}

--以下这种方式导致Lua编译时遇到fact(n-1)并不知道他是局部函数fact,Lua会去查找是否有这样的全局函数fact。为了解决这个问题我们必须在定义函数以前先声明:
local fact
local fact = function (n)
    if n == 0 then
       return 1
    else
       return n*fact(n-1)
    end
end
--以上就是闭包的介绍了,大家务必多多领悟,主要的是多多实践,然后你就会发现闭包真的是很强大。

--尾调用
--尾调用是一种类似在函数结尾的goto调用,当函数最后一个动作是调用另外一个函数时,我们称这种调用尾调用
local function f1()
    return f2()
end
--当程序调用f2的时候,f1中已经无事可做了,所以在调用f2完毕的时候就不需要返回f1了,而是直接返回到调用f1的那个点
--f1的栈信息也不需要保存,这样的话比较节省内存,也就是尾调用的好处吧

--尾调用的函数需要是匿名的函数,如下语法错误
local function f2()
    return function f3()
    end
end
local function f2()
    return f3 = function()
    end
end

--判断尾调用的标准:一个函数调用完另一个函数的时候是否就不需要处理其他事情了,以下的例子不是尾调用
--return g(x) + 1      must do the addition
--return x or g(x)     must adjust to 1 result
--return (g(x))        将返回的结果使用括号包起来,这样强制返回一个值
--所以只有类似return g(...)这种格式的调用是尾调用,其他的都不是
--尾调用的好处就是节省栈空间,所以当我们在程序中实现状态机的时候最好使用尾调用,从一个状态跳转到另一个状态,而不需要浪费栈空间