函数的构建

lua编程语言函数定义格式如下：

1
2
3
4
optional_function_scope function  (argument1,argument2,argument3...,argumentn)
     function_body
     return result_parames_comma_separated
end

【解析】

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

function_name：
指定函数名称

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

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

return_params_comma_separated;
函数返回值，lua语言函数可以返回多个值，每个值以逗号隔开

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

function max(num1,num2)
     if(num1 > num1) then
          a = num1
     else
          a = num2
     end
     return a
end

-- 调用函数
print("两值比较最大值为：",max(10,6))
print("两值比较最大值为：",max(1,6))



=====结果=====
两值比较最大值为：10
两值比较最大值为：6

1
2
3
4
5
6
7
8
9
10
11
12
13
function foo()
     print("true")
end

print(foo)
print(foo())




=====结果=====
function:00000000005DDCA0
true

如果参数列表为空，必须使用()表明是函数调用

如果函数只有一个参数，且为字符串或表结构，()可有可无：print “true”

多返回值

lua函数可以返回多个结果值，在return后列出要返回的值的列表即可返回多值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
function maximum(a)
     local mi = 1
     local m = a[mi]
     for i,val in ipairs(a) do
          if val > m then
               mi = i
               m = val
          end
     end
     return m,mi
end

print(maximum({8,10,11,23,15,5}))




=====结果=====
23     4

lua总是调整函数返回值的个数以适用调用环境，当作为独立的语句调用函数时，所有返回值将被忽略
假设有如下三个函数：

1
2
3
function foo0 () end     -- return no results
function foo1 () return 'a' end     -- retuens 1 result
function foo2 () return 'a','b' end     -- returns 2 results

第一，当作为表达式调用函数时，有以下几种情况：

当调用作为表达式最后一个参数或者仅有一个参数时，根据变量个数函数尽可能多地返回多个值，不足补nil，超出舍去

在其他情况下，函数调用仅返回第一个值（如果没有返回值为nil）

1
2
3
4
5
6
7
8
9
10
11
12
function foo0 () end     -- return no results
function foo1 () return 'a' end     -- retuens 1 result
function foo2 () return 'a','b' end     -- returns 2 results

x,y = foo2()     -- x='a',y='b'
x = foo2()     --x='a','b' is discarded
x,y,z = 10,foo2()     -- x=10,y='a',z='b'
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
x,y = foo0(),20,30     --x='nil',y=20,30

第二，函数调用作为函数参数被调用时，和多值赋值是相同的

1
2
3
4
5
6
7
8
9
function foo0 () end     -- return no results
function foo1 () return 'a' end     -- retuens 1 result
function foo2 () return 'a','b' end     -- returns 2 results

print(foo0())     --
print(foo1())     -- a
print(foo2())     -- a b
print(foo2(),1)     -- a 1
print(foo2() .. "x")     -- ax

第三，函数调用在表构造函数中初始化时，和多值赋值时相同

1
2
3
4
5
6
7
8
function foo0 () end     -- return no results
function foo1 () return 'a' end     -- retuens 1 result
function foo2 () return 'a','b' end     -- returns 2 results

a = {foo0()}     -- a = {}
a = {foo1()}     -- a = {'a'}
a = {foo2()}     -- a = {'a','b'}
a = {foo0(),foo2(),4}     -- a[1] = nil,a[2] = 'a',a[3] = 4

另外，return f()这种形式，则返回”f()的返回值”：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
function foo(i)
     if i == 0 then
          return foo0()
     elseif i == 1 then
          reutrn 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)

可以使用圆括号强制使调用返回一个值

1
2
3
4
5
6
7
function foo0 () end     -- return no results
function foo1 () return 'a' end     -- retuens 1 result
function foo2 () return 'a','b' end     -- returns 2 results

print((foo0()))     -- nil
print((foo1()))     -- a
print((foo2()))     -- a

一个return语句如果使用圆括号将返回值括起来也将导致返回一个值

函数定义

作为表达式调用函数

1
2
3
4
5
6
7
8
9
10
11
local a = f1()
local b,c = f1(),f2()
local e = f3()

print(a,b,c,d,e)




=====结果=====
nil     nil     1     nil     1

解答：当调用作为表达式最后一个参数或者仅有一个参数时，根据变量个数函数尽可能多地返回多个值，不足补nil，超出舍去，其他情况下，函数调用仅返回第一个值(如果没有返回值为nil)

作为函数参数被调用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
print(f1())
print(f2())
print(f3())
print(f1(),f3())
print(f1(),f3(),f2())




=====结果=====
1
1     2
nil     1     2
nil     1     1

解答：

第一行：无输出，在print也会被忽略输出

第二行：输出结果的第一行对应f2()

第三行：f3()有两个结果，所以输出2个结果

第四行：f1()虽然没有输出，但是在逗号前他是被强制输出的，所以有nil值输出

第五行：有逗号间隔，逗号前都被要求输出一个结果，所以f3()只输出第一个返回值

作为表构造函数的初始值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
local t1 = {f1()}
local t2 = {f2()}
local t3 = {f3()}
local t4 = {f1(),f2(),f3()}
print(#t1)
print(#t2)
print(#t3)
print(#t4)




=====结果=====
0
1
2
4

可变参数(三个点表示)

lua将函数的参数放在一个叫arg的表中，除了参数以外，arg表还有一个域n表示参数的个数(lua会将前面的实参传给函数的固定参数，后面的实参放在arg表中)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
function average(...)
     a = 0
     local arg = {...}
     for i,v in ipairs(arg) do
          a = a + v
     end
     print("总共传入"..#arg.."个数")
     return a/#arg
end
print("平均值为："average(10,5,3,4,5,6))




=====结果=====
总共传入6个数
平均值为：     5.5

强制转换

在函数外加上括号()就能实现强制返回一个值

1
2
3
4
5
6
7
8
9
10
11
12
function f()
     return 1,2,3
end
print(f())
print((f()))




=====结果=====
1     2     3
1