Lua 函数

【1】函数定义

Lua函数定义格式如下：

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语言函数可以返回多个值，每个值以逗号隔开。

【2】Lua函数示例

函数示例

--[[ 函数返回两个值的最大值 --]]
local function max(num1, num2)
   if (num1 > num2) then
      result = num1;
   else
      result = num2;
   end

   return result;
end

-- 调用函数
print("两值比较最大值为 (10, 4) :: ", max(10, 4))
print("两值比较最大值为 (5, 6) :: ", max(5, 6))


--[[
两值比较最大值为 (10, 4) :: 10
两值比较最大值为 (5, 6) ::     6
]]

【3】Lua函数特色

（1）将函数作为参数传递给函数。示例如下：

--[[将函数作为参数传递给函数]]
myprint = function(param)
   print("这是打印函数 - ##", param, "##")
end

function add(num1, num2, functionPrint)
   result = num1 + num2
   -- 调用传递的函数参数
   functionPrint(result)
end

myprint(10)
-- myprint 函数作为参数传递
add(2, 5, myprint)

--[[
这是打印函数 - ##    10    ##
这是打印函数 - ##    7    ##
]]

（2）函数可以返回多个值

例1，代码如下：

--[[例如：string.find 其返回匹配串“开始和结束的下标”(如果不存在匹配串返回nil)]]
s, e = string.find("http://www.baidu.com", "baidu")
print(s, e)

--[[执行结果
12    16
]]

s, e = string.find("http://www.google.com", "baidu")
print(s, e)

--[[执行结果
nil    nil
]]

例2，代码如下：

--[[return后列出要返回值的列表即可返回多值]]
function maximum (a)
    local mi = 1             -- 最大值索引
    local m = a[mi]          -- 最大值
    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
]]

例3，特殊函数unpack，它可以接受一个数组作为参数，并从下标1开始返回该数组的所有元素：

print(unpack{10, 20, 30})  -- 10  20  30

（3）不定形参函数

3.1 自定义不定形参函数：Lua函数可以接收可变数目的参数

function add(...)
local s = 0
  for i, v in ipairs{...} do   -- {...} 表示一个由所有变长参数构成的数组
    s = s + v
  end
  return s
end

print(add(3, 4, 5, 6, 7))  -- 25

3.2 将可变参数赋值给一个变量

