久久偷窥wc女厕嘘嘘小说,国产99小视频,欧美另类 ?交

一、函數：

    在Lua中函數的調用方式和C語言基本相同，如：print("Hello World")和a = add(x, y)。唯一的差別是，如果函數只有一個參數，并且該參數的類型為字符串常量或table的構造器，那么圓括號可以省略，如print "Hello World"和f {x = 20, y = 20}。
    Lua為面對對象式的調用也提供了一種特殊的語法--冒號操作符。表達式o.foo(o,x)的另一種寫法是o:foo(x)。冒號操作符使調用o.foo時將o隱含的作為函數的第一個參數。
    Lua中函數的聲明方式如下：

復制代碼代碼如下:

    function add(a)

        local sum = 0

        for i, v in ipairs(a) do

            sum = sum + v

        end

        return sum

    end

在以上聲明中，包含了函數名(add)，參數列表(a)，以及函數體。需要說明的是，Lua中實參和形參的數量可以不一致，一旦出現這種情況，Lua的處理規則等同于多重賦值，即實參多于形參，多出的部分被忽略，如果相反，沒有被初始化的形參的缺省值為nil。

1. 多重返回值：

Lua支持返回多個結果值。如：

復制代碼代碼如下:

s,e = string.find("Hello Lua users","Lua")
print("The begin index is " .. s .. ", the end index is " .. e .. ".");
-- The begin index is 7, the end index is 9.

    以上的代碼示例只是演示了如何獲取Lua函數的多個返回值，下面的示例將給出如何聲明返回多個值的Lua函數。如：
[code]
function maximum(a)
    local mi = 1
    local m = a[mi]
    for i, val in ipairs(a) do
        if val > m then
            mi,m = i,val
        end
    end
    return m,mi
end
print(maximum{8,10,23,12,5})
--23   3

Lua會調整一個函數的返回值數量以適應不同的調用情況。若將函數調用作為一條單獨語句時，Lua會丟棄函數的所有返回值。若將函數作為表達式的一部分來調用時，Lua只保留函數的第一個返回值。只有當一個函數調用是一系列表達式中的最后一個元素時，才能獲得所有返回值。這里先給出三個樣例函數，如：

復制代碼代碼如下:

    function foo0() end

    function foo1() return "a" end

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

最后一個需要介紹的是Lua中unpack函數，該函數將接收數組作為參數，并從下標1開始返回該數組的所有元素。如：

復制代碼代碼如下:

    /> lua

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

    10  20  30

    > a,b = unpack{10,20,30}

    > print(a,b)

    10  20

    > string.find(unpack{"hello","ll"})  --等同于string.find("hello","ll")

在Lua中unpack函數是用C語言實現的。為了便于理解，下面給出在Lua中通過遞歸實現一樣的效果，如：

復制代碼代碼如下:

function unpack(t,i)

    i = i or 1

     if t[i] then

         return t[i], unpack(t,i + 1)

     end

end

2. 變長參數：
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個點(...)。但不同的是，此時這3個點將作為表達式來使用，如{...}表示一個由所有變參構成的數組。在含有變長參數的函數中個，同樣可以帶有固定參數，但是固定參數一定要在變長參數之前聲明，如：

復制代碼代碼如下:

    function test(arg1,arg2,...)

        ...

    end

