Lua 数据类型 —— 函数
一、函数结构
1、声明
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 语言函数可以返回多个值，每个值以逗号隔开。
入参的行为
print("参数局部变量：")
function params(a, b)
print("函数内部，未改变值：", a, b) --> 函数内部，未改变值： 1 2
a = 10
b = 100
print("函数内部，未改变值：", a, b) --> 函数内部，未改变值： 10 100
end
local a = 1
local b = 2
print("入参前：", a, b) --> 入参前： 1 2
params(a, b)
print("入参后：", a, b) --> 入参后： 1 2
2、使用
函数的调用和 java 、 kotlin 没有区别
只是如果函数只有一个参数，且该参数类型是 字符串常量 或是 表构造器 ，则括号是可选，只需隔开一个空格。
-- 等同于 print("function")
print "function" --> function
-- 等同于 dofile("字符串.lua")
dofile "字符串.lua"
-- 等同于 type({})
print(type {}) --> table
二、入参
1、入参个数
参数个数没有规定一定要和函数声明的个数一致，多余会被抛弃，不足参数会被设置为 nil .
function multiParams(p1, p2, p3, p4, p5)
print(p1, p2, p3, p4, p5)
end
multiParams() --> nil nil nil nil nil
multiParams(1) --> 1 nil nil nil nil
multiParams(1, 2) --> 1 2 nil nil nil
multiParams(1, "jiang", 2) --> 1 jiang 2 nil nil
multiParams(1, "jiang", 2, "peng") --> 1 jiang 2 peng nil
multiParams(1, "jiang", 2, "peng", 3) --> 1 jiang 2 peng 3
multiParams(1, "jiang", 2, "peng", 3, "yong") --> 1 jiang 2 peng 3
可以利用这一特性，加上 a or 默认值 达到默认值
local globalCounter = 0
function initGlobal(n)
n = n or 1
globalCounter = globalCounter + n;
end
initGlobal()
print(globalCounter) --> 1
initGlobal(10086)
print(globalCounter) --> 10087
2、使用 … 接收可变参数
2-1、使用列表进行装载可变长参数
使用 ... 进行接收可变长参数函数，用 {} 装载则将其转为列表，值得注意的是，这里每次调用都会创建一个临时的表
和 kotlin 一样，
_可以避免无用参数取名
function add(...)
local total = 0
for _, v in ipairs { ... } do
total = total + v;
end
return total
end
print(add(3, 4, 10, 25, 12)) --> 54
-- 如果存在 nil ， 则后面的就不再继续，因为使用的是 ipairs ， 使用 paris 就不会
print(add(3, 4, 10, nil, 25, 12)) --> 17
可以将 ... 当作多值返回（见下一小节）来使用，直接将其赋值给变量
-- ... 和多值返回类似，可以用多值返回的所有操作
-- 多的会被舍弃，少的用 nil 补充
function foo(...)
local a, b, c = ...
print(a, b, c, "size: " .. #{ ... })
end
foo("a") --> a nil nil size: 1
foo("a", "b") --> a b nil size: 2
foo("a", "b", "c") --> a b c size: 3
foo("a", "b", "c", "d") --> a b c size: 4
foo("a", "b", nil, "c", "d", nil) --> a b nil size: 5 -- 这里的最后一个元素 `nil` 则会被忽视，如果需要被计算则需要用 `table.pack()`
2-2、使用 select 解析可变长参数
nil 也会被认为是元素
当第一个参数 selector 是数值时，表示从哪个下标开始截取。（开始下标是 1 ）
当第一个参数是 # 时，则表示获取长度（ nil 也会被包括在内）。
print(select(1, "a", "b", "c")) --> a b c
print(select(1, "a", "b", nil, "c")) --> a b nil c
print(select(2, "a", "b", "c")) --> b c
print(select(3, "a", "b", "c")) --> c
print(select(4, "a", "b", "c")) --> “空”
print(select("#", "a", "b", "c")) --> 3
-- nil 也会被计算
print(select("#", "a", "b", nil, "c", nil)) --> 5
可以使用 select 进行遍历处理
function add1(...)
local s = 0
for i = 1, select("#", ...) do
-- 此处的 select 只会使用 i 下标的值
s = s + select(i, ...)
end
return s
end
print(add1(1, 2, 3, 4, 5))
2-3、{ … } 和 select 的区别
两种都可以进行遍历元素。
在元素比较少的情况下， select 会快一些，可以避免每次都创建临时新表
元素较多的情况下，则 { … } 会快一些
3、… 行为和多值返回行为一样
可以进行多值赋值，多的参数会被抛弃，少的用 nil 补充
对于所有的函数入参都可以使用可变长参数接收，基于这一特性，我们可以使用以下函数进行跟踪一些入参，调试的时候很有用
function showParams(fun, ...)
print(...)
return fun(...)
end
-- 使用
print(showParams(add, 1, 2, 3, 4, 5))
--> 1 2 3 4 5
--> 15
4、和固定参数混用
可变参数可以和固定参数一起使用，则像 kotlin 、 java 一样，需要将固定参数放在函数参数的最前面。
三、多值返回
函数可以在 return 中返回多个值
- 函数只是作为一条单独语句使用，则所有返回值会被舍弃。（即不需要其返回值）
- 如果函数被当作表达式（加法等操作，字符连接），则只会使用第一个返回值。（因为此处只需要一个值，所以只取第一个返回值）
- 函数被当作多重赋值、函数调用时传入的实参列表、表构造器、return语句时，多值返回才会被获取。
遵循几个规则：
- 赋值时，参数多了会被舍弃，少了会用 nil 进行赋值
- 多值返回函数只有作为最后一个表达式时，才会使用每个返回值，否则只使用第一个。无论是在多重赋值，还是在函数入参，表构造器都是一样的。
可以使用增加括号，让多值返回变为只有一个值返回。
举亿个例子
function f0()
return
end
function f1()
return "jiang"
end
function f2()
return "peng yong", 28
end
获取多值返回
-- 多余的返回值会被舍弃
value = f2()
print(value) --> a
-- 按顺序进行赋值，多余的返回值会被舍弃，少的则会用 nil
value1, value2, value3 = 10, f2()
print(value1, value2, value3) --> 10 a 1
value4, value5, value6, value7 = 10, f2()
print(value4, value5, value6, value7) --> 10 a 1 nil
-- 如果多值返回不是最后一个表达式，则只会使用一个，这个原理同样适用于函数调用入参
value8, value9, value10 = f2(), 10
print(value8, value9, value10) --> a 10 nil
---- f0 返回 nil 赋值给 value11 ， 而 10001 多了一个参数则被舍弃
value11, value12 = f0(), 10000, 10001
print(value11, value12) --> nil 10000
将多值返回当作入参
function params(param1, param2, param3)
print("params:" .. param1 .. "," .. param2 .. ",", param3)
end
---- 唯一一个入参，则会将所有的返回值作为入参
params(f2()) --> params:peng yong,28, nil
-- f2() 虽然返回两个参数，但是因为不是 最后一个参数（也不是唯一一个参数） 所以只会使用第一个返回值，则这里只是入参了两个参数
params(f2(), 10000) --> params:peng yong,10000, nil
---- f2() 最后一个参数，所以会进行多返回值展开，将所有的 f2() 返回值当作入参，所以这里就有三个入参值
params(10001, f2()) --> params:10001,peng yong, 28
-- 多值返回和其他的运算操作只会使用第一个返回值
print(f2() .. 1) --> peng yong1
-- 可以作为表的构造器，但也遵循同样的规则，只有作为最后一个表达式，才会使用所有返回值
t1 = { f2() }
t2 = { f2(), "jiang pengyong" }
showTable(t1) --> [1]=peng yong, [2]=28,
showTable(t2) --> [1]=peng yong, [2]=jiang pengyong,
使用括号屏蔽多值返回，则只会使用第一个返回值
-- 使用括号，强制只返回一个值，f2() 则只有第一个返回值被使用，其他的被省略
print((f2())) --> peng yong
五、table.pack 和 table.unpack
1、table.pack
如果 {...} 中包含有 nil ，则不再是一个有效的序列。 table.pack (5.2 引入) 会将所有的参数（包括 nil），保存到一个 table 中并返回，而且会有一个额外的字段 “n” 用于保存参数个数 。
function noNils(...)
local arg = table.pack(...)
local argValue = ""
for i = 1, arg.n do
argValue = argValue .. (arg[i] or "nil") .. " ,";
end
print("arg [" .. argValue .. "] size:" .. arg.n)
for i = 1, arg.n do
if arg[i] == nil then
return false
end
end
return true
end
-- 使用
print(noNils(2, 3, nil)) --> arg [2 ,3 ,nil ,] size:3 false
print(noNils(2, 3)) --> arg [2 ,3 ,] size:2 true
print(noNils(2, nil, 3)) --> arg [2 ,nil ,3 ,] size:3 false
print(noNils()) --> arg [] size:0 true
print(noNils(nil, nil)) --> arg [nil ,nil ,] size:2 false
2、table.unpack
作用是将 table 转换为一组返回值，可以作为函数的入参
unpack 函数的重要用途之一体现在泛型调用，泛型调用允许我们动态地调用具有任意参数的任意函数。
两种使用方式
table.unpack(table) 将 table 进行展开，作为多值返回
table1 = { "jiang", "peng", "yong", "xiao" }
print(table.unpack(table1)) --> jiang peng yong xiao
table.unpack(table, startIndex, endIndex) 截取 table 的 startIndex 至 endIndex 区间的 item ，进行返回 ( [startIndex, endIndex] )
table1 = { "jiang", "peng", "yong", "xiao" }
print(table.unpack(table1, 2, 3)) --> peng yong
值得注意的是 table.unpack 使用长度操作符获取返回值的个数，因而该函数只能用于序列。
动态调用
这样其实就可以动态的进行调用代码，将上面的稍作修改，可以通过将 print 赋予给变量在进行调用
f = print
f(table.unpack(table1)) --> jiang peng yong xiao
用 Lua 实现一个简易的 table.unpack 函数
真正的 table.unpack 是由 c 进行编写，也可以用递归进行编写一个类似的
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
print(unpack(table1)) --> jiang peng yong xiao
print(unpack(table1, 2, 3)) --> peng yong
六、尾调用
1、作用
尾调用的作用不会使用额外的栈空间（这种实现称为尾调用消除）
因为当被调的函数执行结束后，程序就不再需要返回最初的调用者。
例如以下函数，当调用了 f 函数，f 函数执行完成 g 函数后，不再需要返回 f 函数，而是直接返回到调用 f 函数的地方。
function f(x)
x = x + 1;
return g(x);
end
由于尾调用函数不会使用栈空间，所以一个程序中能够嵌套的尾调用数量是无限的。
2、如何界定是否为尾调用函数
只有形如 return func(args) 的调用才算。
func 及其参数都可以有复杂的表达式，这些复杂的表达式会被先进行计算完之后才进行调用。
举些例子
下面的代码不是尾调用，因为 f 在返回前，还需要对 g 函数的返回进行结果丢弃。
function f(x)
g(x)
end
下面的代码不是尾调用，因为 g 函数的返回值还需要进一步处理（因为加了括号，会只使用一个返回值，所以也会进行舍弃多余的值），才能成为真正的返回值
return g(x) + 1
return x or g(x)
return (g(x))
下面的代码是尾调用，因为这里的 x[j] + a*b, i+j 可以先进行计算，x[i].foo 这里也是先获取，然后最后再进调用，所以无需在返回
return x[i].foo(x[j] + a*b, i+j)
七、写在最后
Lua 项目地址：Github传送门 (如果对你有所帮助或喜欢的话，赏个star吧，码字不易，请多多支持)
公众号搜索 “江澎涌” 可以更快的获取到后续的更新文章