Lua学习基础--02

1.ipairs和pairs的区别

ipairs以数组形式遍历
pairs以键值对形式遍历

2.table.sort

第一个参数为表，第二个参数为自定义排序规则。cmp要写在上sort之上。

local aray={1,2,3,4,5,6,7}
function cmp(a,b)
	return a>b
end
table.sort(array)

输出结果为：7 6 5 4 3 2 1

3.table.concat

第一个参数为表，第二个参数为链接字符，第三个参数为链接的初始索引，第四个参数为链接的结束索引。最后返回一个链接后的字符串

local array={7,6,5,4,3,2,1}
res = table.concat(array,',',1,5);
print(res)

输出结果为：‘7,6,5,4,3,2,1’

4.基础运算符

算数运算符（双目）：+(加)   -(减/负号)   *(乘)   /(除)   %(求模)   ^(乘幂)
关系运算符（双目）： >(大于)  <(小于)  >=(大于等于)   <=(小于等于)   ==(等于)   ~=(不等于)
逻辑运算符（双目）：and(如果a为false则返回a。否则返回b)    or(如果a为true则返回a，否则返回b)    not(于逻辑运算结果相反，如果运算结果为true则返回false)
逻辑运算举例：
and：
local a=true
local b=true
print(a and b)--结果为：b
local a=false
local b=true 
print(a and b)--结果为：a

or：
local a=true
local b=true
print(a and b)结果为a
local a=false
local b=true
print(a and b)--结果为结果为b

5.lua元表的查询机制

众所周知，Lua的表本质其实是个类似Dictionary的东西，其元素是很多的Key-Value键值对。如果尝试访问了一个表中并不存在的元素时，就会触发Lua的一套查找机制，Lua也是凭借这个机制来模拟了类似“类”的行为。下面是一段简单地访问表中元素的代码：

myTable = {
    prop1 = 'Property',
}
print (myTable.prop1)
print (myTable.prop2)　　--打印不存在的成员prop2

稍微有些Lua语法的同学，一看就可以看出，上面的输出结果为：Property nil 。输出为nil的原因很简单，myTable中并没有prop2这个成员，这符合我们平时操作Dictionary的习惯。但对于Lua的表，如果myTable有元表和元方法，情况就不同了。下面我们再看一下设置了元表和元方法的代码：

father = {  
    prop1=1  
}  
son = {  
    prop2=1  
}  
setmetatable(son, father) --把son的metatable设置为father  
print (son.prop1) 

执行输出的结果仍然为：nil，这正印证了上面所说的，只设置元表是不管用的。再来看看同时设置元表和对应的元方法的代码：

father = {  
    prop1=1  
}  
father.__index = father -- 把father的__index方法指向它本身
son = {  
    prop2=1  
}  
setmetatable(son, father) --把son的metatable设置为father  
print (son.prop1)

执行输出的结果为：1。

结合上述的几个小例子，我们再来解释一下__index元方法的含义：在上面的例子中，当访问son.prop1时，son中是没有prop1这个成员的。接着Lua解释器发现son设置了元表：father，（需要注意的是：此时Lua并不是直接在fahter中找到名为prop1的成员，而是先调用father的__index方法），如果__index方法为nil，则直接返回nil。如果__index指向了一张表（上面的例子中father的__index指向了自己本身），那么就会到__index方法所指向的这个表中去查找名为prop1的成员。最终，我们在father表中找到了prop1成员。这里的__index方法除了可以是一个表，也可以是一个函数，如果是函数的话，__index方法被调用时会返回该函数的返回值。

Lua查找一个表元素的规则可以归纳为如下几个步骤：

• Step1:在表自身中查找，如果找到了就返回该元素，如果没找到则执行Step2；
• Step2:判断该表是否有元表（操作指南），如果没有元表，则直接返回nil，如果有元表则继续执行
• Step3:判断元表是否设置了有关索引失败的指南（__index元方法），如果没有(__index为nil)，则直接返回nil；如果有__index方法是一张表，则重复执行Step1->Step2->Step3；如果__index方法是一个函数，则返回该函数的返回值

6.lua实现面向对象（一）

首先实现一个类，创建Window.lua实现windos类：

local Window={width=10,height=20}
function Window:new(w,h)
	local instance={}
	setmetatable(instance,{__index=self})
	instance.width=w
	instance.height=h
	return instance
end

function Window:OpenWindow()
	print("Open The Window",self.width,self.height)
end
return Window

再创建Test.lua，调用Window来进行操作

local win=require("Window")
local window=win:new(100,200)
window:OpenWindow()

输出结果为：“Open The Window” 100 200

7.lua实现面向对象（二）

这里主要实现一下lua的继承。
再创建一个BlueWindow.lua，作为Window的派生类。

local Window=require("Window")

BlueWindow={color="blue"}
setmetatable(BlueWindow,Window)
function BlueWindow:new(w,h,c)
	local instance={}
	instance=Window:new(w,h)
	setmetatable(instance,{__index=self})
	instance.color=c
	return instance
end

function BlueWindow:OpenWindow()
	print("OpenWindow",self.width,self.height,self.color)
end

return BlueWindow

然后这时候在Test.lua中我们来使用派生类吧

--[[local win=require("Window")
local w=win:new(10,20)
w:OpenWindow()]]

local window=require("BlueWindow")
local win=window:new(100,200,"Red")
win:OpenWindow()

输出结果为：“Open The Window” 100 200 Red