Lua极简入门指南（一）：函数篇

Lua 和其他很多语言一样，函数调用时参数列表被包裹在括号中：

print('Hello World')

特别的情况是，如果函数调用时只有一个参数，并且此参数为字符串 literal（字面量）或者 table 构造器（constructor）时，包裹参数的括号可以省略：

print 'Hello World' <--> print('Hello World')

type{}              <--> type({})

Lua 为面向对象的调用提供了特殊的语法：

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

Lua 调用的函数可能被定义在 Lua 中，也可能被定义在 C 中（Lua 标准库中的所有函数都使用 C 编写）。

函数的定义

function add(a)

    local sum = 0

    for i = 1, #a do

        sum = sum + a[i]

    end

    return sum

end

 

print(add{1, 2, 3})

函数调用时，实参（arguments）和形参（parameters）个数可以不匹配，多余的实参会被丢弃，多余的形参值为 nil，例如：

function f(a, b) print(a, b) end

f(3)         --> 3 nil

f(3, 4)      --> 3 4

f(3, 4, 5)   --> 3 4

函数多值返回

在 Lua 中函数可以返回多个值。例如：

function maximum(a)

    local mi = 1

    local m = a[mi]

    for i = 1, #a do

        if a[i] > m then

            mi = i; m = a[i]

        end

    end

    return m, mi

end

 

print(maximum{8, 10, 23, 12, 5})

在多赋值时，多余的值会被丢弃，不足时变量值为 nil：

x, y = 1        --> x == 1, y == nil

x, y = 1, 2, 3  --> x == 1, y == 2

在函数调用时形参的值处理上，在函数返回值的获取上，都遵循这个规则。例如：

function foo0() end

function foo1() return 'a' end

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

 

x, y = foo2()         --> x == 'a', y == 'b'

x = foo2()            --> x == 'a'

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

 

t = { foo2() }        --> {'a', 'b'}

再看一个例子：

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

x, y = foo2(), 20    --> x == 'a', y == 20

这里，由于函数调用不是在列表的最后一个位置，这时候函数只提供一个值。一个更有意义的例子：

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

 

print(foo2())     --> a b

print(foo2(), 1)  --> a 1

如果函数调用在列表的最后一个位置，同时使用 () 包裹函数调用，这时候函数也只提供一个值：

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

 

print(foo2())     --> a b

print((foo2()))   --> a

一个比较有用的利用函数多值返回的特性的函数是 table.unpack，它接受一个数组作为参数，返回数组中的所有元素：

print({10, 20, 30})               --> table: 00000000005BBE00

print(table.unpack{10, 20, 30})   --> 10 20 30

变长参数

我们在使用 print 函数的时候可以传递任意数目的参数。Lua 提供了 … 表示参数列表，让我们实现类似 print 的函数：

function add(...)

    local s = 0

    for _, v in ipairs{...} do

        s = s + v

    end

    return s

end

 

print(add(3, 4, 5))  --> 12

再一个例子：

function test(...)

    local a, b = ...

    print(a, b)

end

 

test(1, 2, 3)  --> 1 2

还有一个特殊情况，我们需要注意：

function p(...)

    for _, v in ipairs{...} do

        print(v)

    end

end

 

p(1, nil, 3)      --> 1

print(1, nil, 3)  --> 1 nil 3

上例可以看到，我们的 p 函数在参数中存在 nil 时并非按我们的意愿输出了结果。Lua 提供了一个 table.pack 函数，用于获取其调用参数（包括 nil 参数）并返回一个包含所有参数的 table，此 table 存在一个额外的域 n，用于表示参数的数量：

function p(...)

    local arg = table.pack(...)

    for i = 1, arg.n do

        print(arg[i])

    end

end

 

p(1, nil, 3, nil)  --> 1 nil 3 nil

不过需要注意的是，{…} 相比 table.pack(…) 来说更加高效，我们可以在确保没有 nil 参数的时候使用。

函数是第一类值（first-class values）

我们能够像使用其他变量一样的使用函数：

a = { p = print }

a.p('Hello World')  --> Hello World

print = math.sin

a.p(print(1))       --> 0.8414709848079

类似于 {} 作为 table 的构造器，我们可以认为 function(x) end 为函数的构造器：

local add = function(a, b)

    return a + b

end

 

print(add(1, 2))

 

-- 另一种写法

local function add(a, b)

    return a + b

end

table.sort 函数用于排序，它可以接受一个排序函数作为参数：

network = {

    { name = "grauna", IP = "210.26.30.34" },

    { name = "arraial", IP = "210.26.30.23" },

    { name = "lua", IP = "210.26.23.12" },

    { name = "derain", IP = "210.26.23.20" },

}

 

print('--------------')

for _, v in ipairs(network) do

    print(v.name)

end

 

table.sort(network, function(a, b)

    return a.name > b.name

end)

 

print('--------------')

for _, v in ipairs(network) do

    print(v.name)

end

输出结果为：

--------------

grauna

arraial

lua

derain

--------------

lua

grauna

derain

arraial

在此例中，我们提供的排序函数作为一个参数传递给 table.sort 函数，像此排序函数这样没有名字的函数被叫做匿名函数。

闭包（closures）

很多语言都支持闭包（Golang、JavaScript 等）。一个函数和其访问的外部变量组成一个闭包。看一个例子：

function newCounter()

    local i = 0

    return function()

        i = i + 1

        return i

    end

end

 

c1 = newCounter()

print(c1())   --> 1

print(c1())   --> 2

这里的 c1 就是一个闭包（外部变量为 i），每次调用 newCounter 都会创建一个闭包（并创建一个新的html" target="_blank">变量 i）：

c2 = newCounter()

print(c2())   --> 1

print(c1())   --> 3

print(c2())   --> 2