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.

順序 選擇 循環 總結