關于Lua的變長參數最后需要說明的是，由于變長參數中可能包含nil值，因此再使用類似獲取table元素數量(#)的方式獲取變參的數量就會出現問題。如果要想始終獲得正確的參數數量，可以使用Lua提供的select函數，如：

復制代碼代碼如下:

for i = 1, select('#',...) do  --這里'#'值表示讓select返回變參的數量(其中包括nil)。

    local arg = select(i, ...) --這里的i表示獲取第i個變參，1為第一個。

     --do something

end

3. 具名實參：

在函數調用時，Lua的傳參規則和C語言相同，并不真正支持具名實參。但是我們可以通過table來模擬，比如：

復制代碼代碼如下:

    function rename(old,new)

        ...

    end

這里我們可以讓上面的rename函數只接收一個參數，即table類型的參數，與此同時，該table對象將含有old和new兩個key。如：

復制代碼代碼如下:

    function rename(arg)

        local old = arg.old

        local new = arg.new

        ...

    end

這種修改方式有些類似于JavaBean，即將多個參數合并為一個JavaBean。然而在使用時，Lua的table存在一個天然的優勢，即如果函數只有一個參數且為string或table類型，在調用該函數時，可以不用加圓括號，如：

復制代碼代碼如下:

rename {old = "oldfile.txt", new = "newfile.txt"}

二、深入函數：

在Lua中函數和所有其它值一樣都是匿名的，即它們都沒有名稱。在使用時都是操作持有該函數的變量，如：

復制代碼代碼如下:

    a = { p = print }

    a.p("Hello World")

    b = print

    b("Hello World")

在聲明Lua函數時，可以直接給出所謂的函數名，如：

復制代碼代碼如下:

function foo(x) return 2 * x end

我們同樣可以使用下面這種更為簡化的方式聲明Lua中的函數，如：

復制代碼代碼如下:

foo = function(x) return 2 * x end

因此，我們可以將函數理解為由語句構成的類型值，同時將這個值賦值給一個變量。由此我們可以將表達式"function(x) body> end"視為一種函數的構造式，就想table的{}一樣。我們將這種函數構造式的結果稱為一個"匿名函數"。下面的示例顯示了匿名函數的方便性，它的使用方式有些類似于Java中的匿名類，如：

復制代碼代碼如下:

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

1. closure(閉合函數)：
若將一個函數寫在另一個函數之內，那么這個位于內部的函數便可以訪問外部函數中的局部變量，見如下示例：

復制代碼代碼如下:

function newCounter() 

    local i = 0

    return function() --匿名函數

        i = i + 1

        return i

    end

end

c1 = newCounter()

print("The return value of first call is " .. c1())

print("The return value of second call is " .. c1())

--輸出結果為：

--The return value of first call is 1

--The return value of second call is 2

在上面的示例中，我們將newCounter()函數稱為閉包函數。其函數體內的局部變量i被稱為"非局部變量"，和普通局部變量不同的是該變量被newCounter函數體內的匿名函數訪問并操作。再有就是在函數newCounter返回后，其值仍然被保留并可用于下一次計算。再看一下下面的調用方式。

復制代碼代碼如下:

function newCounter() 

    local i = 0

    return function() --匿名函數

        i = i + 1

        return i

    end

end

c1 = newCounter()

c2 = newCounter()

print("The return value of first call with c1 is " .. c1())

print("The return value of first call with c2 is " .. c2())

print("The return value of second call with c1 is " .. c1())

--輸出結果為：

--The return value of first call with c1 is 1

--The return value of first call with c2 is 1

--The return value of second call with c1 is 2

由此可以推出，Lua每次在給新的閉包變量賦值時，都會讓不同的閉包變量擁有獨立的"非局部變量"。下面的示例將給出基于閉包的更為通用性的用法：

復制代碼代碼如下:

do

    --這里將原有的文件打開函數賦值給"私有變量"oldOpen，該變量在塊外無法訪問。

    local oldOpen = io.open

    --新增一個匿名函數，用于判斷本次文件打開操作的合法性。

    local access_OK = function(filename,mode) 檢查訪問權限> end

    --將原有的io.open函數變量指向新的函數，同時在新函數中調用老函數以完成真正的打開操作。

    io.open = function(filename,mode)

        if access_OK(filename,mode) then

            return oldOpen(filename,mode)

        else

            return nil,"Access denied"

        end

    end

end

上面的這個例子有些類似于設計模式中裝飾者模式。

2. 非全局函數：

從上一小節中可以看出，Lua中的函數不僅可以直接賦值給全局變量，同時也可以賦值給其他類型的變量，如局部變量和table中的字段等。事實上，Lua庫中大多數table都帶有函數，如io.read、math.sin等。這種寫法有些類似于C++中的結構體。如：

復制代碼代碼如下:

    Lib = {}

    Lib.add = function(x,y) return x + y end

    Lib.sub = function(x,y) return x - y end

或者是在table的構造式中直接初始化，如：

復制代碼代碼如下:

    Lib = { add = function(x,y) return x + y end, 

               sub = function(x,y) return x - y end

             }

除此之外，Lua還提供另外一種語法來定義此類函數，如：

復制代碼代碼如下:

    Lib = {}

    function Lib.add(x,y) return x + y end

    function Lib.sub(x,y) return x - y end

對于Lua中的局部函數，其語義在理解上也是非常簡單的。由于Lua中都是以程序塊作為執行單元，因此程序塊內的局部函數在程序塊外是無法訪問的，如：

復制代碼代碼如下:

do

     local f = function(x,y) return x + y end

     --do something with f.

     f(4,5)

end

對于這種局部函數，Lua還提供另外一種更為簡潔的定義方式，如：

復制代碼代碼如下:

local function f(x,y) return x + y end

該寫法等價于：

復制代碼代碼如下:

    local f

    f = function(x,y) return x + y end

3. 正確的尾調用：

在Lua中支持這樣一種函數調用的優化，即“尾調用消除”。我們可以將這種函數調用方式視為goto語句，如：

復制代碼代碼如下:

function f(x) return g(x) end

由于g(x)函數是f(x)函數的最后一條語句，在函數g返回之后，f()函數將沒有任何指令需要被執行，因此在函數g()返回時，可以直接返回到f()函數的調用點。由此可見，Lua解釋器一旦發現g()函數是f()函數的尾調用，那么在調用g()時將不會產生因函數調用而引起的棧開銷。這里需要強調的是，尾調用函數一定是其調用函數的最后一條語句，否則Lua不會進行優化。然而事實上，我們在很多看似是尾調用的場景中，實際上并不是真正的尾調用，如：

復制代碼代碼如下:

    function f(x) g(x) end            --沒有return語句的明確提示

    function f(x) return g(x) + 1  --在g()函數返回之后仍需執行一次加一的指令。

    function f(x) return x or g(x) --如果g()函數返回多個值，該操作會強制要求g()函數只返回一個值。

    function f(x) return (g(x))     --原因同上。

在Lua中，只有"return func>(args>)"形式才是標準的尾調用，至于參數中(args)是否包含表達式，由于表達式的執行是在函數調用之前完成的，因此不會影響該函數成為尾調用函數。

您可能感興趣的文章: