LUA基础语法
目录
变量篇
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 then
print("1>10")
else
print("no")
end
if 8>10 then
print("8>10")
elseif 8<10 then
print("8<10")
end
--循环语句
--for
--11111
for i=10,15 do
print(i)
end
--22222
for i=1,10,2 do
print(i)
end
--while
local n=10
while n>1 do
n=n-1
print(n)
end
--do while
num=0
repeat
print(num)
num=num+1
until num>5 --结束条件函数
--function
function function_name( ... )
-- body
end
a=function()
end
--无参数无返回
function F1()
print("F1")
end
F1()
F2=function ( )
-- body
print("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 do
print(arg[i])
end
end
F7(1,5,"444",8,7,true)
--函数的嵌套
function F8( ... )
F9=function ()
print("nyx")
end
return F9
end
tt=F8()
F9()
--LUA中闭包考点：
function FF( x )
--改变了传入参数的生命周期
return function ( y )
return x+y
end
end
F10=FF(10)
print(F10(5))
--函数多返回值
function test( )
-- body
return 11,34,25,3
end
a,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 do
print(a[i])
end
for i=1,#b do
print(b[i])
end
--二维
for i=1,#aa do
b=aa[i]
for j=1,#b do
print(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) do
print(i.."_"..k)
end
--类和结构体
--lua中默认没有面向对象，需要自己实现
--封装 成员变量，成员函数。。。。。。
Student={
age=11,
sex=true,
set=4,
Up=function (age)
--这个age与上面的不是同一个，是一个全局变量，除非写Student.age
print(age.age)
print("vgjvv")
end,
Learn=function ()
-- body
print("哈哈哈哈")
end
}
--申明表过后，在表外去申明表有的变量和方法
Student.name="tls"
Student.Speak=function ()
print("speak")
end
print(Student.set)
Student.Up(Student)
Student.Learn()
--lua中.与:的区别
Student.Speak()
--:时会默认把第一个参数传入方法中
Student:Up()
--函数的第三种声明方式
function Student:Speak2()
--lua中 有一个关键字 self 表示，默认传入的第一个参数
print(self.name.."11shuohua")
end
Student: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) do
print(v)
end
--逆序
table.sort( t3, function(a,b)
if a>b then
return true
end
end)
for _,v in pairs(t3) do
print(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) do
print("键值对"..i.."_"..k)
end
print("\n")
--pairs遍历,可以找到所有的键的值
for i,v in pairs(a) do
print("键值对"..i.."_"..v)
end全局变量与本地变量
--全局变量与本地变量
--全局变量
a=1
b="124"
--局部变量
for i=1,2 do
local 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 ( )
-- body
print(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=1
while true do
print(i)
i=i+1
print(coroutine.status(co3))
--协程挂起函数
coroutine.yield()--其中可以带返回值coroutine.yield(i)，协程的第一个返回值是返回有没有执行成功
--coroutine.yield(i)
end
end
co3=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.name
end
}
myt1={
name="nyx"
}
setmetatable(myt1,t2)--将第一个参数设置成第二个元表
print(myt1)
--------------------------__call：当第一个参数被当作一个函数来使用时，会默认调用__call中的内容
--当希望穿参数时，一定要默认第一个参数是调用者自己
t3={
__tostring=function(i)
return i.name
end,
__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.age
end,
__sub=function(t1,t2)
return tt.age-tt1.age
end,
__mul=function(t1,t2)
return tt.age*tt1.age
end,
__div=function(t1,t2)
return tt.age/tt1.age
end,
__mod=function(t1,t2)
return tt.age%tt1.age
end,
__pow=function(t1,t2)
return tt.age^tt1.age
end,
__eq=function(t1,t2)
return tt.age==tt1.age
end,
__lt=function(t1,t2)
return tt.age<tt1.age
end,
__le=function(t1,t2)
return tt.age<=tt1.age
end,
--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=self
setmetatable(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=self
setmetatable(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+1
self.posY=self.posY+1
print(self.posX)
print(self.posY)
end
GameObject: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) do
print(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热更新开发中尽量不要用自动垃圾回收
原文地址：https://blog.csdn.net/sara_shengxin/article/details/144811334
免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！