collshell lua教程筆記

標簽（空格分隔）： lua todo

變量

數字

lua的數字只有double型, 64bits, 但你不必擔心lua處理浮點數會慢(除非大于100,000,000,000,000), 或者有精度問題

如下的方式可以表示數字, 0x開頭的16進制和c是很像的:

num = 1024
num = 3.0
num = 3.1416
num = 314.16e-2
num = 0.31416E1
num = 0xff
num = 0x56

字符串

可以使用單雙引號. 還支持c類ing的轉義. 比如: '\a', '\t', '\n', '\r'
'\v', '\', ''', """.

下列4中方式定義了完全相同的字符串(兩個中括號可以用來定義有換行的字符串)

a = 'alo\n123"'
a = "alo\n123\""
a = [[alo
123"]]

c語言中的NULL在lua中就是nil, 如果你訪問一個沒有聲明過的變量,就是nil.

布爾類型只有nil和false是false, 其他包括0, 空字符串('\0')都是true. (和ruby一樣)

lua中的變量如果沒有特殊說明, 全是全局變量, 哪怕是語句塊或者是函數里. 變量前加local關鍵字就是局部變量:

theGlobalVar = 50 
local theLoalVar = "local variable" 

控制語句

lua中沒有++和--

while

sum = 0 
num = 1
while num <= 100 do 
    sum = sum + num 
    num = num + 1 
end 
print("sum=", sum)

if-else

if age == 40 and sex == 'Male' then 
    print("男人四十一枝花")
elseif age > 60 and sex ~= 'female' then 
    print("old man without country!")
elseif age < 20 then
    io.write("too young, too naive! \n")
else 
    local age = io.read() 
    print("Your age is "..age)
end 

上面的語句不但展示了if-elseif-else語句, 也展示了:

1. "~=" 是不等于, 而不是!=
2. io庫分別從stdin和stdout讀寫的read和write函數
3. 字符串的拼接操作符'..'
4. 條件表達式中的與或非分別是: and, or, not關鍵字.

for

• 從1加到100

sum = 0 
for i = 1, 100 do 
    sum = sum + i 
end 

• 從1到100的奇數和

sum = 0 
for i = 1, 100, 2 then 
    sum = sum + i 
end 

repeat-until loop

sum = 2 
repeat 
    sum = sum ^ 2 -- 冪操作
    print(sum)
until sum > 1000 

函數

lua的函數和javascript的很像!

遞歸

function fib(n)
    if n < 2 then return n end
    return fib(n - 2) + fib(n - 1)
end 

閉包

同樣, javascript附體!

function newCounter()
    local i = 0 
    return function() -- anonymous function 
        i = i + 1 
        return i 
    end 
end 

c1 = newCounter()
print(c1()) --> 1 
print(c1()) --> 2 

function myPower(x)
    return function(y) return y ^ x end 
end 

power2 = myPower(2)
power3 = myPower(3)
print(power2(4)) --> 16 
print(power3(5)) --> 125

函數的返回值

和Ruby, Go語言一樣, 可以一條語句上賦多個值,如:

name, age, bGay = "yufei", 26, false, "yufei@qycloud.com"

因為只有3個變量, 所以第四個值被丟棄

函數也可以返回多個值:

function getUserInfo(id)
    print(id)
    return "yufei", 26, "yufei@qycloud.com" 
end 
name, age, email, website, bGay = getUserInfo()

上例中, website, bGay的值都是nil

局部函數

函數前面加上local就是局部函數, 和javascript的函數式一樣的.
下面連個函數是一樣的:

function foo(x) return x ^ 2 end
foo = function(x) return x ^ 2 end 

Table

所謂的Table其實就是一個Key/Value的數據結構, 它很像javascript的Object, 或是PHP中的數組, 在java和python中叫做Map和Dict.

yufei = { name = "yufei", age = 26, handsome = true}

下面是對Table的CRUD操作:

yufei.website = "http://googleyufei.com" 
local age = yufei.age 
yufei.handsome = false 
yufei.name = nil  

上面看上去很像c/c++中的結構體, 但是name, age, handsome, website都是key. 你還可以這樣定義Table:

t = { [20] = 100, ['name'] = 'yufei', [3.14] = "PI" }
t[20]
t['name']
t[3.14]

數組

數組也是Table. 例子:

arr = [1, 2, 3, 4, 5]

看上去是數組, 但其實等價于:

arr = { [1] = 1, [2] = 2, [3] = 3, [4] = 4, [5] = 5}

lua數組中可以放置不同類型的元素:

arr = [ "string", 100, "yufei", function() print("yufei good!") end] 

-- 數組的函數元素可以如下調用
arr[4]()

lua數組的元素下表是從1開始, 不是從0開始的

for i = 1, #arr do 
    print(arr[i])
end 
-- #arr是arr的長度

lua中沒有l(wèi)ocal的變量都是全局變量, lua是使用Table來管理全局變量的, 這個Table就是_G.

我們可以通過下面的方式來訪問一個全局變量:

_G.globalVal
_G["globalVal"]

pairs()遍歷table

for k, v pairs(t) do 
    print(k, v)
end 

MetaTable 和 MetaMethod

MetaTable和MetaMethod是lua中的重要的語法, MetaTable主要是用來做一個寫類似c++/ruby重載操作符的功能, 例如:

fraction_a = {numerator = 2, denominator = 3}
fraction_b = {numerator = 4, denominator = 7}

-- 如果我們想實現(xiàn)分數間的相加: 2/3 + 4/7
-- 如果直接: fraction_a + fraction_b, 會報錯的

所以我們可以動用MetaTable, 如下:

fraction_op = {} 

function fraction_op.__add(f1, f2)
    ret = {} 
    ret.numerator = f1.numerator * f2.denominator + f2.numerator * f1.denominator 
    ret.denominator = f1.denominator * f2.denominator 
    return ret 
end 

為之前定義的2個table設置MetaTable: (其中setmetatable是庫函數)

setmetatable(fraction_a, fraction_op)
setmetatable(fraction_b, fraction_op)

-- 這樣就可以直接通過'+'連接
-- 實際調用的是fraction_op.__add()函數
fraction_s = fraction_a + fraction_b

__add函數是MetaMethod, 這是lua內建約定的. lua所有的內建的MetaMethod:

面向對象

上面的__index重載, 主要是重載find key的操作. 這個操作可以讓lua變得有點面向對象的感覺, 讓其有點像javascript的prototype.

所謂__index, 說的明確點, 如果有2個對象a和b, 我們想讓b作為a的prototype, 可以這樣:

setmetatable(a, {__index = b })

例如, 可以用一個Window_Prototype的模版加上__index的MetaMethod來創(chuàng)建另一個實例:

Window_Prototype = { x = 0, y = 0, width = 100, height = 100}
MyWin = { title = "hello" }
setmetatable(MyWin, {__index = Window_Prototype })

于是, MyWin中就可以訪問x, y, width, height的東東了. 當表要索引一個值時, 如table[key], lua會首先在table本身中查找key的值, 如果沒有并且這個table存在一個帶有__index屬性的MetaTable, 則lua會按照__index所定義的函數邏輯查找

有了以上的基礎, lua的面向對象是這樣的:

Person = {} 
function Person:new(p)
    local obj = p 
    if obj == nil then 
        obj = { name = 'yufei', age = 27, handsome = true }
    end 
    self.__index = self 
    return setmetatable(obj, self)
end 

function Person:toString()
    return self.name .. ":" ..self.age ..  ":" .. (self.handsome and "handsome" or "ugly")
end 

其中:

1. self就是Person, Person:new(p), 相當于Person.new(self, p)
2. new方法的self.__index = self的意圖是怕self被擴張后改寫, 所以, 讓其保持原樣
3. setmetatable這個函數返回的是第一個參數的值

于是, 我們可以這樣調用:

me = Person.new()
print(me:toString())

kf = Person:new{ name = "King's fucking", age = 70, handsome = false}
print(kf:toString())

繼承如上, 我們就不多說了, lua和js很像, 都是在prototype的實例上改過來改過去.

模塊

參考