函数
- 函数是对语句和表达式进行抽象的主要机制
两种用法
- 一是可以完成特定的任务，一句函数调用被视为一条语句
- 二是以只用来计算并返回特定的结果，视为一句表达式
print("Hello, World")
a = math.sin(3) + math.cos(10)
print(os.date())
- 无论哪种用法都需要将所有参数放到一对圆括号中
- 但如果参数是字面字符串或 table 构造式的话，可以放在括号中，也可以不放
- 即使在调用函数时没有参数，也必须有一个 () 空括号，如调用 os.date()
print "Hello, World" -- 等价于 print("Hello, World")
print {1, 2, 3} -- 等价于 print({1, 2, 3})
function add(a)
local sum = 0
for i, v in ipairs(a) do
sum = sum + v
end
return sum
end
b = {1, 2, 3}
add(b)
- function 是定义函数的关键字
- add 是函数名
- a 是函数的形式参数，是函数定义式参数列表中的参数
- add(b) 调用这个函数所传入的参数称为实际参数
- 调用函数的实际参数的个数可以与函数定义时的形式参数个数不同
- lua 会自动调整实参的数量，以匹配参数表的要求，这和多s重赋值类似
- 若实参少于形参，多余的形参被初始化为 nil
- 若实参多余形参，多余的实参被抛弃
- lua 程序既可以使用 以 lua 编写的函数，也可使用 C 语言编写的函数
function f(a, b)
return a or b
end
f(3) -- a = 3, b = nil
f(3, 4) -- a = 3, b = 4
f(3, 4, 5) -- a = 3, b = 4 ,5 被丢弃了
定义一个全局的计数器
function intCount(n)
n = n or 1 -- 赋值一个默认值
count = count + 1
end
面向对象式调用函数
- o.foo(o, x)
- o:foo(x) 等价于 o.foo(o, x)
- 冒号操作符使得我们在调用 o.foo 时隐含地将 o 作为函数的第一个参数
多重返回值
- lua 允许函数返回多个结果
- 如标准库中的一些预定义函数
-- 用于在字符串中定位一个模式的函数 string.find
print(string.find("Hello Lua users", "Lua")) -- 开始的位置 7, 结束的位置 9
- 在 return 后列出需要返回的所有值即可，用 , 逗号分隔
-- 查找数组中的最大元素，并返回这个元素的所在位置
function maximum(a)
local mi = 1 -- 最大值的索引
local max = a[mi] -- 最大值
for i,v in ipairs(a) do
if v > max then
mi = i
max = v
end
end
return max, mi
end
maximum(a) -- 没有任何反应
print(maximum({3, 4, 23, 5, 7}) -- 23 3
print(maximum({3, 4, 23, 5, 7} .. "a") -- 23a
- 如果将函数调用作为单独的语句执行，lua 会丢弃所有的返回值
- 如果将将函数作为表达式的一部分调用，只保留函数的第一个返回值
- 只有当函数是一系列表达式中的最后一个元素（或只有一个元素的时候），才会获取所有的返回值
一系列表达式在 Lua 中的 4 中情况
- 多重赋值
- 函数调用时传入的实参列表
- table 构造式
- return 语句
多重赋值
- 在多重赋值中，如果一个函数调用是最后（或仅有）的一个表达式，lua 会保留尽可能多的返回值，用来匹配赋值的变量
- 如果一个函数没有返回值或没有返回足够多的返回值，那么 lua 会用 nil 来补充缺失的值
- 如果一个函数调用不是一系列表达式中的最后一个元素，就只能返回一个值
- 如果一个函数调用作为另一个函数调用的最后一个（或仅有的）实参的时候，第一个函数的所有返回值都会作为实参传递给另一个函数
function foo0() end
function foo1() return "a" end
function foo2() return "a", "b" end
-- 多重赋值的4种情况
-- 第一种情况
x, y = foo2() -- x = "a" , y = "b"
x = foo2() -- x = "a"
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
-- 第四种情况
print(foo0()) -- 不会打印任何值
print(foo1()) -- a
print(foo2()) -- a, b
print(foo2(), 20) -- a, 1
print(foo2() .. "x") -- ax
table 构造式
- table 构造式可以完整地接收一个函数调用的所有结果，即不会有任何数量方面的调整
- 但这种行为，只有当一个函数调用作为最后一个元素时才会发生
- 其他位置上的函数调用总是只产生一个结果值
function foo0() end
function foo1() return "a" end
function foo2() return "a", "b" end
t = {foo2()} -- t = {"a", "b"}
t = {foo2(), "x"} -- t = {"a", "x"}
return
- 将函数调用放入一对圆括号 () 中，使其只返回一个结果
- return 语句后面的内容不需要 () 圆括号
- 如果强行加上则会使一个多返回值的函数，强制其只返回一个 return(f())
function foo0() end
function foo1() return "a" end
function foo2() return "a", "b" end
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)) -- 无返回值
-- () 包裹
print((foo(1)) -- a
print((foo(2)) -- a
print((foo(0)) -- nil 不太懂为什么
unpack 函数
- 接收一个数组作为参数
- 并从下标 1 开始返回该数组的所有元素
- 这个预定义函数由 C 语言编写
print(unpack{10, 20, 30}) -- 10 20 30
a, b = unpack{10, 20, 30} -- a = 10, b = 20
- 用于泛型调用
- 泛型调用就是可以以任何实参来调用任何函数
-- 调用任意函数 f, 而所有的参数都在数组 a 中
-- unpack 将返回 a 中的所有值，这些值作为 f 的实参
f(unpack(a))
f = string.find
a = {"hello", "ll"}
f(unpack(a)) -- 3 4 等效于 string.find("hello", "ll")
用 lua 递归实现 unpack
function unpack(t, i)
i = i or 1
if t[i] then
return t[i], unpack(t, i + 1)
end
end
变长参数
- lua 中的函数可以接收不同数量的实参
- 当这个函数被调用时，它的所有参数都会被收集到一起
- 这部分收集起来的实参称为这个函数的「变长参数」
- ... 3个点表示该函数接收不同数量的实参
- 一个函数要访问它的变长参数时，需要用 ... 三个点，此时 ... 三个点是作为一个表达式使用的
- 表达式 ... 三个点的行为类似一个具有多重返回值的函数，它返回的是当前函数的所有变长参数
- 具有变长参数的函数也可以拥有任意数量的固定参数
- 但固定参数一定要在变长参数之前
- 当变长参数中包含 nil ，则需要用 select 访问变长参数
- 调用 select 时，必须传入一个固定参数 selector(选择开关) 和一系列变长参数
- 如果 selector 为数字 n ，那么 select 返回它的第 n 个可变实参
- 否则，select 只能为字符串 "#" ，这样 select 会返回变长参数的总数，包括 nil
-- 返回所有参数的和
function add(...)
local s = 0
for i, v in ipairs{...} do -- 表达式{...}表示一个由变长参数构成的数组
s = s + v
end
return s
end
print(add(3, 4, 5, 100)) -- 115
-- 调试技巧 ,类似与直接调用函数 foo ，但在调用 foo 前先调用 print 打印其所有的实参
function foo1(...)
print("calling foo:", ...)
return foo(...)
end
-- 获取函数的实参列表
function foo(a, b, c) end
function foo(...)
local a, b, c = ...
end
-- 格式化文本 string.format ，输出文本 io.write
-- 固定参数一定要在变长参数之前
function fwrite(fmt, ...)
return io.write(string.format(fmt, ...))
end
fwrite() -- fmt = nil
fwrite("a") -- fmt = a
fwrite("%d%d", 4, 5) -- fmt = "%d%d" , 变长参数 = 4, 5
for i = 1, select('#', ...) do
local arg = select('#', ...)
<循环体>
end
具名参数
- lua 中的参数传递机制是具有 「位置性」的
- 就是说在调用一个函数时，实参是通过它在参数表中的位置与形参匹配起来的
- 第一个实参的值与第一个形参相匹配，依此类推
- 定义：通过名称来指定实参
- 可将所有的实参组织到一个 table 中，并将这个 table 作为唯一的实参传给函数
- lua 中特殊的函数调用语法，当实参只有一个 table 构造式时，函数调用中的圆括号是可有可无的
os.rename -- 文件改名,希望达到的效果 os.rename(old = "temp.lua", new = "temp1.lua")
-- lua 不支持注释的写法
rename = {old = "temp.lua", new = "temp1.lua"}
function rename (arg)
return os.rename(arg.old, arg.new)
end
x = Window{x = 0, y = 0, width = 300, height = 200, title = "Lua", background = "blue", border = "true"}
-- Window 函数根据要求检查必填参数，或为某些函数添加默认值
-- 假设 _Window 是真正用于创建新窗口的函数，要求所有参数以正确次序传入
function Window(options)
if type(options.title) ~= "string" then
error("no title")
elseif type(options.width) ~= "number" then
error("no width")
elseif type(options.height) ~= "height" then
error("no height")
end
_Window(options.title,
options.x or 0 -- 默认值
options.y or 0 -- 默认值
options.width, options.height,
options.background or "white" -- 默认值
options.border -- 默认值为 false(nil)
)
