Lua基础：函数

函数有两种用途：1.完成指定的任务，这种情况下函数作为调用语句使用；

                                2.计算并返回值，这种情况下函数作为赋值语句的表达式使用。

                                function func_name (arguments-list) 
                                      statements-list; 
                                end; 

Lua 函数可以返回多个结果值，比如 string.find，其返回匹配串“开始和结束的下标”

1. s, e = string.find("hello Lua users", "Lua") 
2. print(s, e) --> 7 9 
3. -----------------------------------------------------------------
4. function maximum(a)             --函数function修饰
5.     local mi=1                          --局部变量
6.     local m=a[mi]                    
7.     for i,val in ipairs(a) do         --泛型for循环
8.         if val > m then                  --if语句
9.             mi=i
10.             m=val
11.         end
12.     end
13.     return m,mi                    --返回值
14. end
15. print(maximum({8,10,23,12,5}))  --调用函数，打印结果

可变参数：...参数的个数可以是0个或者多个

1. printResult=""
2. --重写print函数
3. function printf(...)
4.     for i,v in ipairs(arg) do     --Lua将参数放在arg列表中
5.         printResult=printResult .. tostring(v) .. "\t"
6.     end
7.     printResult=printResult .. "\n"
8.     print(printResult)
9. end
10.  
11. printf(3)
12. printf(3,4)
13. printf(3,4,5,8)

命名参数：可以将参数放在表中，把表作为参数rename{old="temp.lua", new="temp1.lua"} 

1. function rename(arg)
2.     return os.rename(arg.old,arg.new)
3. end
4. rename{old="a.bat",new="b.bat"}  --传递表作为参数

匿名函数：函数可以没有名字，函数可以放在变量中，也可放到表中，可以作为参数，可以作为返回值

1. a={p=print}
2. a.p("Hello world")
3. --------------------------------------------------------
4. network={                --表
5.     {name="grauna",IP="210.26.30.34"},
6.     {name="arraial",IP="210.26.30.23"},
7.     {name="lua",IP="210.26.23.12"},
8.     {name="derain",IP="210.26.23.20"}
9. }       
10.  
11. for k,v in ipairs(network) do    
12.     print(tostring(v.name .. ":" .. v.IP));          --排序前
13. end          
14. table.sort(network,function(a,b)          --函数作为参数，根据name排序
15.                         return (a.name>b.name)
16.                     end)
17.  
18. for k,v in ipairs(network) do
19.     print(tostring(v.name .. ":" .. v.IP));   --排序后
20. end
21.  

当一个函数内部嵌套另一个函数定义时，内部的函数体可以访问外部的函数的局部变量，这种特征我们称作词法定界。

1. names={"Peter","Paul","Mary"}
2. grades={Mary=10,Paul=7,Peter=8}
3.  
4. function sortbygrade(names,grades)
5.     table.sort(names,function(n1,n2)         --sort()可以访问外部函数的参数grades
6.             return grades[n1]>grades[n2]
7.     end)
8. end

闭包是一个函数加上它可以正确访问的 upvalues。闭包指值而不是指函数，函数仅仅是闭包的一个原型声明

1. function newCounter()
2.     local i=0
3.     return function()  --匿名函数，使用upvalue i保存值，
4.         i=i+1
5.         return i
6.     end
7. end
8. c1=newCounter()    --调用newCounter()创建一个变量i的闭包
9. print(c1())
10. print(c1())
11. c2=newCounter()     --c1、c2 是建立在同一个函数上，但作用在同一个局部变量的不同实例上的两个不同
    的闭包。c1，c2结果互不干扰。
12. print(c2())
13. print(c1())
14. print(c2())

非全局函数：Lua 中函数可以作为全局变量也可以作为局部变量

1. local fact             
2. fact=function(n)
3.     if n==0 then
4.         return 1
5.     else
6.         return n*fact(n-1)
7.     end
8. end
9. print(fact(5))

尾调用：是一种类似在函数结尾的 goto 调用，当函数最后一个动作是调用另外一个函数时，我们称这种调用尾调用。

1. local f,g
2. function g()
3.     f()             --不需要返回值给g()
4. end
5. function f()
6.     g()
7. end