Lua学习
Posted Tearix
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Lua学习相关的知识,希望对你有一定的参考价值。
写在前面:此文只是本人挑选出来的知识点,不是全面的基础学习
建议有lua基础的读者先读一位大神的系列文章,写得很好:
Lua入门系列|果冻想:http://www.jellythink.com/archives/882,
本文的信息来源主要有:1.Lua入门系列|果冻想
2.Lua官方文档(我记得有人翻译了lua部分的接口,c部分的没翻译完,读者可以自己去找找)
3.Lua和c的交互:http://www.cnblogs.com/sevenyuan/p/4511808.html(lua和c#的交互也是类似)
4.项目代码和自己的思考
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的元方法”的说法有失偏颇,但可以帮忙理解,赋值元方法是元表的方法,不是子表的。
我在tolua的源码中看到类似的语法:
local table_a = {} table_a.__index = table_a
local b = {}
setmetatable(b,table_a)
//其实代码改成这样或许会好看一些:
local table_a = {}
local table_base = {}//函数,字段的定义表
table_a.__index = table_base
local b = {}
setmetatable(b,table_a)
我当时懵逼了,觉得这不是死循环的写法吗?然后捶了自己的胸口:table_a是元表,这个元表并没有自己的元表,所以不会死循环,寻值过程是b中找不到,去b的元表的__index找,找不到?去b的元表的元表的__index找(但这里,b的元表没有元表,所以这一步就没有到达,返回Nil了)
元表的元表是自己才会引起死循环,看下面糟糕的代码:
local table_a = {} table_a.__index = table_a setmetatable(a,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会将加载的文件内容(函数,global变量等)以表的形式存储到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学习的主要内容,如果未能解决你的问题,请参考以下文章