LUA基础语法

目录

变量篇

算数运算符

条件分支语句与循环语句

函数

表 Table

全局变量与本地变量

协程

元表

面向对象（封装，继承，多态）

常用自带库

垃圾回收

变量篇

print("hello")
print("lua")
--注释
--[[多行注释1
]]--[[多行注释2
]]----[[多行注释3
--]]--变量
a=5
b=nil
print(a)--多重赋值
aa,bb=1,2
aaa,bbb,c=1,2
print(aaa,bbb,c)--多变量赋值
a,b,c= 1,2
print(c)--不够会自动为空，多了会省略   --数值型
q=0x11
print(q)
print(type(q))--string
x="ajn8uah"
y='jkHJUb90'
xx="jbs\nhk"
print(x,y,xx)
yy=x..y--拼接
print(yy)
print(string.format("我今年%d岁",10))print("\n")
tonum=tonumber("10")
tostr=tostring(10)
print(string.upper(y))
print(string.lower(yy))
print(string.reverse(xx))
print(string.find(yy,"HJ"))
print(string.sub(yy,5,9))
print(string.rep(y,4))
print(string.gsub(yy,"j","xxx"))print("\n")
s=string.char(0x45)
s1=string.byte(y,2)
print(#x)
print(tonum,tostr,s,s1)ss=[[w
ky
duohang
shuchu
]]
print(ss)

算数运算符

--算数运算符
-- 有+-*/%
--没有自增自减 ++ --
--没有复合运算符 
print (1+2)
a=3
b=4
print(a*b,a/b)
print("154.2"+4)
print("25.2"*5)
print(45%7)
print("幂运算"..2^5)--条件运算符
-- > < >= <= == ~=
print(3>1)
print(2>8)
print(2~=7)
print(7==7)
print("\n")--逻辑运算符,满足短路（第一个是假的则就是假）
-- && ||
-- and or
print(true or false)
print(true and false)
print(false and print(555))
print(not true)
--LUA不支持位运算符，不支持三目运算符--and or
--逻辑与逻辑或
--不仅可以连接bool类型，任何类型都可以连接
--在lua中只有nil与false为假
print(1 and 2)
print(false and 2)print(false or 3)
print(4 or 77)
print(nil or false)x=5
y=1
local res=(x>y)and x or y
print(res)

条件分支语句与循环语句

--条件分支语句if 1>10 thenprint("1>10")
elseprint("no")
endif 8>10 thenprint("8>10")
elseif 8<10 thenprint("8<10")
end--循环语句
--for
--11111
for i=10,15 doprint(i)
end--22222
for i=1,10,2 doprint(i)
end--while
local n=10
while n>1 don=n-1print(n)
end--do while
num=0
repeatprint(num)num=num+1
until num>5 --结束条件

函数

--functionfunction function_name( ... )-- body
enda=function()
end--无参数无返回
function F1()print("F1")
end
F1()F2=function (  )-- bodyprint("F2")
end
F2()--有参数无返回
function F3(a)print(a)
end
F3("1")--可以穿任意参数
F3(1,8,5)--不会报错，自动丢弃--有返回
function F4(a)return a,"444",false
end
temp=F4("4587")
print(temp)
--多返回值时前面申明多个变量来接取
t1,t2,t3=F4(9)
print(t1,t2,t3)--函数的类型
print(type(F4))--函数的重载
--LUA中不支持函数重载,默认调用最后一个申明的函数--变长参数
function F7( ... )--变长参数使用 用一个表存起来 再用arg={...}for i=1,#arg doprint(arg[i])end
endF7(1,5,"444",8,7,true)--函数的嵌套
function F8( ... )F9=function ()print("nyx")endreturn F9
endtt=F8()
F9()--LUA中闭包考点：
function FF( x )--改变了传入参数的生命周期return function ( y )return x+yend
endF10=FF(10)
print(F10(5))--函数多返回值
function test( )-- bodyreturn 11,34,25,3
enda,b,c=test()
print(a)
print(b)
print(c)

表 Table

--表table，所有复杂类型都是表！！！！--数组
a={1,5,222,"nujs",true,8787,nil}
--索引从1开始
print(a[5])
--#是通用的获取长度的关键字
print(#a)
b={45,"sjb",nil,4}
print(#b)	--高版本中不会因为中间存在nil而是表的长度被截断--二维数组
aa={{5,7,55},{5,"775",1}}
print(aa[1][3])--数组的遍历
--一维
for i=1,#a doprint(a[i])
endfor i=1,#b doprint(b[i])
end
--二维
for i=1,#aa dob=aa[i]for j=1,#b doprint(b[j])end
end--自定义索引
bb={[0]="n",2,3,[-1]=4,5}
print(bb[0])
print(#bb)--为：2 3 5 
print(bb[-1])c={[1]=1,[2]=2,[6]=7,[11]=9}--比较特别的，注意！
print(#c)--字典
--字典的申明
a={["name"]="nyx",["age"]=18,["1"]=5}
print(a["name"])
print(a["age"])
print(a["1"])
--可以用类似.成员变量的形式得到值
print(a.name)
--但是数字不可以.
--print(a.1)
--修改
a["name"]="wwww"
print(a.name)
--新增
a["sex"]="female"
print(a.sex)
--删除
a["sex"]=nil
print(a.sex)
print("遍历")--模拟字典遍历只能用pairs
for i,k in pairs(a) doprint(i.."_"..k)
end
--类和结构体
--lua中默认没有面向对象，需要自己实现
--封装 成员变量，成员函数。。。。。。
Student={age=11,sex=true,set=4,Up=function (age)--这个age与上面的不是同一个，是一个全局变量，除非写Student.ageprint(age.age)print("vgjvv")end,Learn=function ()-- bodyprint("哈哈哈哈")end
}
--申明表过后，在表外去申明表有的变量和方法
Student.name="tls"
Student.Speak=function ()print("speak")
endprint(Student.set)
Student.Up(Student)
Student.Learn()--lua中.与:的区别
Student.Speak()
--:时会默认把第一个参数传入方法中
Student:Up()--函数的第三种声明方式
function Student:Speak2()--lua中 有一个关键字 self 表示，默认传入的第一个参数print(self.name.."11shuohua")
endStudent:Speak2()--表的公共操作
t1={{age=1,name="nnn"},{age=77,name="www"}}
t2={name="thd",sex=true}--插入
print(#t1)
table.insert(t1,t2);
print(#t1)
print(t1[1])
print(t1[2])
print(t1[3])
print(t1[1].name)--删除
--remove 传表，会移除最后一个内容
table.remove(t1)
print(#t1)
print(t1[1].name)
--remove 传两个参数，第一个是表，第二个是索引
table.remove(t1,2)
print(#t1)t2={5,8,nil,22,"bbb",4}
print(#t2.."--t2")--排序
t3={5,8,42,22,1,4}
table.sort(t3)
for i,v in pairs(t3) doprint(v)
end
--逆序
table.sort( t3, function(a,b)if a>b thenreturn trueend
end)
for _,v in pairs(t3) doprint(v)
end--拼接
tb={"155","87","h","888745",5544}
str=table.concat(tb,"。")--返回的是字符串，对表中元素有要求
print(str)

--迭代器
--主要是用来遍历表的
a={[0]=1,2,[-1]=5,nil,"444",8}--ipairs,从1开始遍历
for i,k in ipairs(a) doprint("键值对"..i.."_"..k)
endprint("\n")
--pairs遍历,可以找到所有的键的值
for i,v in pairs(a) doprint("键值对"..i.."_"..v)
end

全局变量与本地变量

--全局变量与本地变量
--全局变量
a=1
b="124"--局部变量
for i=1,2 dolocal c="xx"
end
print(c)
--多脚本执行
--关键字 require("脚本名")或者单引号‘’
require("test")
print(testa)
print(aa)--脚本卸载
require("test")--加载一次后不会再执行
--package.loaded["脚本名"],为true说明已经被执行过
print(package.loaded["test"])
--卸载已经执行过的脚本
package.loaded["test"]=nil
print(package.loaded['test'])
local ra=require('test')--可以接收return出去的本地变量
print(ra)--大G表
--_G(是一个特殊的table,保存所有的全局变量)
for k,v in pairs(_G) do--print(k,v)
end

协程

-----------------------------协程（协同程序）---------------------------
----------------------创建(create创建与function函数创建)--------------------
--coroutine.create()
fun=function (  )-- bodyprint(13)
end
co=coroutine.create(fun)
--协程的本质是一个线程对象
print(co)
print(type(co))--函数创建，返回为函数
co2=coroutine.wrap(fun)
print(co2)
print(type(co2))----------------------------------运行--------------------------
--create创建方式的运行
coroutine.resume(co)--函数创建方式运行
co2()----------------------------------------挂起-------------------------fun2=function()local i=1while true doprint(i)i=i+1print(coroutine.status(co3))--协程挂起函数coroutine.yield()--其中可以带返回值coroutine.yield(i)，协程的第一个返回值是返回有没有执行成功--coroutine.yield(i)end
endco3=coroutine.create(fun2)
isT,tempi=coroutine.resume(co3)
print(isT,tempi)
coroutine.resume(co3)--在lua中因为程序是从上到下执行一次 ，所有只有重启一次他才会继续执行
coroutine.resume(co3)
coroutine.resume(co3)co4=coroutine.wrap(fun2)
--此方式的协程调用也可以有返回值，但是没用默认的第一个返回值
co4()
co4()
co4()
co4()--与上面相同，执行一次-----------------------------------状态------------------------------------------
--coroutine.statusd(协程对象)
--dead 结束
--suspended 暂停
--running 进行中
print(coroutine.status(co3))
print(coroutine.status(co))
--得到现在正在运行的协程编号(线程号)
print(coroutine.running())

元表

--------------------元表---------------------
--------------------元表的概念---------------------
--任何表变量都可以作为另一个表变量的元表
--任何变量都可以有自己的元表
--当对有元表的表执行操作时，会执行元表中的内容
--------------------设置元表---------------------
t1={}
myt={}
--设置元表函数
setmetatable(myt,t1)--将第一个参数设置成第二个元表--------------------元表的操作---------------------
-----------------—__tostring
t2={__tostring=function(i)return i.nameend
}
myt1={name="nyx"
}setmetatable(myt1,t2)--将第一个参数设置成第二个元表
print(myt1)--------------------------__call：当第一个参数被当作一个函数来使用时，会默认调用__call中的内容
--当希望穿参数时，一定要默认第一个参数是调用者自己
t3={__tostring=function(i)return i.nameend,__call=function(a,b)print(a)print(b)print("love")end
}
myt2={name="nyx"
}setmetatable(myt2,t3)--将第一个参数设置成第二个元表
print(myt2)
--把子表当作函数使用，就会调用元表的__call方法
myt2(5)-------------------------------------运算符重载
meta={--相当于运算符重载，当子表使用+运算符时，会调用方法__add=function(t1,t2)return tt.age+tt1.ageend,__sub=function(t1,t2)return tt.age-tt1.ageend,__mul=function(t1,t2)return tt.age*tt1.ageend,__div=function(t1,t2)return tt.age/tt1.ageend,__mod=function(t1,t2)return tt.age%tt1.ageend,__pow=function(t1,t2)return tt.age^tt1.ageend,__eq=function(t1,t2)return tt.age==tt1.ageend,__lt=function(t1,t2)return tt.age<tt1.ageend,__le=function(t1,t2)return tt.age<=tt1.ageend,
--lua中没有不等于与大于，大于等于__concat=function(t1,t2)return "t1..t2"end}
tt={age=1}
setmetatable(tt,meta)
tt1={age=2}print(tt..tt1)----------------------__index与__newindex-------------------------mm={age=2
}
--将__index的赋值写在表外进行初始化
mm.__index=mm
ty={}
setmetatable(ty,mm)print(getmetatable(ty))--得到元表的方法
--__index当子表中ty找不到某个属性时，会到元表中__index指定的表去找索引
print(ty.age)--————index查找可以层层向上
mmFa={sx=5
}
mmFa.__index=mmFa
setmetatable(mm,mmFa)
print(mm.sx)--__newIndex 当赋值时，如果赋值一个不存在的索引，那么会把这个值附到newIndex所指的表中，不会修改自己
ma={}
ma.__newIndex={}
mt={}
setmetatable(mt,ma)
mt.grade=99
print(mt.grade)
print(ma.__newIndex.grade)

面向对象（封装，继承，多态）

-----------------------------面向对象--------------------------
-----------------------------封装--------------------
--面向对象，类，其实都是基于table来实现Object={}
Object.id=1
function Object:Test()print(self.id)end--冒号 会将自动调用这个函数的对象，作为第一个参数传入的写法
function Object:new(  )-- self代表我们默认传入的第一个参数--对象就是变量，返回一个新的变量，返回出去的内容，本质上就是表对象local obj={}--元表知识，__index 当找自己的变量找不到时，就会去找元表当中__index指向的内容self.__index=selfsetmetatable(obj,self)return obj
end
local myObj=Object:new()
print(myObj)
print(myObj.id)
myObj:Test()
--想当于对空表中，申明一个新的属性叫id
myObj.id=2
print(Object.id)
myObj:Test()------------------------------------继承---------------------
--写一个用于继承的方法
function Object:subClass(classname)--_G知识点，是总表，所有声明的全局变量都以键值对的形式存在其中_G[classname]={}--写相关继承规则local obj=_G[classname]self.__index=self--子类 定义一个base属性 base属性代表父类obj.base=selfsetmetatable(obj,self)
end
print(_G)
_G["a"]=1
print(a)Object:subClass("Person")
local p1=Person:new()print(p1.id)------------------------------------多态-------------------------
print("------------------------------------------")
--相同行为不同表现
--相同方法，不同执行逻辑，就是多态
Object:subClass("GameObject")
GameObject.posX=0
GameObject.posY=0
function GameObject:Move()self.posX=self.posX+1self.posY=self.posY+1print(self.posX)print(self.posY)
endGameObject:subClass("Player")
function Player:Move()-- base.Move构建一个base保留父类的方法--这里的base指的是Gameobject类，此方式调用相当于将基类表作为第一个参数传入方法--避免将基类表传入到方法中，这样相当于公用一张表的属性--我们如果要执行父类逻辑，我们不要直接冒号调用--要通过.调用然后传入第一个参数self.base.Move(self)
end
local P1=Player:new()
P1:Move()
--目前这种写法，不同对象使用的成员变量居然是相同的
local P2=Player:new()
P2:Move()

常用自带库

-------------------lua的自带库----------------------------------------时间---------------------
--系统时间
print(os.time())
--自己传入参数得到时间
print(os.time({year=2024,month=12,day=29}))--利用os.date("*t")
local nowtime = os.date("*t")
print(nowtime)
for i,v in pairs(nowtime) doprint(i,v)
end
print(nowtime.hour)
-------------------数学运算---------------------
--math
--绝对值
print(math.abs(-23))
--弧度转角度
print(math.deg(math.pi))
--三角函数,传弧度
print(math.cos(math.pi))
--向下向上取整
print(math.floor(2.6))
print(math.ceil(5.2))--最大值与最小值
print(math.max(1,4))
print(math.min(4,1))--小数分为整数与小数俩部分
print(math.modf(2.4))--幂运算
print(math.pow(2,5))--随机数,先设置随机数种子
math.randomseed(os.time())
print(math.random(100))
print(math.random(100))--开方
print(math.sqrt(9))-------------------路径---------------------
--lua脚本加载路径
print(package.path)

垃圾回收

------------------------垃圾回收--------------------
--关键字 collectgarbage
--获取当前lua占用内存数 K字节，用返回值*1024得到具体内存占用字节数
collectgarbage("count")test={id=1,name="222222"}
print(collectgarbage("count"))--lua中的机制与C#中的机制很类似，解除羁绊则变为垃圾
test=nil--进行垃圾回收，看类似于GC
collectgarbage("collect")
print(collectgarbage("count"))
--lua中其实有自动定时垃圾回收
--但是在Unity热更新开发中尽量不要用自动垃圾回收