Lua热更新

--单行注释

--[[
多行注释
]]

a=nil  --定义a这个变量的值为nil
print(a) --这里是输出a这个变量，输出值也同样是nil，不过输出的是字符串类型

a=1 b=1.25
print(a) --输出的值是1
print(b) --输出的值是1.25

a="SeveneStudio_Logo" 
print(a)  --输出的值是SeveneStudio_Logo
a='SeveneStudio——Company'
print(a)  --输出的值是SeveneStudio——Company
a=[[SevenStuido_KaiFa]]
print(a)  --输出的值是SevenStuido_KaiFa

a=true
print(a) -- 输出的值是true
a=false
print(a) -- 输出的值是false

a=123
print(type(a))  --因为a的类型是number，所以通过type()获取的输出的是number
a="123"
print(type(a))  --因为a的类型是string，所以通过type()获取的输出的是string

s="aBcDEfG字符串"
print(#s)

print("123\n123")
s=[[
这里
是
SeveneStudio
]]
print(s)

print("HaXinXi".."XueYuan")  -- HaXinXiXueYuan
s1="Wang"
s2="Li"
print(s1..s2)   -- HaXinXiXueYuan

print(string.format("我是哈信息%d级学生",18))   --我是哈信息18级学生
print(string.format("我的家乡是%s市","承德"))   --我的家乡是承德市

s="SeveneStudio"
print(string.upper(s))  --SEVENESTUDIO
print(string.lower(s))  --sevenestudio

print(string.reverse(s)) --oidutSeneveS

s="SeveneStudio"
print(string.find(s,"eve")) --2       4

string.sub(s, i [, j])
s="SeveneStudio"
print(string.sub(s,2,6)) --evene

s="SeveneStudio"
print(string.rep(s,3)) --SeveneStudioSeveneStudioSeveneStudio

s="SeveneStudio"
print(string.gsub(s,"e","*"))  --S*v*n*Studio    3

print("字符转ASCII码")
print(string.byte(s,1))  -- 83
print("ASCII码转字符")
print(string.char(string.byte(s,1)))  --S

function 函数名（）
end

a=function()
end

print("**********无参数无返回值**********")
function F1()
    print("f1函数")
end
F1()
F2=function ()
    print("F2函数")
end
F2()

print("**********有参数无返回值**********")
function F3(a)
    print(a)
end
F3(1)
F3("SeveneStudio")
F3(true)
F3(1,2,3)

**********有参数无返回值**********
1
SeveneStudio
true
1

temp=F4("1")
print("只有一个变量:",temp)
temp,temp2=F4("1")
print("只有两个变量（1）:",temp)
print("只有两个变量（1）:",temp2)
temp,temp2,temp3=F4("1")
print("有三个变量（1）:",temp)
print("有三个变量（2）:",temp2)
print("有三个变量（3）:",temp3)

只有一个变量:   1
只有两个变量（1）:      1
只有两个变量（1）:      123
有三个变量（1）:        1
有三个变量（2）:        123
有三个变量（3）:        true

print("**********变长参数**********")
function F7(...)
    --变长参数使用一个表存起来
    --这里需要注意变长参数以...代表
    arg = {...}
    for i = 1, #arg, 1 do
        print(arg[i])
    end    
end
F7(1,"HX",true,4,5,6)

print("**********嵌套函数**********")
function F8()
    return function ()
        print(123)
    end    
end
f9=F8()
f9()

function F9(x)
    --改变传入参数的生命周期
    return function (y)
        return x+y
    end
end
f10=F9(10)
print(f10(5))

a={1,2,3,"SeveneStudio",true,nil}
print("打印数组第一个值",a[1])
print("a这个数组的长度为",#a)
b={1,nil,"SeveneStudio",true,8,5,6}
print("b这个数组的长度为",#b)

打印数组第一个值        1
a这个数组的长度为       5
b这个数组的长度为       7

print("*********数组遍历*********")
for i=1,#a do
    print(a[i])
end
print("---------------------------")
for i=1,#b do
    print(b[i])
end

*********数组遍历*********
1
2
3
SeveneStudio
true
---------------------------
1
nil
SeveneStudio
true
8
5
6

print("*********二维数组*********")
a={{1,2,true},{4,5,"SeveneStudio"}}
print(a[1][3])
print(a[2][3])

*********二维数组*********
true
SeveneStudio

print("*********二维数组遍历*********")
for i = 1, #a do
    b=a[i]
    for j = 1, #b do
        print(b[j])
    end
end

*********二维数组遍历*********
1
2
true
4
5
SeveneStudio

a={[0]=1,2,[-1]=3,4,5,[5]=6}
print("***********ipairs迭代器遍历")
--第一种方式
for i, k in ipairs(a) do
    print("ipairs遍历键值"..i.."_"..k)
end
--第二种方式==>可以省略k
for i in ipairs(a) do
    print("ipairs遍历键值"..i)
end

***********ipairs迭代器遍历
ipairs遍历键值1_2
ipairs遍历键值2_4
ipairs遍历键值3_5
ipairs遍历键值1
ipairs遍历键值2
ipairs遍历键值3

a={[0]=1,2,[-1]=3,4,5,[5]=6}
print("***********pairs迭代器遍历")
--ipairs遍历是从1开始往后遍历的，小于等于是不会获取到的
--智能找到连续索引的键值，若中间断序，无法遍历后面的内容
for i, k in pairs(a) do
    print("pairs遍历键值"..i.."_"..k)
end
for i in pairs(a) do
    print("pairs遍历键值"..i)
end

***********pairs迭代器遍历
pairs遍历键值1_2
pairs遍历键值2_4
pairs遍历键值3_5
pairs遍历键值0_1
pairs遍历键值5_6
pairs遍历键值-1_3
pairs遍历键值1
pairs遍历键值2
pairs遍历键值3
pairs遍历键值0
pairs遍历键值5
pairs遍历键值-1

print("****************字典的声明和使用****************")
--字典由键值对构成
a={["id"]=1,["name"]="SeveneStudio",["age"]=22,["hobby"]="踢足球，打篮球"}
--第一种方式访问
print(a["id"])
print(a["name"])
print(a["age"])
print(a["hobby"])
print("--------------------------------------------------")
--第二种方式访问
print(a.id)
print(a.name)
print(a.age)
print(a.hobby)
print("***修改***")
a["name"]="HYH"
print(a["name"])
print(a.name)
print("***增加***")
a["sex"]="man"
print(a["sex"])
print(a.sex)

****************字典的声明和使用****************
1
SeveneStudio
22
踢足球，打篮球
--------------------------------------------------
1
SeveneStudio
22
踢足球，打篮球
***修改***
HYH
HYH
***增加***
man
man

print("****************字典的遍历****************")
for k,v in pairs(a) do
    print(k,v)
end
print("****************字典的值遍历****************")
for _,v in pairs(a) do
    print("单个值:",v)
    print("带上键:",_,v)
end
print("****************字典的键遍历****************")
for k in pairs(a) do
    print(k)
    print(a[k])
end

****************字典的遍历****************
sex     man
name    HYH
hobby   踢足球，打篮球
age     22
id      1
****************字典的值遍历****************
单个值  man
带上键  sex     man
单个值  HYH
带上键  name    HYH
单个值  踢足球，打篮球
带上键  hobby   踢足球，打篮球
单个值  22
带上键  age     22
单个值  1
带上键  id      1
****************字典的键遍历****************
sex
man
name
HYH
hobby
踢足球，打篮球
age
22
id
1

Student={
    --变量==>年龄,性别,姓名
    name="小明",--姓名
    age=18,--年龄
    sex=true,--性别==>这里通过true代表男
    --函数
    Eat=function (food)
        --如果采用这种方式进行书写，是与表中的name是毫无关系的，print中的name会看成全局变量哦
        --想要在表内部函数中调用表本身的属性和方法，一定要使用表名.属性或者表名.方法
        print(name)
        print("我们中午吃的:",food)
    end,
    Learn=function ()
        print("好好学习，天天向上")
    end,
    --在函数中调用自己属性或者方法的方式是把自己作为一个参数传进去，在内部访问
    Sleep=function (s)
        print(s.sex)
    end
}
Student.Sleep(Student)
--lua在申明表后，在表外是可以申明表没有的变量和方法
Student.hobby="踢足球，打篮球";
Student.Speak=function ()
    print(Student.name,"说话了")
end
function Student.SpeakTwo()
    print("又说话了")
end
--lua无法通过实例化对象new的方式，更像是一个类中有很多静态方法和变量，通过类名点的方式调用
print(Student.name,"今年",Student.age)
print(Student.Eat("汉堡包"))
Student.Speak();
print(Student.hobby);
Student.SpeakTwo();
Student:SpeakTwo();

--lua中的点和冒号的区别
--冒号调用方法会默认把调用者作为第一个参数传入方法中
function Student:SpeakThree()
    --lua中有一个关键字self表示默认传入的第一个参数
    print(self.name.."说话")
    
end
Student:SpeakThree()
Student.SpeakThree(Student)

print(true and false)
print(true or false)
print(not false)

x=3
y=2
--这里x>y返回的是true  （x>y） and x==>3 是真的，就不用看or了
local res=(x>y) and x or y
print(res)

x=1
y=3
--这里x>y返回的是false，则(x>y)==>false and x==>x ==>false or y or是真则真==>取y，则是3 
local r=(x>y) and x
print(r)
local res=(x>y) and x or y
print(res)

a=8
if a>5 then
    print("大于5")
end

a=22
if a>15 then
    print("大于15")
else
    print("小于15")
end

a=5
if a<5 then
    print("小于5")
elseif a==5 then
    print("等于5")
else
    print("大于5")
end 

num=0
while num<5 do
    print(num)
    num=num+1
end

num=0
repeat
    print(num)
    num=num+1
until  num>5

print("****默认递增for循环****")
for i = 1, 10 do
    print(i)
end
print("****每次递增3的for循环****")
for i = 1, 10, 3 do
    print(i)
end
print("****每次递减1的for循环****")
for i = 5, 1, -1 do
    print(i)
end

a=123 --number类型
b="SeriousWission"  --字符串类型
c=true  --boolean类型

local d="HaXinXi"  --局部字符串类型
local e=123456  --局部字符串类型

-- 全局方法
funOne=function ()
    print("方法")
end
-- 本地方法
local funTwo=function ()
    print("local方法")
end

print("Test这里加载了这个lua文件测试")
testA="123456"
local testLocalA="456789"
funOne=function ()
    print("方法")
end
local funTwo=function ()
    print("local方法")
end
return testLocalA

require("Test")  -- 调用同路径中的Test脚本
funOne()  -- 这里因为上一行已经加载了Test脚本，而且Test脚本中funOne方法是共有的，所以可以直接使用
print(testA) --打印testA参数的值
print(testLocalA) -- 打印testLocalA参数的值

package.loaded["Test"]

package.loaded["Test"]=nil  -- 将判断包是否加载过为nil
package.loaded["Test"]=false --将判断包是否加载过为false

local a=require("Test") --这里调用Test.lua文件，用local a来接收，其实收到的也就是Test.lua中的testLocalA
print(a)

a=1
b="serious"
c=true
for key, value in pairs(_G) do
  print(key,value)
end

string  table: 0000021B456413D0
ipairs  function: 00007FFDB36C9980        
setmetatable    function: 00007FFDB36C8B20
_G      table: 0000021B45633FA0
rawequal        function: 00007FFDB36C8C90
c       true
b       serious
load    function: 00007FFDB36C9EB0        
rawlen  function: 00007FFDB36C8DB0        
getmetatable    function: 00007FFDB36C8A40
assert  function: 00007FFDB36CA580        
debug   table: 0000021B45641690
package table: 0000021B45641050
os      table: 0000021B45641190
xpcall  function: 00007FFDB36CAA80
table   table: 0000021B45641510
dofile  function: 00007FFDB36CA3A0
io      table: 0000021B456411D0
pairs   function: 00007FFDB36C9780
next    function: 00007FFDB36C9640
loadfile        function: 00007FFDB36C9AC0
require function: 0000021B456412D0
utf8    table: 0000021B45640F90
tonumber        function: 00007FFDB36C85C0
select  function: 00007FFDB36CA620
a       1
rawget  function: 00007FFDB36C8E80
arg     table: 0000021B45641010
math    table: 0000021B456415D0
pcall   function: 00007FFDB36CA800
_VERSION        Lua 5.4
print   function: 00007FFDB36C8210
warn    function: 00007FFDB36C8330
collectgarbage  function: 00007FFDB36C91E0
type    function: 00007FFDB36C9590
coroutine       table: 0000021B45641490
tostring        function: 00007FFDB36CADA0
rawset  function: 00007FFDB36C8FF0

fun=function ()
    print("SeriousWission")
end

co=coroutine.create(fun)
print(co)  --打印结果 thread: 0000025793510878

co2=coroutine.wrap(fun)
print(co2)  -- function: 0000025793542920

-- 创建协程的第一种方式
co=coroutine.create(fun)
print(type(co))  --thread
-- 创建协程的第二种方式
co2=coroutine.wrap(fun)
print(type(co2))  --function

--运行通过coroutine.create()创建的协程
coroutine.resume(co)
--运行通过coroutine.wrap()创建的协程
--直接用接收coroutine.wrap()的方法名运行即可
co2()--因为本质是方法，可以直接使用方法来运行

fun2 =function ()
    local i=0
    while true do
        i=i+1
        print("I Like Lua".."==>"..i)
        -- 协程挂起函数
        coroutine.yield()
    end
end

--coroutine.create()创建
co3=coroutine.create(fun2)
--coroutine.resume()运行
coroutine.resume(co3)  --输出结果为：I Like Lua==>1
coroutine.resume(co3)  --输出结果为：I Like Lua==>2

--coroutine.wrap()创建
co4=coroutine.wrap(fun2)
--运行
co4() --输出结果为：I Like Lua==>1
co4() --输出结果为：I Like Lua==>2

fun3 =function ()
    local i=0
    while true do
        i=i+1
        print("I Like Lua".."==>"..i)
        -- 协程挂起函数
        coroutine.yield(i)
    end
end

-- 这里需要明白，是coroutine.resume这时有两个返回值，第一个返回的是程序是否执行成功，第二个是yield的值
co3=coroutine.create(fun3)
isOK,tempOne=coroutine.resume(co3)
print(isOK,tempOne)

-- coroutine.wrap返回的是没有程序是否成功这个值，只会返回程序中的值和yield的值
co4=coroutine.wrap(fun3)
print("返回值==>"..co4())

mytable = {}                          -- 普通表
mymetatable = {}                      -- 元表
setmetatable(mytable,mymetatable)     -- 把 mymetatable 设为 mytable 的元表

mytable2={
    __tostring=function()
        return "爱吃大饼的小虎"
    end
}   --定义一个表
mymetatable2={}  --定义一个元表
setmetatable(mytable2,mymetatable2)  --- 输出结果:爱吃大饼的小虎
print(myTable2)   --这里print是输出语句，里面输出的字符串，因此便会输出 爱吃大饼的小虎

mytable3={
    __tostring=function(t)
        return t.name
    end
}   --定义一个表
mymetatable3={
	name="爱吃大饼的小虎"
}  --定义一个元表
setmetatable(mytable3,mymetatable3)  ---输出结果:爱吃大饼的小虎
print(mytable3)  --这里不难看出，子表需要知道父表有name这个参数，才可以输出

meta4={
    --当子表要被当做字符串使用时，会默认调用这个元表中的tostring方法
    --这里为了凸显出不同，特意换了一个字符串输出
    __tostring=function()
        return "爱吃大饼的小虎"
    end,
    __call=function ()
        print("七鳄学习格")
    end
}
myTable4={}
--设置元表函数setmetatable(子表，元表【可以看做是父表】)
setmetatable(myTable4,meta4)
--当作函数来调用，这时不会调用__tostring(),而是__call()
myTable4()  --输出结果:七鳄学习格

meta5={
    --当子表要被当做字符串使用时，会默认调用这个元表中的tostring方法
    --这里为了凸显出不同，特意换了一个字符串输出
    __tostring=function(t)
        return t.name
    end,
    __call=function (a)
        print(a)
        print("七鳄学习格")
    end
}
myTable5={
	name="黄雨涵123"
}
--设置元表函数setmetatable(子表，元表【可以看做是父表】)
setmetatable(myTable5,meta5)
--当作函数来调用，这时不会调用__tostring(),而是__call()
myTable5(1)  
--输出结果:
		黄雨涵123
        七鳄学习格
--这里可能会意外，需要解释一下:当方法中带参数，会将myTable5本身传进去，所以打印的便是myTable5中的name参数的值，
--当__call=function (a)中在传入一个参数，是__call=function (a,b)时便会打印传入的数值1，
--简单来说第一个是表本身，第二个参数是传入的数值

meta5={
    ------对应的是运算符+，当执行加法执行此方法
    __add=function(t1,t2)
        return t1.age+t2.age
    end,
    ----对应的是运算符-，当执行减法执行此方法
    __sub=function (t1,t2)
        return t1.age-t2.age
    end,
    ----对应的是运算符*，当执行乘法执行此方法
    __mul=function (t1,t2)
        return t1.age*t2.age
    end,
    ----对应的是运算符/，当执行除法执行此方法
    __div=function (t1,t2)
        return t1.age/t2.age
    end,
    ----对应的是运算符==，当执行相等执行此方法
    __eq=function (t1,t2)
        return ""  --这里只会返回true或者false
    end,
    ----对应的是拼接，当执行拼接执行此方法
    __concat=function (t1,t2)
        return t1.str..t2.str
    end,
    ----对应的是运算符==，当执行相等执行此方法
    __lt=function (t1,t2)
        return ""  --这里只会返回true或者false
    end,
}
myTable5={age=1,str='黄雨涵'}
myTable6={age=2,str='真帅'}
--设置元表函数setmetatable(子表，元表【可以看做是父表】)
setmetatable(myTable5,meta5)
setmetatable(myTable5,meta6)
print(myTable5+myTable6)  --3
print(myTable5-myTable6)  ---1
print(myTable5*myTable6)  --2
print(myTable5/myTable6)  --0.5
print(myTable5==myTable6) --false
print(myTable5..myTable6) --黄雨涵真帅
print(myTable5<myTable6)  --true

meta7={
    age=1
}
myTable7={}
--设置元表函数setmetatable(子表，元表【可以看做是父表】)
setmetatable(myTable7,meta7)
print(myTable7.age)	--输出结果:nil

meta7={
    age=1
}
--用元表指定所指定的表，这里就指向元表本身即可，其实指向一个新表也是可以的=>meta7.__index={age=2} 
meta7.__index=meta7
myTable7={}
--设置元表函数setmetatable(子表，元表【可以看做是父表】)
setmetatable(myTable7,meta7)
print(myTable7.age) --输出结果:1

meta7={
	--这里将myTable7的元表中的age注释上
    --age=1
}
meta7Father={
    age=1
}
meta7Father.__index=meta7Father
meta7.__index=meta7
myTable7={}
--设置元表函数setmetatable(子表，元表【可以看做是父表】)
setmetatable(meta7,meta7Father)
setmetatable(myTable7,meta7)
print(myTable7.age)  --输出结果:1

meta8={}
meta8.__newindex={}
myTable8={}
--设置元表函数setmetatable(子表，元表【可以看做是父表】)
setmetatable(myTable8,meta8)
myTable8.age=10
--这时打印出的是nil
print(myTable8.age)
--如果想获取到age的值,则需要获取__newindex中的age
print(meta8.__newindex.age)  --输出结果:10

meta9={}
myTable9={}
setmetatable(myTable9,meta9)
print(getmetatable(myTable9))  

meta10={}
myTable10={}
setmetatable(myTable10,meta10)
print(rawget(myTable10,"age"))

meta11={}
meta11.__newindex={}
myTable11={}
setmetatable(myTable11,meta11)
rawset(myTable11,"age",2)
print(myTable11)

Object ={}
Object.id=1

-- 冒号是会自动将调用这个函数的对象作为第一个参数传入的写法
function Object:new()
    --self 代表的是我们默认传入的第一个参数
    --对象就是变量，返回一个新的变量
    --返回出去的内容 本质上就是表对象
    local obj={}
    --元表知识: __index 当找自己的变量找不到时，就会找元表当中的__index指向的内容
    return obj;
end

local myObj=Object:new()
print(myObj)

-- 冒号是会自动将调用这个函数的对象作为第一个参数传入的写法
function Object:new()
    local obj={}
    --元表知识: __index 当找自己的变量找不到时，就会找元表当中的__index指向的内容
    -- 这里的self可以理解为函数调用者
    self.__index=self
    setmetatable(obj,self)
    return obj;
end

Object.name="爱吃大饼的小虎"
function Object:Test()
    print(self.name)
end
function Object:TestTwo(age)
    Object.age=age
    print(self.age)
end
-- 冒号是会自动将调用这个函数的对象作为第一个参数传入的写法
function Object:new()
    local obj={}
    --元表知识: __index 当找自己的变量找不到时，就会找元表当中的__index指向的内容
    -- 这里的self可以理解为函数调用者
    self.__index=self
    setmetatable(obj,self)
    return obj;
end

myObj:Test() --因为获取的Object.name的值，所以为：爱吃大饼的小虎
myObj:TestTwo(2)--因为是将age这个值2赋给Object.age，所以为：2

myObj.name="七鳄学习格"
print(Object.name)  ---这里的结果还是：爱吃大饼的小虎
myObj:Test() --这里的结果还是：七鳄学习格

Object ={}
Object.id=1
Object.name="爱吃大饼的小虎"
function Object:Test()
    print(self.name)
end
function Object:TestTwo(age)
    Object.age=age
    print(self.age)
end
-- 冒号是会自动将调用这个函数的对象作为第一个参数传入的写法
-- 冒号是会自动将调用这个函数的对象作为第一个参数传入的写法
function Object:new()
    --self 代表的是我们默认传入的第一个参数
    --对象就是变量，返回一个新的变量
    --返回出去的内容 本质上就是表对象
    local obj={}
    --元表知识: __index 当找自己的变量找不到时，就会找元表当中的__index指向的内容
    self.__index=self
    setmetatable(obj,self)
    return obj;
end

--这里相当于将a和b的值传入到_G表中，方可通过_G.a和_G.b获取值
_G["a"]=1
_G.b=123
print(_G.a)
print(_G.b)

--className表示一个新的类的名称
function Object:subClass(className)
    --相当于将新的类放到_G表中
    _G[className]={}
    local obj= _G[className]
    --指向元表
    self.__index=self
    setmetatable(obj,self)
    
end
--调用这个subClass方法
Object:subClass("Person")
--相当于实例化Person
local p1=Person:new()
print("获取Person的值:"..p1.id) --这里的结果为1

（1）p1:Person:new()===>function Object:new()
（2）所以function Object:new()中的obj，self相当于Person，所以p1中没有id，就要到Person中找，诚然也是没有的
（3）那么就要到Person的元表中__index去找
（4）这里就用到function Object:subClass(className)了，Person相当于className，然后local obj= _G[className]，所以Person就是obj，self相当于Object，这里就找到id了，结果是1

Object:subClass("Person")
local p1=Person:new()
--这里p1.id获取到的是元表Person的元表Object的id的值
print("获取Person的值:"..p1.id) --1
p1.id=100  
--这里相当于给p1添加一个新的属性id，并为其赋值为100，既然自己有id属性，当然就不会在向上找了
print(p1.id)  --100
Object:subClass("Monster")
local m1=Person:new()
--这里m1.id相当于新建一个类，名字交Monster，然后没有id这个属性，所以就向上找，获取到的是元表Person的元表Object的id的值
print("获取Monster的值:"..m1.id) --1
--这里相当于给m1添加一个新的属性id，并为其赋值为200，既然自己有id属性，当然就不会在向上找了
m1.id=200 
print(m1.id) --200

Object ={}
Object.id=1
Object.name="爱吃大饼的小虎"
function Object:Test()
    print(self.name)
end
function Object:TestTwo(age)
    Object.age=age
    print(self.age)
end
-- 冒号是会自动将调用这个函数的对象作为第一个参数传入的写法
-- 冒号是会自动将调用这个函数的对象作为第一个参数传入的写法
function Object:new()
    --self 代表的是我们默认传入的第一个参数
    --对象就是变量，返回一个新的变量
    --返回出去的内容 本质上就是表对象
    local obj={}
    --元表知识: __index 当找自己的变量找不到时，就会找元表当中的__index指向的内容
    self.__index=self
    setmetatable(obj,self)
    return obj;
end
--className表示一个新的类的名称
function Object:subClass(className)
    --相当于将新的类放到_G表中
    _G[className]={}
    local obj= _G[className]
    --指向元表
    self.__index=self
    --子类 定义个base属性 base属性代表父类
	obj.base = self
    setmetatable(obj,self)
    
end

--相当于创建一个GameObject类
Object:subClass("GameObject")
-- 创建posX和posY两个属性
GameObject.posX = 0;
GameObject.posY = 0;
--创建一个方法
function GameObject:Move()
	self.posX = self.posX + 1
	self.posY = self.posY + 1
	print(self.posX)
	print(self.posY)
end
--相当于创建一个GameObject类
GameObject:subClass("Player")
--调用Move其方法
function Player:Move()
	--base 指的是 GameObject 表（类）
    --这里相当于继承GameObject的Move方法
	self.base:Move()
end
--实例化p1
local p1 = Player:new()
p1:Move() 

--实例化p2
local p2 = Player:new()
p2:Move() --结果可以自己看看是2，2，这是超级大的bug，他等于改变了GameObject的posX和posY的值了

print(os.time()) 

--自己传入参数，得到时间
print(os.time({year=2014,month=8,day=14}))

local nowTime=os.date("*t")
for index, value in pairs(nowTime) do
    print(index,value)
end
print(nowTime.hour)
--结果如下
sec     26
month   2
isdst   false
wday    3
yday    45
year    2023
min     6
hour    21
day     14

print(os.date("today is %A, in %B"))  --运行结果: today is Tuesday, in February
print(os.date("%X", 906000490))  --运行结果: 10:48:10

print("绝对值:"..math.abs(-11))
print("π的值:"..math.pi)
print("返回小于或等于 x 的最大整数:"..math.floor(8.15))
print("返回其参数中的最大值:"..math.max(1,8,11,98,14,32))
print("返回其参数中的最小值:"..math.min(11,-8,1,98,14,32))

print(package.path)

file = io.open("test.lua", "r") -- 以只读方式打开文件 
--打开文件的格式file = io.open (filename [, mode])这里的mode是类型，具体类型如下表

io.input(file) -- 设置默认输入文件为 test.lua
print(io.read()) -- 输出文件第一行

io.close(file) -- 关闭打开的文件
file = io.open("test.lua", "a") -- 以附加的方式打开只写文件
io.output(file) -- 设置默认输出文件为 test.lua
io.write("--  test.lua 文件末尾注释") -- 在文件最后一行添加 Lua 注释
io.close(file) -- 关闭打开的文件

--使用就比较简单了
test={id=1,name="123"}
print(collectgarbage("count")) --74.1328125

--复用一下上面的代码
test={id=1,name="123"}
print(collectgarbage("count"))  --74.4267578125
test = nil
collectgarbage("collect")  --做一次垃圾回收
print(collectgarbage("count"))  --45.8173828125==>这里会发现内存数变小了