09：function用法特性

01：函数的定义
optional_function_scope function function_name( argument1, argument2, argument3…, argumentn)
function_body
return result_params_comma_separated
end

optional_function_scope: 该参数是可选的制定函数是全局函数还是局部函数，未设置该参数默认为全局函数，如果你需要设置函数为局部函数需要使用关键字 local。

function_name: 指定函数名称。

argument1, argument2, argument3…, argumentn: 函数参数，多个参数以逗号隔开，函数也可以不带参数。

function_body: 函数体，函数中需要执行的代码语句块。

result_params_comma_separated: 函数返回值，Lua语言函数可以返回多个值，每个值以逗号隔开。

--函数返回两个值的最大值
function max(num1,num2)
if num1>num2 then
return num1
else
return num2
end
end

print(max(10,20))

02：函数作为数据赋值

sum=max
print(sum(200,100))

03：将函数作为参数传递给函数

myprint=function(parm)
print("打印函数",parm)
end


function add(num1,num2,functionPrint)

result=num1+num2
functionPrint(result)
end


myprint(10)
add(10,10,myprint)
--打印函数	10
--打印函数	20

04：多返回值

function maxNum(a)

return a,2*a;

end

b,c=maxNum(5)
print(b,c)
--打印函数	10
--打印函数	20

05：可选参数
Lua 函数可以接受可变数目的参数，和 C 语言类似，在函数参数列表中使用三点 … 表示函数有可变的参数

--可选参数
function test(...)
local sums={...} --{...} 表示一个由所有变长参数构成的数组  
for k,v in pairs(sums)do
print(v)
end
end
test(4,5,8)

function average(...)
result=0
local arg={...}
for k,v in pairs(arg) do
result=result+v
end
print("总共传入" ..#arg .." 个数")
return result/#arg
end
print(average(4,58,89,99))

06.unpack
unpack( )函数是接受一个数组来作为输入参数，并默认从下标为1开始返回所有元素。

local a={1,2,3,4};
print(unpack(a))
1234

07.具名实参
Lua中的参数机制是具有“位置性”的，也就是说在调用一个函数时，实参是通过它在参数表中的位置与形参匹配起来。但有时通过名称来指定实参也是很有用的。
将所有的实参组织到一个table中，并将这个table作为唯一的实参传给函数，使用时可以通过table查找到需要的值。

function rename_file(arg)
print(arg.old,arg.new);
if type(arg.old) == "string" then
    print("no old name!")
	end

end

rename_file{old = "old.txt", new = "new.txt"}

old.txt	new.txt
no old name!

08.函数是可以作为变量存储的

function foo(x)
print(x)
end

foo1=function(x)
print(x)
end
foo(100);
foo1(100);
100
100

10.局部函数

--函数存储在table中
lib={};
lib.foo=function(x,y)
return x+y;
end

lib.goo=function(x,y)
return x-y;
end
//或者这样
lib={foo=function(x,y) return x+y;end,
goo=function(x,y) return x-y;end }

print(lib.foo(10,10)); --20
print(lib.goo(20,10)); --10

local foo=function (x,y)
return x+y;
end

local function foo(x,y)
return x+y;
end

print(foo(20,20));

11.闭合函数
函数中的局部变量的值在函数调用结束后不消失而保留原值，即其占用的存储单元不释放，在下一次该函数调用时，该变量保留上一次函数调用结束时的值
类似于静态局部变量(static)

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

function sortbyGrade(names,grades)
    table.sort(names,function (n1,n2)
        return grades[n1]>grades[n2];
    end);
end
newTable=sortbyGrade(names,grades);
for i, v in ipairs(names) do
    print(i..':'..v);
end
1:Peter
2:Mary
3:Paul

例子2

--闭合函数
--local i就属于一个非局部变量，因为它既不是全局变量，也不是单纯的局部变量（因为另外一个函数可以用到它）
--再来回到定义，GetCount函数里的那个函数，加上非局部变量i，就构成了一个闭合函数了，就这么简单。
--对于闭合函数而已，属于它的非局部变量，并不是在调用它的时候临时产生的，而是和它一起存在的。
--所以每次调用闭合函数，非局部变量的值都不会被重置
function GetCount()
    local i=0;
    return function()
        i=i+1;
        return i;
    end
end

co1=GetCount(); --非局部变量i是和变量co1一起存在的不是临时产生的
co2=GetCount();

print(co1());--1
print(co1());--2
print(co1());--3
print("..............");
print(co2());--1
print(co2());--2
print(co2());--3

i非局部变量下

function Count()
    return function()
       local i=9;
        i=i+1;
        return i;
    end
    end
co3=Count();
print(co3());--10
print(co3());--10
print(co3());--10

12.非全局函数
函数名称其实也是一个变量名
在编译的时候，mutou函数是编译不过的，因为这个时候pangbai函数未定义，换句话说，pangbai变量并不存在。
只要换一个方式就可以解决这个问题了：

local mutou;
local pangbai;

mutou= function ()

    print("mutou");
    pangbai();
end

pangbai= function()
    print("pangbai");
end
mutou();
--mutou
--pangbai

13.在table语法相结合来创建局部函数

lib={};
--常规的函数语法
lib.foo=function()
   print("foo")
end
--构造式来创建局部函数：
--lib={goo=function() print("goo") end}

--其它
function lib.koo()
    print("koo");
end

function lib.Joo()
    print("Joo");
end
lib.foo(); --foo
lib.koo(); --koo
lib.Joo(); --Joo