-- -- run
-- local sceneGame = cc.Scene:create()
-- sceneGame:addChild(createLayerFarm())
-- sceneGame:addChild(createLayerMenu())
--if cc.Director:getInstance():getRunningScene() then
--
cc.Director:getInstance():replaceScene(sceneGame)
--else
--
cc.Director:getInstance():runWithScene(sceneGame)
--end
cclog("----------------------------------------")
--local nhang = 1 / 3
--local nNumber = (1 % 3) * 200
--local X = nNumber
--local Y = nhang * 100
-- nhang = nhang - nhang%1
-- print("ddddddd")
-- local a, b = math.modf(1/10)
-- print(a)
-- print(b)
-- Map = {1,2,3}
-- for id, name in next, Map do
-- print(id, name) -- 返回的时候用括号括起来表示返回的参数
-- end
--local uiLayout = GUIReader:shareReader():widgetFromJsonFile("DemoLogin/DemoLogin.ExportJson")
--local a = 1
--assert( a == 2 , "dugaoda assert")
--cclog("next")
--local t = next(tMy)
--cclog("next%d", t)
--cclog("unpack")
--cclog("unpack")
---- 闭包的概念
local __index123 = function () return 1 end
local value = __index123() -- value 1
local __index1 = function (a) return (1 + a) end
local value1 = __index1(2) -- value1 3
local pointer = __index123 -- 指向__index123这个函数
cclog("pointer()")
print(pointer())
--print(pointer(2))
pointer = __index1
cclog("pointer(2)")
print(pointer(2))
--local temptable = {"du", "gao", "da"}
--table.concat(temptable, ";", 1, 2) -- du:gao
--local table2 = {[1] = "a", [2] = "b", [3] = "c", [26] = "z"}
--table.maxn(table2) -- 会返回26
--local meta =
--{
-- __add = function (op1, op2)
-- op ={}
-- op.x = op1.x + op2.x
-- op.y = op1.y + op2.y
-- return op
-- end
--}
---- meta 变化的意思
--local a = { x = 1, y = 2 }
--setmetatable(a, meta)
--local b = { x = 2, y = 3}
--c = a + b
--print("add realize")
--print(c.x, c.y) -- 输出3 5
-------------------------- 2015年1月22日 --------------------------
-- 使用cocos2d中extern中的class
local MySprite = class("MySprite",
function(fileName)
return CCSprite:create(fileName)
end
)
MySprite.__index = MySprite
MySprite.type1 = 0
function MySprite:createMS(fileName, _type)
local mySprite = MySprite.new(fileName)
mySprite:myInit(_type)
return mySprite
end
function MySprite:myInit(_type)
self.type1 = _type
end
local ddds = MySprite:createMS("menu2.png", 1)
ddds:setPosition(ccp(100, 100))
--sceneGame:addChild(ddds, 100)
-- 创建layer
local DuGaoDaLayer = class("DuGaoDaLayer",
function ()
return CCLayer:create()
end
)
DuGaoDaLayer.__index = DuGaoDaLayer -- 其实这句貌似这里可以不用写 在创建的其实就已经给DuGaoDaLayer设置元表
DuGaoDaLayer.H = 10 -- 新增成员变量
DuGaoDaLayer.W = 20 -- 新增成员变量
-- 模仿他们的创建函数 实例对象
function DuGaoDaLayer:create()
local layer = DuGaoDaLayer.new()
--layer:setH(1)
return layer
end
-- 新增函数
function DuGaoDaLayer:setH(nHeight)
self.H = nHeight
end
-- 创建
local templayer = DuGaoDaLayer:create()
-- 以后函数的创建或调用统一使用: 只有成员变量调用的时候才使用. 自己在创建和调用的时候老是调用.
templayer:setH(1)
print("dugaodalayer")
print(templayer.H)
print(templayer.W)
Window = {}
Window.prototype = {x = 0, y = 0, width = 100, heiht = 100}
Window.mt = {}
--Window.td ={}
function Window.new(o)
setmetatable(o, Window.mt)
return o
end
Window.mt.__index = function(table, key) -- 这里的元方法是函数
return Window.prototype[key]
end
local w = Window.new({x = 10, y = 20})
print(w.width) -- 100
-- 元表的使用
-- 定义一个表
ManDuGaoDa = {}
ManDuGaoDaSon = {}
ManDuGaoDaSon.info = {name = "duxiaoda", age = 10}
ManDuGaoDa.mt = {} -- 创建元表
setmetatable(ManDuGaoDa, ManDuGaoDa.mt)
--ManDuGaoDa.mt.__index = function(table, Key) -- 实现元表中的内容
-- return ManDuGaoDaSon.info[Key]
--end
--或写成
ManDuGaoDa.mt.__index = ManDuGaoDaSon.info -- 在这里ManDuGaoDaSon.info称为元方法
print(ManDuGaoDa.name) -- 输出 duxiaoda
print(ManDuGaoDa.age) -- 输出 10
-- lua类的使用
-- 1.定义表
dugaoda = {garde = 0}
-- 2.模拟构造体
function dugaoda:new(o)
local o = o or {}
setmetatable(o, self)
self.__index = self
return o
end
function dugaoda:play()
print("dugaoda")
end
function dugaoda:test1()
print("test1")
end
function dugaoda:test2()
print("test2")
end
-- dugaoda的实例dugaoda1
dugaoda1 = dugaoda:new()
-- 重新定义基类的方法play
function dugaoda1:play()
print("dugaoda1")
end
-- dugaoda1的实例dugaoda2
dugaoda2 = dugaoda1:new() -- 这里把dugaoda1当作dugaoda的子类使用
print(dugaoda2.garde) -- 输出 0
dugaoda2.garde = 10
print(dugaoda2.garde) -- 输出 10
--print(dugaoda2.garde()) -- 错误 这是成员不是方法
dugaoda2:play() -- 输出 dugaoda1
dugaoda2:test1() -- 输出 test1
dugaoda2:test2() -- 输出 test2
-- 另一种方式类，带有成员方法的并且初始化成员方法
dugaodafamily = {nfather = 0, nmother = 0, nson = 0, nwife = 0}
dugaodafamily.__index = dugaodafamily
function dugaodafamily:new(father, mother, son, wife)
local self = {}
setmetatable(self, dugaodafamily) -- 设置 元方法是dugaodafamily，dugaodafamily是table也可以是函数
self.nfather = father
self.nmother = mother
self.nson = son
self.nwife = wife
return self
end
clonedugaoda = dugaodafamily:new(1, 2, 3, 4)
print(clonedugaoda.nfather)
print(clonedugaoda.nmother)
print(clonedugaoda.nson)
print(clonedugaoda.nwife)
print("------------------- coroutine -----------------------------")
-- 协同程序
local co = coroutine.create(function () print("coroutine running") end) --创建新的协同程序
print(coroutine.status(co)) -- 输出co的状态 现在是suspended
coroutine.resume(co) -- coroutine running
-- coroutine.yield()
local cotest = coroutine.create(function ()
for i = 1, 10 do
print("co", i)
coroutine.yield()
end
end)
coroutine.status(cotest) -- 查看
coroutine.resume(cotest) -- 唤起
coroutine.status(cotest) -- 查看
coroutine.resume(cotest) -- 再次唤起
coroutine.resume(cotest) -- 打印co 3
coroutine.resume(cotest) -- 打印co 4
coroutine.resume(cotest) -- 打印co 5
coroutine.resume(cotest) -- 打印co 6
coroutine.resume(cotest) -- 打印co 7
coroutine.resume(cotest) -- 打印co 8
coroutine.resume(cotest) -- 打印co 9
coroutine.resume(cotest) -- 打印co 10
coroutine.resume(cotest) -- 什么都不打印
print(coroutine.status(cotest)) -- dead
local co1 = coroutine.create(function ()
for i = 1, 5 do
print("dugaoda hp:", i)
coroutine.yield(co1)
end
print("stop hp +")
end)
coroutine.resume(co1) -- 1
coroutine.status(co1)
coroutine.resume(co1) -- 2
coroutine.status(co1)
coroutine.resume(co1) -- 3
coroutine.status(co1)
coroutine.resume(co1) -- 4
coroutine.status(co1)
coroutine.resume(co1) -- 5
coroutine.status(co1)
coroutine.resume(co1) -- 已经死亡无法唤起
print(coroutine.status(co1)) -- dead
local co2 = coroutine.create(function (name)
print(name)
for i = 1, 10 do
coroutine.yield("dugaoda give")
end
end)
local result, msg = coroutine.resume(co2, "du") -- 其实这边得到的是 coroutine.yield("dugaoda give")返回的结果和信息
print(msg)
local result, msg = coroutine.resume(co2)
print(msg)
local result, msg = coroutine.resume(co2)
print(msg)
function foo (a)
print("foo", a) -- foo 2
return coroutine.yield(2 * a) -- return 2 * a
end
co = coroutine.create(function (a , b)
print("co-body", a, b) -- co-body 1 10
local r = foo(a + 1)
print("co-body2", r)
local r, s = coroutine.yield(a + b, a - b)
print("co-body3", r, s)
return b, "end"
end)
print("main", coroutine.resume(co, 1, 10)) -- true, 4
print("------")
print("main", coroutine.resume(co, "r")) -- true 11 -9
print("------")
print("main", coroutine.resume(co, "x", "y")) -- true 10 end
print("------")
print("main", coroutine.resume(co, "x", "y")) -- false cannot resume dead coroutine
print("------")
-- -- 基类
--Account = {balance = 0}
--function Account.new(o)
-- o = o or {}
-- setmetable(o, self)
-- self.__index = self
-- return o
--end
--function Account:desposit(v)
-- self.balance = self.balance + v
--end
---- 子类
--SpeciallAccount = Account:new()
---- 实例子类对象
--a = SepciallAccount:new(1000.00)
--Person = { name = "这个人很懒" }
--Person.talk = function ( self , words )
--print ( self.name .. "说:" .. words )
--end
--Person:talk("你好")
-- local meta =
--{
-- talek = function ()
-- return print("a")
-- end
--}
---- meta 变化的意思
--local a = {}
--setmetatable(a, meta)
--a.talek()
--local MyLayer = class("MyLayer", function()
--return CCLayer:create()
--end)
-------------------------- 2015年1月22日 --------------------------
-- 错误处理，程序终止，不会执行下去，会输出如下提示
-- error
--error("你的智商不多了，赶紧休息，恢复一下吧")
-- 如果assert的第一个参数为不为false，则返回第一个参数的值；否则，执行error函数，输出错误信息，错误信息的内容为assert的第二个参数。
--assert(false, "你是一个非常善良有爱心的人，我很喜欢你..所以，去死吧！")
-- 使用pcall调用test函数，如果test不报错，则pcall返回ture，否则，返回false。
function test()
print("dugaoda true")
end
if pcall(test) then
print("normal")
else
print("error")
end
-- 函数的几个特别之处 函数参数个数自适应
function dugaodamethod(sNmae, nAge)
print(sNmae)
print(nAge)
end
dugaodamethod("dugaoda")
dugaodamethod("dugdaoda", 40, 20, "hello")
function dugaodareturn()
return 10, 20
end
local a, b, c = 10, dugaodareturn() -- 输出 10 10 20
-- 函数的特点之一：如果函数的调用不是在表达式的最后一个元素，则最多只返回一个值
local a, b, c = dugaodareturn(), 10 -- 输出 10 10 nil
print(a)
print(b)
print(c)
-- 具名实参
function dugaodainfo1(args)
return args.name, args,age
end
-- 是根据table的key值来获取的，根本就不需要考虑参数顺序
local sname, nage = dugaodainfo1({name = "dugaoda", age = 30})
-- 非局部变量
function myclosure()
local i = 0 -- 在这里i属于非局部变量
return function ()
i = i + 1
return i
end
end
local mydiaoyong = myclosure() -- myclosure()函数的返回值是一个匿名函数，这里要特别的注意mydiaoyong对应的值是myclosure()的返回值匿名函数
-- 相当于 mydiaoyong = function () i = i + 1 return i end
-- 当执行 local mydiaoyong = myclosure() 的时候其实运行了myclosure()函数里面的内容对i赋了初0
-- 执行mydiaoyong()的时候其实相当于执行匿名函数里面的内容 返回得到i的内容
print(mydiaoyong()) -- 1
print(mydiaoyong()) -- 2
print(mydiaoyong()) -- 3
--在这里，local i就属于一个非局部变量，因为它既不是全局变量，也不是单纯的局部变量（因为另外一个函数可以访问到它）。
--再来回到定义，count函数里的那个函数，加上非局部变量i，就构成了一个闭合函数了，就这么简单。
--对于闭合函数而言，属于它的非局部变量，并不是在调用它的时候临时产生的，而是和它一起存在的。
--所以每次调用闭合函数，非局部变量的值都不会被重置。
function myclosure1()
return function ()
local ni = 123 -- 在这里ni属于局部变量
ni = ni + 1
return ni
end
end
local temp = myclosure1()
print(temp()) -- 输出123
print(temp()) -- 输出123
print(temp()) -- 输出123
-- 介绍一个“语法糖”
function dugaodayufa()
end
-- 等价于 上下两个等价
local dugaodayufa
dugaodayufa = function()
end
-- 这样就不会报错了 du1能够识别到du2
local du1
local du2
local function du1()
return du2()
end
local function du2()
print("23")
end
-- 尾调用
-- 尾调用的大致意思是：一个函数的调用是另一个函数的最后一个动作时，这个调用就称之为尾调用。
function foo1()
return foo()
end
--这就不属于尾调用，因为调用完count函数之后，还要取得count的返回值,然后进行一次加法操作
function foo2()
return foo() + 1
end
function foo234(n)
if n > 0 then
return foo234(n - 1)
else
return "dugaoda"
end
end
local p = foo234(5)
print(p)
-- 迭代器 打算2015年1月23日 看一遍
local tabTest = {du, gao, da, ha, ha, ha}
for index, value in ipairs(tabTest) do
print(value)
end
function mydiedaiqi(t)
local i = 0
return function()
i = i + 1
return t[i]
end
end
local iter = mydiedaiqi(tabTest)
-- 实现1
while true do
local value = iter()
if value == nil then
break
end
print(value)
end
-- 实现2
for value in mydiedaiqi(tabTest) do
print(value)
end
function a(...)
local arg = {...}
end
-- 字符串部分
-- require (用于使用模块)
-- module (用于创建模块)
print("require dugaoda")
--require("src/dugaoda")
require("src/dugaoda") --
-- 都可以正常的调用dugaoda.lua 中的MAX_DUGAODA_SIZE和hesls()变量和函数 ，如果dugaoda.lua中的变量或方法有关键字local那么就会调用不到
print(MAX_DUGAODA_SIZE)
hesls()
-- 包含模块文件
local dugaodason1 = require("dugaodason")
dugaodason1.info()
--pay()
-- 其实，require干的事就是这样：（这就是为什么模块文件要写成那样了）
--local dugaodason1 = (function()
---- dugaodason.lua的内容
--end)
-------------- 模块(module)和包(package) --------------
-- require会将返回值存储到table package.loaded中
require("dugaodabigson")
--pay() -- 错误 程序识别不到pay这个函数必须加上前缀dugaodabigson
dugaodabigson.pay() -- 正确
--简单的说
--a.lua
--module (..., package.seeall)
--flag=true
--function example()
--...
--end
--在别的脚本中
--require "a"
--调用脚本a中的任何全局变量或者函数必须加上a.
--这个好处就是你不同的脚本中可以用相同的名称定义变量或者函数，而不会混乱。
-------------- 模块(module)和包(package) --------------
-- Lua中的捕获机制和转换技巧介绍
local getstr = "dugaoda = memeda"
local _, _, key, vale = string.find(getstr, "(%a+)%s*=%s*(%a+)")
-- 存储哑元变量 _ 中
-- '%a+' 表示非空的字母序列；'%s*' 表示0个或多个空白 %[对应符号[ %]对应符号%] 貌似也可以用\[ \]
local date = "17/7/1990"
local month, day, year = string.find(date, "(%d+)/(%d+)/(%d+)")
-- 假定你想查找一个字符串中单引号或者双引号引起来的子串，你可能使用模式 '["'].-["']'，
local s = [[then he said: "it's all right"!]]
-- Lua中handler方法的原理详解
print("-------------- handler --------------")
local dugaodahandler = {}
function dugaodahandler:fun()
self.m = "hello"
end
local dugaodahandler1 = {}
dugaodahandler.fun(dugaodahandler1) -- 因为fun函数里面执行的内容是 dugaodahandler1.m = "hello" 替代了self
print(dugaodahandler1.m) -- hello
print(dugaodahandler.m) -- nil
--handler(cls, cls.onClose)
function fandlertemp(obj, method)
return function(...)
return method(obj, ...)
end
end
local cls = {}
cls._m = "close"
function cls:onClose()
print(self._m)
end
fandlertemp(cls, cls.onClose)() -- 分析
--local sdie = fandlertemp(cls, cls.onClose) -- 结果sdie = function(...) return method(obj, ...) end
--sdie() -- 执行 method(obj, ...) 函数 cls:onClose() print(cls._m)
--+ 匹配前一字符1次或多次
--* 匹配前一字符0次或多次
--- 匹配前一字符0次或多次
--? 匹配前一字符0次或1次
-- 另外的2中循环
local conditon = 5
while conditon == 5 do
print("de")
conditon = 1
end
repeat
print("de")
conditon = 5
until conditon == 5
local di = {2,2,3}
local sd = next(di) -- 返回第一个索引的值 可以用next(t)来检测表是否为空(此函数只能用于以数字索引的表与ipairs相类似)
print(sd) -- 输出1
local myceil = math.ceil(3.1)
print(myceil) -- 输出4
--randomseed
--设随机数种子
math.randomseed(os.time())
--random
--取随机数
math.random(5,90)
5~90
--modf
取整数和小数部分
math.modf(20.12)
20 0.12
--mod
取模
math.mod(65535, 2)
1
local str1 = string.char(97) -- 转换整数为相对应的字符
print(str1)
-- Lua中实现面向对象的一种漂亮解决方案
local _class={}
function class(super)
local class_type = {}
class_type.ctor = false -- 设置构造函数
class_type.super = super -- 设置父类
class_type.new = function(...) --
local obj = {}
do
local create
create = function(c,...)
if c.super then
create(c.super, ...)
end
if c.ctor then
c.ctor(obj, ...)
end
end
create(class_type, ...)
end
setmetatable(obj, { __index = _class[class_type] })
return obj
end
local vtbl = {}
_class[class_type] = vtbl
setmetatable(class_type, {__newindex = function(t, k, v) vtbl[k] = v end })
if super then
setmetatable(vtbl,{ __index = function(t,k)
local ret=_class[super][k]
vtbl[k]=ret
return ret
end
}
)
end
return class_type
end
base_type = class() -- 定义一个基类 base_type
function base_type:ctor(a) -- 定义 base_type 的构造函数
print("base_type ctor")
self.m_a = a
end
function base_type:print_a() -- 定义一个成员函数
print(self.m_a)
end
function base_type:hello() -- 定义另一个成员函数 base_type:hello
print("hello base_type")
end
jichenglei = class(base_type) -- 定义一个类 jichenglei 继承于 basetype
function jichenglei:ctor() -- 定义 jichenglei 的构造函数
print("jichenglei ctor")
end
function jichenglei:hello() -- 重载 base_type:hello 为 jichenglei:hello
print("hello jichenglei")
end
myjicheng = jichenglei.new(2)
myjicheng:print_a()
print("class")
--Lua教程之弱引用table
--1.无法超越人类智慧的智能——自动内存管理的缺陷
t = {}
key1 = {name = "du"}
t[key1] = 1
key1 = nil
key2 = {name = "gao"}
t[key2] = 2
key2 = nil
-- 强制进行一次垃圾收集
--collectgarbage(); -- 单词barbage垃圾的意思
for Key, Value in pairs(t) do
print(Key.name .. ": " .. Value)
end
--2.颠覆你的认知——弱引用table
--刚刚举例的只是正常情况，那么，如果我们把某个table作为另一个table的key值后，希望当table设为nil值时，另一个table的那一条字段也被删除。
--应该如何实现？
--这时候就要用到弱引用table了，弱引用table的实现也是利用了元表。
weak_t = {}
-- 给t设置一个元表，增加__mode元方法，赋值为“k”
setmetatable(weak_t, {__mode = "k"});
weak_key1 = {name = "my"}
weak_t[weak_key1] = 1
weak_key1 = nil
weak_key2 = {name = "wife"}
weak_t[weak_key2] = 2
weak_key2 = nil
-- 强制进行一次垃圾收集
--collectgarbage(); -- 单词barbage垃圾的意思
-- 这时候weak_t已经是一个空的table了
if next(weak_t) then
print("exist")
else
print("null")
end
print("weak_reference")
for Key, Value in pairs(weak_t) do
print(Key.name .. ": " .. Value) -- 这个时候输出的结果为空
end
-- 3.三种形式的弱引用
--对于弱引用table，其实有三种形式：
--1）key值弱引用，也就是刚刚说到的情况，只要其他地方没有对key值引用，那么，table自身的这个字段也会被删除。设置方法：setmetatable(t, {__mode = “k”});
--2）value值弱引用，情况类似，只要其他地方没有对value值引用，那么，table的这个value所在的字段也会被删除。设置方法：setmetatable(t, {__mode = “v”});
--3）key和value弱引用，规则一样，但是key和value都同时生效，任意一个起作用时都会导致table的字段被删除。设置方法：setmetatable(t, {__mode = “kv”});
local value1 = "du"
local value2 = "gao"
local key1 = 1
local key2 = 2
weak_t_v = {}
setmetatable(weak_t_v, {__mode = "k"});
weak_t_v[key1] = value1
weak_t_v[key2] = value2
key1 = nil
key2 = nil
for Key, Value in pairs(weak_t_v) do
print(Value)
end
print("collectgarbage")
--collectgarbage()
--for Key, Value in pairs(weak_t_v) do
-- print(Value)
--end
-- 上面不管是对 value1=nil 或 key1 = nil 都无法把表给清空 因为只对table有效
local value11 = {name = "du"}
local value22 = {name = "gao"}
weak_t_v2 = {}
setmetatable(weak_t_v2, {__mode = "v"});
weak_t_v2[1] = value11
weak_t_v2[2] = value22
value11 = nil
value22 = nil
for Key, Value in pairs(weak_t_v2) do
print(Value)
end
print("collectgarbage")
collectgarbage()
-- 这个时候table已经是空的了
if next(weak_t_v2) then
print("exist")
else
print("null")
end
for Key, Value in pairs(weak_t_v2) do
print(Value) -- 输出 table
print(Value.name) -- 输出 table
end
-- 语法小技巧
local x = x or v
local x = a and b or c
local a = b == "dugaoda" --
--2015年1月30日 10:07:00
local num16_1 = 0x56
local num16_2 = 0xff
print(num16_1)
print(num16_2)
--注：前面说过，Lua中的变量，如果没有local关键字，全都是全局变量，Lua也是用Table来管理全局变量的，Lua把这些全局变量放在了一个叫“_G”的Table里。
--__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
--__eq(a, b) 对应表达式 a == b
--__lt(a, b) 对应表达式 a < b
--__le(a, b) 对应表达式 a <= b
--__index(a, b) 对应表达式 a.b
--__newindex(a, b, c) 对应表达式 a.b = c
--__call(a, ...) 对应表达式 a(...)
local table1 = {1, 2}
local table2 = {2, 3}
local metameathon =
{
__add = function(a, b) -- 重载加号运算符
temp = {}
temp[1] = a[1] - b[1]
temp[2] = a[2] - b[2]
return temp
end
}
setmetatable(table1, metameathon)
local table3 = table1 + table2
for Key, Value in ipairs(table3) do
print(Value) -- 输出 -1 -1
end
local table12 = {[1] = "a", [2] = "b", [3] = "c", [26] = "z"}
local mymxan = table.maxn(table12) --
print(mymxan) -- 输出26
-- 升序排列
local tbl = {"du", "gao", "da", "ha"}
table.sort(tbl)
print(table.concat(tbl, ":"))
local tab23 = {10, 20, 39, 392}
table.sort(tab23)
print(table.concat(tab23, ":"))
local guild1 = {}
table.insert(guild1, {
name = "Cladhaire",
class = "Rogue",
level = 70,
})
table.insert(guild1, {
name = "Sagart",
class = "Priest",
level = 70,
})
table.insert(guild1, {
name = "Mallaithe",
class = "Warlock",
level = 40,
})
mysortmethon = function(a, b)
if a.level == b.level then
return a.name < b.name
else
return a.level < b.level
end
end
table.sort(guild1, mysortmethon)
for Key, Value in ipairs(guild1) do
print(Value.name)
end
--tolua.isnull是判断一个userdata是否存在或者已经被释放的。如果传入的参数不是userdata，当然会返回true。
local p1 = tolua.isnull("sdfe") -- 返回true
local p2 = tolua.isnull(null) -- 返回true
local p3 = tolua.isnull({}) -- 返回true
--2015年2月2日 09:07:29
local table123 = {3, 234, 45, xing = "du", ming = "gao", 2340, 92, 10, wifi = "mima"}
table.foreachi(table123, function(i, v) print(v) end) -- 只输出数字的数字key
table.foreach(table123, function(i, v) print(v) end) -- 输出整个表
-- 返回从一个unix时间值
-- 10800 = 3*60*60 (3 hours) 向西3个时区
print(os.time{year=1970, month=1, day=1, hour=0}) --> 10800
-- 返回当前用户机器上的时间.
local timetemp = os.date("*t", 906000490)
-- timetemp = {year = 1998, month = 9, day = 16, yday = 259, wday = 4,
-- hour = 23, min = 48, sec = 10, isdst = false}
print(os.date("%x", 906000490))
--> 09/16/1998
--函数os.clock返回执行该程序CPU花去的时钟秒数
--getfenv(function or integer) - 返回此表已获取函数的堆栈结构或者堆栈等级
--setfenv(function or integer, table) - 设置此表已获取函数的堆栈结构或者堆栈等级本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
