Lua中的函數


【前言】

Lua中的函數和C++中的函數的含義是一致的,Lua中的函數格式如下:

function MyFunc(param)
     -- Do something
end

在調用函數時,也需要將對應的參數放在一對圓括號中,即使調用函數時沒有參數,也必須寫出一對空括號。對於這個規則只有一種特殊的例外情況:一個函數若只有一個參數,並且此參數是一個字符串或table構造式,那么圓括號便可以省略掉。看以下代碼:

print "Hello World"          --> print("Hello World")等價
print [[a multi-line
          message]]          -->print([[a multi-line
                              -->               message]]) 等價
-- f是一個函數
f{x=10, y=20}               -->f({x=10, y=20}) 等價

上面代碼的一些簡便寫法,如果不熟悉的話,在閱讀別人的代碼時,就會是一頭霧水。

一個函數定義具有一個名稱、一系列的參數和一個函數體。函數定義時,所定義的參數的使用方式與局部變量非常相似,它們是由調用函數時的“實際參數”初始化的。調用函數時提供的實參數量可以與形參數量不同。Lua會自動調整實參的數量,以匹配參數表的要求,若“實參多余形參,則舍棄多余的實參;若實參不足,則多余的形參初始化為nil”。這個與接下來要介紹的多重返回值非常相似。

 【多重返回值】

這個應該是Lua的一個特征吧。允許函數返回多個結果,只需要在return關鍵字后列出所有的返回值即可。以下根據帶來來說明情況:

function foo0() end                         -- 無返回值
function foo1() return "a" end          -- 返回一個結果
function foo2() return "a", "b" end     -- 返回兩個結果

-- 在多重賦值時,如果一個函數調用是最后,或僅有的一個表達式,
-- 那么Lua會保留其盡可能多的返回值,用於匹配賦值變量
x, y = foo2()               -- x = "a", y = "b"
x = foo2()                    -- x = "a", "b"被丟棄
x, y, z = 10, foo2()     -- x = 10, y = "a", z = "b"

-- 如果一個函數沒有返回值或者沒有足夠多的返回值,那么Lua會用
-- nil來補充缺失的值
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, 30則被丟棄

-- table構造式可以完整的接收一個函數調用的所有結果,即不會有任何數量
-- 方面的調整
local t = {foo0()}          -- t = {}(一個空的table)
local t = {foo1()}          -- t = {"a"}
local t = {foo2()}          -- t = {"a", "b"}

-- 但是,對於上述的行為,只有當一個函數調用作為最后一個元素時才會發生,
-- 而在其他位置上的函數調用總是只產生一個結果值
local t = {foo0(), foo2(), 4}          -- t[1] = nil, t[2] = "a", t[3] = 4

-- 我們也可以在一個函數中,使用return返回另一個函數的返回值
function MyFunc()          -- 返回a
     return foo1()          -- 注:這里是return foo1(),而不是return (foo1())
end

-- return foo1()和return (foo1())是兩個完全不同的意思
-- 將一個函數調用放入一對圓括號中,從而迫使它只返回一個結果
print((foo0()))          -- nil
print((foo1()))          -- a
print((foo2()))          -- a

【變長參數】

在C語言中,函數可以接受不同數量的實參,Lua中的函數也可以接受不同數量的實參,例如以下代碼:

-- 打印所有的參數
function VarArguments(...)
     for i, v in ipairs{...} do
          print(v)
     end
end

VarArguments(1, 2, 3)

參數表中的3個點(…)表示該函數可接受不同數量的實參。當這個函數被調用時,它的所有參數都會被收集到一起。這部分收集起來的實參稱為這個函數的“變長參數”。一個函數要訪問它的變長參數時,仍需要用到3個點(…)。但不同的是,此時這3個點是作為一個表達式來使用的。在上例中,表達式{…}表示一個由所有變長參數構成的數組。在C語言中使用變長參數需要注意的問題,在Lua中同樣需要注意。

通常一個函數在遍歷其變長參數時只需要使用表達式{…},這就像訪問一個table一樣,訪問所有的變長參數。然而在某些特殊的情況下,變長參數中可能會包含一些故意傳入的nil,那么此時就需要用select來訪問變長參數了。調用select時,必須傳入一個固定實參selector和一系列變長參數。如果selector為數字n,那么select返回它的第n個可變實參以及其后面的所有參數;否則selector只能為字符串“#”,這樣select會返回變長參數的總數,請看以下代碼:

for i = 1, select('#', ...) do
    local arg = select(i, ...) -- 得到第i個參數
    -- Do something else