--[[将可变参数赋值给一个变量]]
function average(...)
   result = 0
   local arg = {...}    -- arg 为一个表，局部变量
   for i,v in ipairs(arg) do
      result = result + v
   end
   print("总共传入 " .. #arg .. " 个数")
   return result / #arg
end

print("平均值为", average(10, 5, 3, 4, 5, 6));

--[[执行结果
总共传入 6 个数
平均值为    5.5
]]

3.3 可以通过select("#", ...来获取可变参数的数量)

--[[可以通过 select("#",...) 来获取可变参数的数量]]
function average(...)
   result = 0
   local arg = {...}
   for i, v in ipairs(arg) do
      result = result + v
   end
   print("总共传入 " .. select("#", ...) .. " 个数")
   return result / select("#", ...)
end

print("平均值为", average(10, 5, 3, 4, 5, 6))

--[[执行结果
总共传入 6 个数
平均值为    5.5
]]

3.4 需要几个固定参数再加上可变参数时，固定参数必须放在可变参数之前

function fwrite(fmt, ...)  -- 固定的参数fmt
    return io.write(string.format(fmt, ...))
end

fwrite("baidu\n")        -- fmt = "baidu", 没有变长参数。
fwrite("%d%d\n", 1, 2)   -- fmt = "%d%d", 变长参数为 1 和 2

--[[执行结果
baidu
12
]]

3.5 遍历变长参数时只需要使用{...}，然而变长参数可能会包含一些nil，那么就需要用select函数来访问变长参数。

[1] select('#', ...)返回可变参数的长度

[2] select(n, ...)用于访问n到select('#', ....)的参数

--[[
遍历变长参数的时候只需要使用{…}，然而变长参数可能会包含一些nil，那么就可以用select函数来访问变长参数了：select('#', …) 或者 select(n, …)
select('#', …) 返回可变参数的长度
select(n, …) 用于访问 n 到 select('#',…) 的参数
]]

do
    function foo(...)
        for i = 1, select('#', ...) do  --> 获取参数总数
            local arg = select(i, ...); --> 读取参数
            print("arg", arg);
        end
    end

    foo(11, 12, 13, 14);
end

--[[执行结果
arg    11
arg    12
arg    13
arg    14
]]

（4）具名实参

具名实参，即具体名称的实参值。比如，字符串拷贝函数有两个参数（src, dest），当我们记不清第一个参数是src还是dest时，可以在调用时明确指明具体实参值。

Lua语言中的rename接口，就是个很有代表性的例子。试着新建一个文件temp.lua，然后复制以下代码段：

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

rename({old = "temp.lua", new = "temp1.lua"})
--rename({new = "new1.lua", old = "temp1.lua"})

注意观察：执行结果，同目录下会多一个temp1.lua文件

再把第六行的注释去掉，然后执行结果：同目录下会多一个new1.lua文件。

（5）待续

【4】深入函数

（1）闭合函数

[1.1] 在Lua中，函数是第一类值

如何理解这个“第一类值”？类比着学习，我们知道C语言的数据类型有整数、浮点数、枚举、指针、数组、结构、共用体、void等等。

前面我们也学习了《Lua数据类型》包括nil、boolean、number、string、function等等。

即就是，在Lua中，函数可以存储到变量（无论全局变量还是局部变量）中或table中，可以作为实参传递给其他函数，还可以作为其他函数的返回值。

先看最常见的这个求和函数定义：

function func(a, b) return a + b end

其等价于

func = function(a, b) return a + b end

两种方式比较：

第一种方式，似乎更符合我们对函数的潜意识（传统的）视觉印象规则。

第二种方式，更彰显了Lua中函数作为“第一类值”的体现和范畴。

通过以上两种方式的对比，我们可以更深入的理解Lua中函数的定义本质：

一个函数定义实质上是一条赋值语句，创建了一种类型为“函数”的值，且将其赋值于变量func。

可以验证一下类型，如下所示：

func = function(a, b) return a + b end
print(func)            -- function: 02DF8FC8
print(type(func))      -- function
print(func(10, 20))    -- 30

在Lua中，将表达式“function(x) <body> end”视为一种函数的构造式，就像table的构造式{ }一样。

将这种函数构造式的结果称为一个“匿名函数”，虽然一般情况下，会将函数赋予全局变量，即给予其一个名称。

但是，在某些特殊情况下，仍会需要直接用到匿名函数。

不要问我哪里需要用到，其实你肯定见过，比如sort函数，请看如下示例：

students =
{
    {name = "Wang", age = "18"},
    {name = "Qin", age = "20" },
    {name = "Li", age = "19"},
    {name = "Wei", age = "21"},
}

--[[ before sort ::]]
print("before sort ::")
for i = 1, #students do
    print(i, students[i].name, students[i].age)
end

table.sort(students, function(a, b) return (a.name > b.name) end)

--[[ after sort ::]]
print("after sort ::")
for k, v in pairs(students) do
    print(k, v.name, v.age)
end

--[[执行结果
before sort ::
1    Wang    18
2    Qin    20
3    Li    19
4    Wei    21
after sort ::
1    Wei    21
2    Wang    18
3    Qin    20
4    Li    19
]]

像sort这样的函数，接受另一个函数作为实参，称其是一个“高阶函数”，是一种强大的编程机制。

names = {"Peter", "Paul", "Mary"}
grades = {Mary = 10, Paul = 7, Peter = 8}
table.sort(names, function(n1, n2)
    return grades[n1] > grades[n2]
    end)

for k, v in ipairs(names) do
    print(k, v)
end

--[[
1    Mary
2    Peter
3    Paul
]]

names = {"Peter", "Paul", "Mary"}
grades = {Mary = 10, Paul = 7, Peter = 8}

function sortbygrade(names, grades)
    table.sort(names, function(n1, n2)
    return grades[n1] > grades[n2]
    end)
    return names
end

for k, v in ipairs(sortbygrade(names, grades)) do
    print(k, v)
end

--[[
1    Mary
2    Peter
3    Paul
]]

--[[一般函数]]
function increCounter1()
   local i =  0
    i = i + 1
    return i
end

print(increCounter1)     -- function: 02A6B8F8
print(increCounter1())   -- 1
print(increCounter1())   -- 1

--[[闭合函数]]
function increCounter2()
   local i =  0
   return function()
            i = i + 1
            return i
        end
end

print(increCounter2)    -- function: 02A6B738
print(increCounter2())  -- function: 02A6B918

c1 = increCounter2()
print(c1())            -- 1
print(c1())            -- 2
c2 = increCounter2()
print(c2())            -- 1
print(c1())            -- 3
print(c2())            -- 2

--[[闭合函数 局部变量]]
function increCounter3()
   return function()
        local i = 9
        i = i + 1
        return i
    end
end

print(increCounter3)    -- function: 02A6B6F8
print(increCounter3())  -- function: 02A6B7D8

c3 = increCounter3()
print(c3())            -- 10
print(c3())            -- 10
c4 = increCounter3()
print(c4())            -- 10
print(c4())            -- 10
print(c4())            -- 10

匿名函数

（2）非全局函数

（3）正确尾调用

【5】总结

Good Good Study, Day Day Up.

顺序 选择 循环 总结