1.lua元表和元方法：

　　__add(a, b) --加法
　　__index(a, b) --索引查询
　　__newindex(a, b, c) --索引更新（PS：不懂的话，后面会有讲）
　　__call(a, ...) --执行方法调用
　　__tostring(a) --字符串输出
　　__metatable --保护元表

　　_index元方法:
　　　　是否还记得当我们访问一个table中不存在的字段时，会返回什么值？默认情况下，当我们访问一个table中不存在的字段时，得到的结果是nil。但是这种状况很容易被改变；Lua是按照以下的步骤决定是返回nil还是其它值得：

　　　　1.当访问一个table的字段时，如果table有这个字段，则直接返回对应的值；
　　　　2.当table没有这个字段，则会促使解释器去查找一个叫__index的元方法【应该说是table的元表的__index元方法】，接下来就就会调用对应的元方法，返回元方法返回的值；
　　　　3.如果没有这个元方法，那么就返回nil结果。
　　在实际编程中，__index元方法不必一定是一个函数，它还可以是一个table。
　　当它是一个函数时，Lua以table和不存在key作为参数来调用该函数，这就和上面的代码一样；
　　当它是一个table时，Lua就以相同的方式来重新访问这个table

　　__metatable方法：

　　　　local set = {}
　　　　setmetatable(set, mt)
　　　　mt.__metatable = "You cannot get the metatable" -- 设置完我的元表以后，不让其他人再设置

　　PS：不要搞混了元表和元方法：
　　　　元方法是元表里的函数，local a = {};a.__index = function()...这个__index还不是a的元方法！，当a以元表的身份出现时才是，比如local b={},setmetatable(b,a)，虽然“这个__index还不是a的元方法”的说法有失偏颇，但可以帮忙理解，赋值元方法是元表的方法，不是母表的。

2.

index:取下标操作用于访问 table[key] 。

function gettable_event (table, key)
local h
if type(table) == "table" then
local v = rawget(table, key)
if v ~= nil then return v end
h = metatable(table).__index --记住，是元表的__index方法，不是table的__index方法，所以元表一般都定义了__index
if h == nil then return nil end
else
h = metatable(table).__index
if h == nil then
error(···);
end
end
if type(h) == "function" then
return h(table, key) -- 调用处理器
else return h[key] -- 或是重复上述操作
end
end

__call元方法的调用时机：
> function f(tb,x,y) return x+y+tb.n end
> b={}
> b.__call = f
> a = {}
> a.n=100
> setmetatable(a,b)
> print(a(1,2)) --103，有点构造函数的味道，但却明显不是！只是执行一个函数，没有创建实例，不过__call经常被赋值成构造函数，这时就是了。

3.

require用于使用模块，module用于创建模块
require:
require一个模块：
　　1.先判断package.loaded这个table中有没有对应模块的信息；
　　2.如果有，就直接返回对应的模块，不再进行第二次加载；
　　3.如果没有，就加载，返回加载后的模块
　　4.搜索package.path的所有路径下，该模块名的Lua文件是否存在，不存在则搜索package.cpath的所有路径下的，该模块名的C程序库文件是否存在，还不存在就报错返回了，当找到了这个文件以后，如果这个文件是一个Lua文件，它就通过loadfile来加载该文件；如果找到的是一个C程序库，就通过loadlib来加载，这两都只加载不运行
　　5.require会将返回值存储到table package.loaded中
　　6.require以模块名为参数 运行 已经加载的文件
　　7.如果运行没有返回值（即return 结尾），require就会返回table package.loaded中的值
　　注：require一个c程序库时，lua会去调用该库的luaopen_xx函数：require "mLualib"调用luaopen_mLualib函数，具体是：
　　　　local path = "mLualib.dll"
　　　　local f = package.loadlib(path,"luaopen_mLualib") -- 返回luaopen_mLualib函数
　　　　f() -- 执行
　　　　可以看一下lua层调用c层dll的例子。
module:
module("player_t")内部做了:
　　1.模块名设为player_t；
　　2.建立一个空table；
　　3.在全局环境_G中添加模块名对应的字段，将空table赋值给这个字段；
　　4.在已经加载table中设置该模块；
　　5.设置环境变量。(该模块就不能访问_G环境了)
module(..., package.seeall)：
　　这句话的功能就好比module(...)再加上了setmetatable(M, {__index = _G})，可以正常访问_G
一个典型的使用例子：

　　module( "drop_item_t", package.seeall )--创建一个drop_item_t的模块（在require这个脚本的时候创建）

