coolshell lua教程笔记

2015-01-21 本文已影响398人飞将军

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语句, 也展示了:

"~=" 是不等于, 而不是!=
io库分别从stdin和stdout读写的read和write函数
字符串的拼接操作符'..'
条件表达式中的与或非分别是: 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中没有local的变量都是全局变量, 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}

-- 如果我们想实现分数间的相加: 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

method	expression
__add(a, b)	a + b
__sub(a, b)	a - b
__mul(a, b)	a * b
__div(a, b)	a / b
__mod(a, b)	a % b
__pow(a, b)	a ^ b
__unm(a)	-a
__concat(a, b)	a .. b
__len(a)	#a
__lt(a, b)	a < b
__le(a, b)	a <= b
__index(a, b)	a.b a[b]
__newindex(a, b, c)	a.b = c a[b] =c
__call(a, ...)	a(...)

__add函数是MetaMethod, 这是lua内建约定的. lua所有的内建的MetaMethod:

method	expression
__add(a, b)	a + b
__sub(a, b)	a - b
__mul(a, b)	a * b
__div(a, b)	a / b
__mod(a, b)	a % b
__pow(a, b)	a ^ b
__unm(a)	-a
__concat(a, b)	a .. b
__len(a)	#a
__lt(a, b)	a < b
__le(a, b)	a <= b
__index(a, b)	a.b a[b]
__newindex(a, b, c)	a.b = c a[b] =c
__call(a, ...)	a(...)

面向对象

上面的__index重载, 主要是重载find key的操作. 这个操作可以让lua变得有点面向对象的感觉, 让其有点像javascript的prototype.

所谓__index, 说的明确点, 如果有2个对象a和b, 我们想让b作为a的prototype, 可以这样:

setmetatable(a, {__index = b })

例如, 可以用一个Window_Prototype的模版加上__index的MetaMethod来创建另一个实例:

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

其中:

self就是Person, Person:new(p), 相当于Person.new(self, p)
new方法的self.__index = self的意图是怕self被扩张后改写, 所以, 让其保持原样
setmetatable这个函数返回的是第一个参数的值

于是, 我们可以这样调用:

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

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

继承如上, 我们就不多说了, lua和js很像, 都是在prototype的实例上改过来改过去.