Lua函数 | 易学教程

函数

函数有两种用途：1.完成指定的任务，这种情况下函数作为调用语句使用；2.计算并返回值，这种情况下函数作为赋值语句的表达式使用。
语法：

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

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

print(8*9, 9/8) 
a = math.sin(3) + math.cos(10) 
print(os.date())

上述规则有一个例外，当函数只有一个参数并且这个参数是字符串或者表构造的时候，()是可选的：

print "Hello World" <--> print("Hello World") 
dofile 'a.lua' <--> dofile ('a.lua') 
print [[a multi-line <--> print([[a multi-line 
 message]] message]]) 
f{x=10, y=20} <--> f({x=10, y=20}) 
type{} <--> type({})

Lua 也提供了面向对象方式调用函数的语法，比如 o:foo(x)与 o.foo(o, x)是等价的，后面的章节会详细介绍面向对象内容。

Lua 使用的函数可以是 Lua 编写也可以是其他语言编写，对于 Lua 程序员来说用什么语言实现的函数使用起来都一样。

Lua 函数实参和形参的匹配与赋值语句类似，多余部分被忽略，缺少部分用 nil 补足。

function f(a, b) return a or b end
CALL PARAMETERS 
f(3) a=3, b=nil 
f(3, 4) a=3, b=4 
f(3, 4, 5) a=3, b=4 (5 is discarded)

返回多个结果值

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

s, e = string.find("hello Lua users", "Lua") 
print(s, e) --> 7 9 
Lua 函数中，在 return 后列出要返回的值得列表即可返回多值，如：
function maximum (a) 
local mi = 1 -- maximum index 
local m = a[mi] -- maximum value 
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,23,12,5})) --> 23 3

Lua 总是调整函数返回值的个数去适用调用环境，当作为一个语句调用函数时，所有返回值被忽略。假设有如下三个函数：

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

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

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

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 is discarded

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

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

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

a = {foo0()} -- a = {} (an empty table) 
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()返回的所有值

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

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

函数多值返回的特殊函数 unpack，接受一个数组作为输入参数，返回数组的所有元素。unpack 被用来实现范型调用机制，在 C 语言中可以使用函数指针调用可变的函数，可以声明参数可变的函数，但不能两者同时可变。在 Lua 中如果你想调用可变参数的可变函数只需要这样：

f(unpack(a)) 
unpack 返回 a 所有的元素作为 f()的参数
f = string.find 
a = {"hello", "ll"} 
print(f(unpack(a))) --> 3 4 
预定义的 unpack 函数是用 C 语言实现的，我们也可以用 Lua 来完成：
function unpack(t, i) 
 i = i or 1 
if t[i] then
 return t[i], unpack(t, i + 1) 
end 
end

可变参数

Lua 函数可以接受可变数目的参数，和 C 语言类似在函数参数列表中使用三点（…）表示函数有可变的参数。Lua 将函数的参数放在一个叫 arg 的表中，除了参数以外，arg表中还有一个域 n 表示参数的个数。
例如，我们可以重写 print 函数：

printResult = ""
function print(...) 
for i,v in ipairs(arg) do
 printResult = printResult .. tostring(v) .. "\t"
end 
 printResult = printResult .. "\n"
end 
有时候我们可能需要几个固定参数加上可变参数
function g (a, b, ...) end
CALL PARAMETERS 
g(3) a=3, b=nil, arg={n=0} 
g(3, 4) a=3, b=4, arg={n=0} 
g(3, 4, 5, 8) a=3, b=4, arg={5, 8; n=2}

如上面所示，Lua 会将前面的实参传给函数的固定参数，后面的实参放在 arg 表中。
举个具体的例子，如果我们只想要 string.find 返回的第二个值：
一个典型的方法是使用虚变量（下划线）

local _, x = string.find(s, p) 
-- now use `x' 
... 
还可以利用可变参数声明一个 select 函数：
function select (n, ...) 
return arg[n] 
end 
print(string.find("hello hello", " hel")) --> 6 9 
print(select(1, string.find("hello hello", " hel"))) --> 6 
print(select(2, string.find("hello hello", " hel"))) --> 9

有时候需要将函数的可变参数传递给另外的函数调用，可以使用前面我们说过的unpack(arg)返回 arg 表所有的可变参数，Lua 提供了一个文本格式化的函数 string.format（类似 C 语言的 sprintf 函数）：

function fwrite(fmt, ...) 
return io.write(string.format(fmt, unpack(arg))) 
end

这个例子将文本格式化操作和写操作组合为一个函数。

命名参数

Lua 的函数参数是和位置相关的，调用时实参会按顺序依次传给形参。有时候用名字指定参数是很有用的，比如 rename 函数用来给一个文件重命名，有时候我们我们记不清命名前后两个参数的顺序了：

-- invalid code 
rename(old="temp.lua", new="temp1.lua")

上面这段代码是无效的，Lua 可以通过将所有的参数放在一个表中，把表作为函数的唯一参数来实现上面这段伪代码的功能。因为 Lua 语法支持函数调用时实参可以是表的构造。

rename{old="temp.lua", new="temp1.lua"}

根据这个想法我们重定义了 rename：

function rename (arg) 
return os.rename(arg.old, arg.new) 
end

当函数的参数很多的时候，这种函数参数的传递方式很方便的。例如 GUI 库中创建窗体的函数有很多参数并且大部分参数是可选的，可以用下面这种方式：

w = Window { 
 x=0, y=0, width=300, height=200, 
 title = "Lua", background="blue", 
 border = true
} 
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.x or 0, -- default value 
 options.y or 0, -- default value 
 options.width, options.height, 
 options.background or "white", -- default 
 options.border -- default is false (nil) 
 ) 
end

来源：CSDN

作者：昔拉天使

链接：https://blog.csdn.net/qq_39885372/article/details/104313627

标签

函数调用

lua

string