　　drop_item_mt = drop_item_mt or { __index = drop_item_t }--创建一个元表，它的__index指向drop_item_t这个全局表（这个表是module语句中创建的），是为了使用drop_item_t表里的函数
　　setmetatable( drop_item_t, { __index = ctrl_t } )--drop_item_t元表设为ctrl_t，其中ctrl_t是另外一个全局表，这句的意义是让drop_item_t继承ctrl_t表，是为了让drop_item_mt使用ctrl_t的函数
　　function new( _item_id )
　　　　local drop_item = {}
　　　　setmetatable( drop_item, drop_item_mt ) --创建一个表，设元表为drop_item_mt，则这个表可以使用表drop_item_t和表ctrl_t的所有函数
　　　　return drop_item 
　　end

　　注：这里我一开始也迷惑__index的使用，但看了官方文档即前面第2点的代码后就知道，元表只是“中介”，真正起作用的是元表中的元方法，如__index用于搜寻

4.

闭包是由函数和与其相关的引用环境组合而成的实体，即
闭包=函数+引用环境，多个闭包之间木有联系和影响，他们引用的是不同的环境

function Fun1()
local iVal = 10 -- upvalue
function InnerFunc1() -- 内嵌函数
print(iVal) --
end

function InnerFunc2() -- 内嵌函数
iVal = iVal + 10
end
return InnerFunc1, InnerFunc2
end

-- 将函数赋值给变量，此时变量a绑定了函数InnerFunc1, b绑定了函数InnerFunc2
local a, b = Fun1()--生产一个闭包
local c, d = Fun1()--又生产一个闭包
-- 调用a
a() -->10

-- 调用b
b() -->在b函数中修改了upvalue iVal

-- 调用a打印修改后的upvalue
a() -->20
--调用c，不受第一个闭包影响
c() -->10

闭包一个重要用途是用于迭代

5.

协程：
　　协程的resume和yield配合起来，在主程序和协同程序之间交换数据：resume处于主程中，它将外部状态（数据）传入到协同程序内部；而yield则将内部的状态（数据）返回到主程中。
　　create后第一次resume称为启动协程，后面的resume叫重新唤醒协程，而每个yield都是一样的。resume分成“开始resume”，和“resume返回”；yield分成“遇到yield”和“重启yield”
　　当resume是启动协程时，开始resume就是运行创建协程时传入的函数，resume返回 则返回true/false(出错时false)，和 遇到yield时yield的参数：

co = create(f());
f(){return yield(1,2,3)}
resume(co);--返回true,1,2,3，即遇到yield把协程数据传到主线程
--当resume是重新唤醒协程时，开始resume就是重启yield，这时，resume的第2,3...个参数会借助yield传入协程中：
co = create(f());
f(){local a, b = yield(1,2,3);print(a,b);}
resume(co);返回true，1,2,3
resume(co,"a","b");//print（a,b）打印的结果是"ab"，即resume把数据传入了协程中，重启yield是入口，协助了数据的传入。

　　一个“遇到yield把协程数据传到主线程”的例子：
　　生产者消费者模式：

function produter()
local i=0
while true do
i=i+1
yield(i)
end
end
co = create(produter);
local consume = resume(co);--每次resume(co)都能生产一个产品(i)

　　一个“开始resume即重启yield把主线程数据传入协程”的例子：
　　协程缓存：有一个任务需要不定时执行，并且这个任务需要协程执行：

co = coroutine.create(function (f)
while f do
f = coroutine.yield(f())
end
end)

　　每次resume就执行一次任务，但只需create一个协程，即协程缓存。

6.

弱表的使用例子：能解决，缓存的内存开销大过带来的性能提升，问题

function memoize (f)
local mem = {} -- 缓存化表
setmetatable(mem, {__mode = "kv"}) -- 设为弱表
return function (x) -- ‘f’缓存化后的新版本
local r = mem[x]
if r == nil then --没有之前记录的结果？
r = f(x) --调用原函数
mem[x] = r --储存结果以备重用
end
return r
end
end

7.

lua和c/c++交互：强烈建议看这篇博文：http://www.cnblogs.com/sevenyuan/p/4511808.html

因为行文简单明了：简单而没有废话，行文思想也很有趣，但有几句话不妥：

　　1.类似的还有lua_setfield，设置一个表的值，肯定要先将值出栈，保存，再去找表的位置。

　　　　应该是先设置完值后，才出栈，不然干嘛压栈，不就为了在lua层new一个变量，然后给表设置使用吗？，出栈就毁了。

　　2.lua_getglobal(L,"var")会执行两步操作：1.将var放入栈中，2.由Lua去寻找变量var的值，并将变量var的值返回栈顶（替换var）。

　　　　应该是先把_G压栈...

8.待续。。。

Lua学习