Lua学习笔记（五）：函数

---

1 Lua中的函数定义

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

lua中函数的语法：

function func_name (arguments-list)
    statements-list
end

调用函数时，如果参数列表为空，则必须使用()表明是函数调用。该规则有一个例外，即：当函数只有一个参数并且这个参数是字符串或者table时，()可有可无：

print "Hello World"     <-->        print("Hello World")
f{x = 10, y = 20}       <-->        f({x = 10, y = 20})

此外，Lua也提供了面向对象方式调用函数的语法：

o:foo(x)                <-->        o.foo(o, x)

2 多返回值

Lua的函数中，可以返回多个结果值，只需要在return后列出要返回的值的列表即可：

function getMax(a)
    local idx = 1
    local m = a[idx]
    for i, val in ipairs(a) do
        if val > m then
            idx = i
            m = val
        end
    end
    
    return idx, m
end

Lua会调整函数返回值的个数以适用调用环境，其规则可以归纳为多舍少补nil。特别的，当函数作为独立的调用语句使用时，返回值将被忽略。
以下几种情况需要注意：

function foo0 () end
function foo1 () return 'a' end
function foo2 () return 'a', 'b' end

1. 函数作为表达式调用函数时，如果是最后一个参数，需要遵循多舍少补nil的规则；若不是，则只返回第一个返回值；

x, y, z = foo2()        -- x = 'a', y = 'b', z = nil
x, y, z = 10, foo2()    -- x = 10, y = 'a', z = 'b'
x, y, z = foo2(), 20    -- x = 'a', y = 20, z = nil

2. 函数作为函数的参数被调用时，与1相同；
3. 函数在表的构造函数中初始化时，与1相同；

print(foo2())           <-->        a   b
print(1, foo2())        <-->        1   a   b
print(foo2(), 1)        <-->        a   1
print(foo2() .. x)      <-->        ax

a = {foo2()}                        <-->    a = {'a', 'b'}
a = {1, foo2()}                     <-->    a = {1, 'a', 'b'}
a = {foo2(), 1}                     <-->    a = {'a', 1}
a = {foo0(), foo1(), foo2(), 1}     <-->    a = {nil, a, a, 1}

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(0))       --  (no result)
print(foo(1))       --> a
print(foo(2))       --> a   b
print(foo(3))       --  (no result)

5. 可以使用圆括号强制调用函数只返回一个值；

print((foo(0)))     --> nil
print((foo(1)))     --> a
print((foo(2)))     --> a

6. unpack函数，接受一个数组作为输入参数，返回数组的所有元素。

f = string.find
a = {"hello", "ll"}
print(f(unpack(a)))     --> 3   4

3 可变参数

在函数参数列表中使用三点(...)表示函数有可变参数

Lua将函数的可变参数放在arg表中，此表还有一个域n表示参数的个数。
我们也可以在几个固定参数后加上可变参数。

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}

举个例子。如果我们只想要string.find的第二个返回值，典型的方法是使用哑元（dummy variable，一般使用下划线）：

local _, x = string.find(s, p)

还可以利用可变参数声明一个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的所有可变参数：

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

4 命名参数

Lua的函数参数，是和位置相关的，调用时实参会按顺序依次传给形参。

---