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

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

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

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

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