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的实例上改过来改过去.