end

select(‘#’, …)會返回所有變長參數的總數,其中包括nil(還記得table.maxn么?)對於Lua 5.0版本來說,變長參數則有另外一套機制。聲明函數的語法是一樣的,也是將3個點作為最后一個參數。但Lua 5.0沒有提供“…”表達式。而是通過一個隱含的局部table變量“arg”來接受所有的變長參數。這個table還有一個名為“n”的字段,用來記錄變長參數的總數,例如以下代碼:

function MyFunc(a, b, ...)
     print(arg.n)
end

MyFunc(1, 2, 3, 4, 5)     -->3

這套舊機制的缺點在於,每當程序調用了一個具有變長參數的函數時,都會創建一個新的table。而在新機制中,只有在需要時才會去創建這個用於變長參數訪問的table。這里只是對這個方法進行簡單介紹,別在閱讀別人的代碼時,看不懂!!!

【深入討論函數】

在Lua中,函數與其它傳統類型的值具有相同的權利。函數可以存儲到變量或table中,也可以作為實參傳遞給其它函數,還可以作為其它函數的返回值。在Lua中有一個容易混淆的概念是,函數與所有其它值一樣都是匿名的,即它們都沒有名稱。當討論一個函數名時,實際上是在討論一個持有某函數的變量,例如以下代碼:

-- 我們經常這樣定義函數
function foo(x) return 2 * x end

-- 實際上,這只是一種“語法糖”而已;
-- 上述代碼只是下面代碼的一種簡化書寫形式
foo = function (x) return 2 * x end

實際上,一個函數定義實際就是一條語句(更准確地說是一條賦值語句),這條語句創建了一種類型為“函數”的值,並將這個值賦予一個變量。由於函數在Lua中就是一個普通的值,所以不僅可以將其存儲在全局變量中,還可以存儲在局部變量甚至table的字段中。

【內嵌函數】

若將一個函數寫在另一個函數之內,那么這個位於內部的函數便可以訪問外部函數中的局部變量,這個特征叫做“詞法域”。我們來看看下面一段有趣的代碼:

function newCounter()
     local i = 0
     return function () -- 匿名函數
          i = i + 1
          return i
     end
end

c1 = newCounter()
print(c1())     -->輸出什么?
print(c1())     -->又輸出什么?

如果你很明白上面的輸出,很明白上面的代碼,那么閉合函數這一小節就不需要閱讀了。在上述代碼中,有一個變量i,對於函數newCounter來說,i是一個局部變量,但是對於匿名函數來說,當它訪問這個i時,i既不是全局變量,也不是局部變量,對於我們來說,我們稱這樣的變量為一個“非局部的變量”。下面這段代碼也是同樣的道理:

function newCounter(i)
     return function () -- 匿名函數
          i = i + 1
          return i
     end
end

c1 = newCounter(10)
print(c1())     -->輸出什么?
print(c1())     -->又輸出什么?

匿名函數訪問了一個“非局部的變量”i,該變量用於保持一個計數器。乍一看,由於創建變量i的函數,也就是newCounter已經返回,所以之后每次調用匿名函數時,i都應該是已經超出了作用范圍。但是,Lua會以closure的概念來正確地處理這種情況。在這里簡單的講,一個closure就是一個函數加上該函數所需訪問的所有“非局部的變量”。如果再次調用newCounter,那么它會創建一個新的局部變量i,從而將得到一個新的closure。在后續的總結中,專門總結一篇關於Lua中的閉包的博文,敬請期待。

【非全局的函數】

由於函數和普通變量一樣,所以函數不僅可以存儲在全局變量中,還可以存儲在table的字段中,或局部變量中。我們可以把函數存在一個table中,比如以下代碼:

Lib = {}
Lib.foo = function (x, y) return x + y end
Lib.goo = function (x, y) return x - y end

只要將一個函數存儲在一個局部變量中,就得到了一個“局部函數”,也就是說這個函數只能在某個特定的作用域內才有效。我們可以這樣定義一個局部的函數:

local f = function (<參數>)
     <函數體>
end
-- Lua還提供另一種特殊的“語法糖”
local function f (<參數>)
     <函數體>
end

有的時候,我們需要進行函數的前置聲明,比如以下代碼:

local f, g

function f()
     <一些其它操作>
     g()
end

function g()
     <一些其它操作>
     f()
end

 


免責聲明!

本站轉載的文章為個人學習借鑒使用,本站對版權不負任何法律責任。如果侵犯了您的隱私權益,請聯系本站郵箱yoyou2525@163.com刪除。



 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM