在lua中，函数是语句和表达式体现的主要机制。函数可以完成某些特定的任务、计算和返回执行结果。
前者当成一个语句，后者当成一个表达式:
1 print(8*9,9/8)
2 a = math.sin(3) + math.cos(10)
3 print(os.date())在这两种情况下，调用函数都要用一个括号携带一系列参数去表示。如果函数不带参数，也需要用空的括号去表示。
但是有几个特列括号是可以省略的：
print "Hello World" --函数只有一个字符串参数
print [[ a multi-line message ]]
f{x=10,y=20} --参数是一个表
type{} Lua为针对面向对象的调用提供了特殊的语法——冒号操作符。
o.foo(o,x)可以用o:foo(x)表示，这样去调用foo，是隐含地把o作为函数第一个参数。
一个Lua程序可以使用Lua或C定义的函数。就像所有的标准Lua库是用C写的一样。
然而，在调用一个函数时，两者是没有区别的。
一个函数定义的常规语法像这样：
-- add the elements of sequence 'a'
function add (a)
local sum = 0
for i=1, #a do
sum = sum + a[i]
end
return sum
end
可以看到，一个函数定义由函数名(add)、参数(a)、函数体(一系列的语句)组成。
函数参数是当作局部变量使用，由函数调用时的参数去初始化。
当调用函数时的参数不等于函数定义时的参数个数时，Lua会自动调整数量。类似于多重赋值。
这种调整行为其实很有用，比如对于默认实参的应用，以下是一个全局计数器：
function incCount(n)
n = n or 1
count = count + n
end该函数用1作为它的默认实参，每次不带参数去调用incCount就增加1。
5.1 多重返回值
Lua函数有一个与众不同的特点，就是返回多个值。Lua中有几个预定义函数就是多重返回值。
string.find 函数：
s,e = string.find("hello Lua users","Lua")
print(s,e) --> 7 9
如果该函数匹配到了Lua,它就返回两个索引值，分别指向“Lua”在字符串中的开始和结束位置。
用Lua写的函数同样可以返回多个结果，只需在return后面给出。
例如，找出一个序列中最大值，并返回它所在的位置：
function maximum (a)
local mi = 1
local m = a[mi]
for i = 1, #a do
if a[i] > m then
mi = i; m = a[i]
end
end
return m , mi
end
print(maximum({8,10,23,12,5})) -- 23 3Lua也会调整函数返回的个数，以适应不同的调用环境。当函数作为一个单独的语句调用时，Lua会丢掉所有函数返回。
当函数作为一个表达式被调用时，Lua只保留第一个返回值。以下情况，函数调用处在最后的表达式中时，才能获得函数所有值：函数作为语句用于多重赋值、 函数作为实参被调用、table构造、return语句、有以下函数：
function foo0() end
function foo1() return "a" end
function foo2() return "a","b" end
x,y = foo2() -- x="a",y="b"
x = f002() -- x="a","b"被丢弃
x,y,z = 10,foo2() --x=10,y="a",z="b"
如果函数不返回值，或者没有返回足够多的值，Lua会用nil去填充
x,y = foo0() --x=nil,y= nil
x,y = foo1() --x="a",y=nil
x,y,z = foo2() --x="a",y="b",z=nil
如果函数不是一系列表达式的最后一个元素，则只返回一个值：
x,y = foo2(),20 --x="a",y=20
当函数作为作为最后一个参数或只有它一个参数被调用时，函数返回所有的结果：
print(foo0()) -->空
print(foo1()) -->a
print(foo2()) -->a b
print(foo2(),1) --> a 1
print(foo2() .. "x") -->ax
table构造时，可以接收一个函数的所有结果
t = {foo0()} --t={} 空table
t = {foo1()} --t = {"a"}
t = {foo2()} --t = {"a","b"}
--但是函数不是最后一个元素或唯一一个元素时,它只返回一个值
t = {foo0(),foo2(),4} --t[1]=nil,t[2] = "a",t[3] = 4
最后，return语句，return f() 返回所有的 f 函数的值：
function foo (i)
if i == 0 then return foo0()
elseif i == 1 then return foo1()
elseif i == 2 then return foo2()
end
end
print(foo(1)) -->a
print(foo(2)) -->a b
print(foo(0)) -->no results
print(foo(3)) -->no results
也可以将一个函数调用放入一对括号中，强制返回一个结果：
print((foo0())) -->nil
print((foo1())) -->a
print((foo2())) -->a
还有一个特殊的函数——unpack,它接收一个数组作为参数，并从下标1开始返回该数组的所有元素：
pirnt（unpack{10,20,30}） -->10 20 30
a,b = unpack{10,20,30} -->a=10,b=20,30被抛弃
unpack函数的一个重要用途体现在“泛型调用”，即可以动态地以任何参数来调用任何函数。
如果想调用函数fun，而所有参数都在数组a中：
f = string.find
a = {"hello","ll"}
print(f(table.unpack(a))) -->等价于string.find（"hello","ll"）
-->3 4
通常，unpack可以通过取长度操作符"#"知道有多少个元素返回，也可以通过提供确切的限制：
print(table.unpack({"Sun","Mon","Tue","Wed"},2,3) --返回索引2到索引3的值
--> Mon Tue
尽管unpack是由C写的，但是也可以用Lua通过递归来实现：
function unpack(t,i,n)
i = i or 1
n = n or #t
if i<= n then
return t[i],unpack(t, i+1, n)
end
end
当第一次只用一个参数调用时，i = 1 ; n = #t,然后return t[1] ,紧接着返回所有unpack的值。unpack(t,2,n)...unpack(t,3,n)....
直到最后一个n元素。
5.2 变长参数
Lua中的函数是可变参的，它可以接收不同的数量的参数。
例如下面的例子，下面的函数返回所有参数的总和：
function add(...)
local s = 0
for i,v in ipairs{...} do
s =s + v
end
return s
end
print(add(3,4,10,25,12)) -->54"..." 表示这个函数是可变参函数。函数体内可以再次使用它表示变参。
可以把"..."表达式称作变参表达式，类似于多重返回值函数。
local a,b = ...
同样的，上面的命令创建了两个用变参的前两个参数初始化的变量。
实际上，可以通过变长参数模拟Lua中普通的参数传递机制：
function foo(a,b,c)可以转换为：
function foo(...)
local a,b,c = ...
end
下面的函数,它是一个多值恒定函数，简单地返回了所有的参数：
function id(...)
return ...
end
来看看另一个很有用的例子。Lua提供了一个格式化文本函数(string.format)和一个文本输出函数(io.write)。
将两个结合到一个变参函数里：
function fwrite(fmt,...)
return io.write(string.format(fmt,...))
end
注意在”...“前有一个fmt存在，可变参函数可以有任意数量的固定参数，必须放在变参前。
调用 参数
fwrite() fmt = nil, 没有变参
fwrite("a") fmt = "a", 没有变参
fwrite("%d%d",4,5) fmt = "%d%d",变参=4,5为了遍历变参，函数可以使用{...}把变参收集到一个table里。
在一些特殊的场合，变参中可能有一些nil，Lua提供了一个table.pack函数。
该函数接收变长的参数，并且返回一个由变参组成的table表。这个表有一个隐含的n元素，代表这个表的参数总个数。
注意，这个表返回的不一定是一个序列。
下面的函数用table.pack去检测它的参数是否含有nil：
function nonils(...)
local arg = table.pack(...)
for i = i,arg.n do
if arg[i] == nil then
return false
end
end
return true
end
print(nonils(2,3,nil)) -->false
print(nonils(2,3)) -->true
print(nonils()) -->true
print(nonils(nil)) -->false
然而请记住，当变参中没有nil时，{...}要比table.pack方便快捷。
5.3 具名实参
Lua中的参数传递是具有位置性的，调用函数时，参数是按照位置进行匹配。
用os.rename来进行阐述，该函数的作用是改变文件名。通常你会不记得哪个在前，哪个在后。
因此，会希望这个函数能接受两个具有名称的实参，例如：
-- invalid code
rename(old = "temp.lua", new = "temp1.lua")Lua不支持这种语法，但可以稍加改变达到该效果。用table传参。
rename{old = "temp.lua",new = "temp1.lua"}
于是，函数定义如下：
function rename(arg)
return os.rename(arg.old,arg.new)
end
当函数有很多可选参数的时候，这种方式传参非常有用。比如，一个GUI库创建一个窗口的函数，就有很多参数，并且很多参数是可选的。
最好的做法就是用具名实参：
function window (options)
-- check mandatory options 必要参数
if type (options.title ) ~= "string" then
error ( "no title" )
elseif type ( options.width ) ~= "number" then
error ( "no width" )
elseif type ( options.height ) ~= "number" then
error ( "no height" )
end
-- everything else is optional 可选参数
_window (options.title,
options.width,
options.height,
options.x or 0, --default value
options.y or 0, --default value
options.background or "white", --default
options.border -- default is false (nil)
)
end
w = window{ x= 0,y = 0, width = 300,height = 200,
title = "Lua" , background = "blue",border = true
}
window可以自由检查必要参数，也可以添加默认参数。
_window函数实际才是需要所有正确参数来创建一个新窗口。
