Unity Lua教程

一、环境搭建

1、首先安装LuaForWindows，官网地址：https://github.com/rjpcomputing/luaforwindows/releases
2、安装Sublime Text，官网地址：https://www.sublimetext.com/download
3、如果大家下载不了的话，可以通过我提供的百度网盘进行下载：
链接：https://pan.baidu.com/s/1ojhEqgUoEtozdS3itTY1_Q
提取码：nw68

二、基本语法（lua语句 可以省略分号）

1、打印函数

print("hello world")

2、注释

--单行注释

--[[
第一种多行注释
]]

--[[
第二种多行注释
]]--

--[[
第三种多行注释
--]]

3、关键字

4、数据类型

5、查看变量的类型

print(type(a))
--type的返回值为string类型

--lua中使用没有声明过的变量，不会报错，默认值是nil

6、字符串

s="521一生一世"
print(#s)  --获取字符串的长度，一个汉字占3个长度，英文字符占一个长度

--字符串多行打印
print("123\n123")
s=[[
521
1314
]]
print(s)

--字符串拼接
print("123".."456")  --通过两个..
print(string.format("小明今年%d岁了",18)
--%d：与数字拼接
--%a：与任何字符拼接
--%s：与字符配对

--别的类型转字符串
a=18
print(tostring(a))

--字符串提供的公共方法
str="aBcDe"
print(string.upper(str))  --小写转大写的方法
print(string.lower(str))  --大写转小写的方法
print(string.reverse(str))  --翻转字符串
print(string.find(str,"cDe"))  --字符串索引查找，Lua中索引下标从1开始
print(string.sub(str,3))  --截取字符串
print(string.rep(str,2))  --字符串重复
print(string.gsub(str,"cD","**"))  --字符串修改

a=string.byte("Lua",1)  --给指定位置的字符转成ASCII码
print(a)
print(striing.char(a))  --ASCII码转字符

7、运算符

--算术运算符
	-- + - * / % ^
	-- 没有自增自减 ++ --
	-- 没有复合运算符 += -= /= *= %=
	-- 字符串可以进行算术运算符操作，会自动转成number
	print("123"+1)  --结果为：124
	print("幂运算："..2^5)

--条件运算符
	-- > < >= <= == ~=（不等于）

--逻辑运算符
	--and 与
	--or 或
	--not 非
	-- Lua中支持“短路”，只要第一个条件成立，后面的语句就不执行

--位运算符
	--Lua中不支持位运算

--三目运算符
	--Lua中不支持三目运算符

8、条件分支语句

--单分支
if 条件 then
	...
end

--双分支
if 条件 then
	...
else
	...
end

--多分支
if 条件 then
	...
elseif 条件 then  --elseif是连着写的，要不然会报错
	...
else
	...
end

--Lua中没有Switch语法，需要自己实现

9、循环语句

--while语句
while 条件 do
	...
end

--do while语句
repeat
	...
until 条件 --结束条件，满足条件退出

--for语句
for i=1,5 do  --从1开始到5结束，i默认递增+1，如果要自定义增量，要这样写：i=1,5,2
	...
end

10、函数

--无参数无返回值，两种方法
function F1()  --一个在function后面取名字
	...
end

F2 = function()  --一个不取名字，用一个变量来存储
	...
end

--有参数，如果传入的参数和函数参数个数不匹配，不会报错，只会补空nil或者丢弃
function F3(a)
	...
end

--有一个返回值
function F4(a)
	return a
end

--有多个返回值，需要申明多个变量来接取，接少接多不影响，少了丢弃，多了为nil
function F5(a)
	return a,b,c
end

--函数类型就是function

--不支持函数的重载

--变长参数
function F6(...)
	arg = {...}
	for i=1,#arg do
		print(arg[i])
	end
end
F6(1,"123",true,456)

--函数嵌套，函数里面申明函数
function F7()
	return function()
		print(123)
	end
end
F8 = F7()
F8()

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

11、复杂数据类型table

--所有的复杂类型都是table

--数组的声明和使用
a = {1,2,"123",true,nil,"456"}
print(a[1])  --Lua中索引从1开始
print(#a)  --获取数组的长度，#是通用的获取长度的关键字，在打印长度的时候，第一个空后面的内容会被忽略

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

--二维数组
b = {{1,2,3},{4,5,6}}
print(b[1][2])

--二维数组的遍历
for i=1,#b do
	c=b[i]
	for j=1,#c do
		print(c[j])
	end
end

--自定义索引
aa={[0]=1,2,3,[-1]=4}  --#aa打印结果为2，忽略小于等于0的索引
bb={[1]=1,[2]=2,[4]=4,[6]=6}  --有坑，#bb打印的结果为6，索引之间可以跳一个,缺的补nil
cc={[1]=1,[2]=2,[5]=5,[6]=6}  --#cc打印结果为2

--迭代器遍历，主要是用来遍历表的，一般不要用#来遍历表
a={[0]=1,2,[-1]=3,4,5,[5]=6}

--ipairs遍历，还是从1开始往后遍历的，小于等于0的值得不到
--只能找到连续索引的键，如果中间断序了，它也无法遍历出后面的内容
for i,k in ipairs(a) do
	print(i.."_"..k)  --1_2 2_4 3_5
end

--pairs它能够把所有的键都找到，通过键可以得到值
for i,v in pairs(a) do
	print(i.."_"..v)  --1_2 2_4 3_5 0_1 -1_3 5_6
end

--只遍历键
for i in pairs(a) do
	print(i)
end

12、字典

--字典的声明，字典是由键值对构成
a={["name"]="张三",["age"]=18,["sex"]="男"}
print(a["name"])  --访问
print(a.name)  --虽然可以通过.成员变量的形式得到值，但是不能是数字
a["name"]="李四"  --修改
a["score"]=100  --新增
a["score"]=nil  --删除

--字典的遍历
for k,v in pairs(a) do
	print(k,v)
end

13、类和结构体

--Lua中默认是没有面向对象的，需要我们自己来实现

--类的声明，成员变量，成员函数
Student = {
	age=18,
	sex=true,
	Up=function()
		--这样写 这个age和表中的age没有任何关系 它是一个全局变量
		--print(age)

		--想要在表的内部函数中 调用表本身的属性或者方法
		--一定要指定是谁的 所以要使用 表名.属性 或者 表名.方法
		print(Studnet.age)

		print("Grow up!");
	end
}
print(Student.age)  --调用
Student.Up()

--申明表过后，在表外去申明表有的变量和方法
Student.name="张三"

Student.Learn=function(t)
	--第二种 能够在函数内部调用自己属性或者方法的 方法
	--把自己作为一个参数传进来 在内部 访问
	print(t.sex)
	
	print("好好学习，天天向上")
end
Student.Learn(Student)
Student:Learn()  --冒号调用方法 会默认把调用者 作为第一个参数传入方法中

function Student:Speak()  --冒号声明函数
	--Lua中 有一个关键字 self 表示默认传入的第一个参数
	print(self.name.."说话")
end	

14、表的公共操作

t1={{age=1,name="123"},{age=2,name="345"}}
t2={name="张三",sex=true}

--将t2插入t1
table.insert(t1,t2)

--移除最后一个索引的内容
table.remove(t1)

--移除指定位置的内容
table.remove(t1,1)

t3={4,8,1,3,6,9}
table.sort(t3)  --升序排序

table.sort(t3,function(a,b)
	if a>b then
		return true
	end
end)  --降序排序

--拼接
tb={"123","456","789"}
table.concat(tb,",")

15、多脚本执行

--全局变量和本地变量
--本地变量就是在变量前加local关键字
--不加local关键字的都是全局变量

--多脚本执行语法：require("脚本名") 或 require('脚本名')
--如果是require加载执行的脚本 加载一次过后不会再被执行

--脚本卸载
--package.loaded["脚本名"]  --返回值是boolean 意思是 该脚本是否被执行
package.loaded["脚本名"]=nil  --卸载已经执行过的脚本

--大G表：是一个总表 它将我们申明的所有全局的变量都存储在其中
--写法：_G
_G["a"] = 1  --大G表中声明
print(a)

--如果想在另外一个脚本中访问该脚本中的本地变量，可以通过return返回，在另一个脚本中用变量接收即可

16、特殊用法

--多变量赋值,如果后面的值不够，会自动补空；如果后面的值多了，会自动省略
a,b,c=1,2,3

--多返回值
function Test()
	return 10,20,30,40
end
a,b,c=Test()  --多返回值时 你用几个变量接 就有几个值 如果少了 就少接几个 如果多了 就自动补空

--逻辑与 逻辑或
--and or 他们不仅可以连接boolean 任何东西都可以用来连接
--在Lua中 只有nil和false才认为是假
--“短路” 对于and来说 有假则假 对于or来说 有真则真
--所以他们只需要判断 第一个 是否满足 就会停止计算了
print(1 and 2)  --2
print(0 and 1)  --1
print(nil and 1)  --nil
print(false and 2)  --2
print(true or 1)  --true
print(nil or 2)  --2

--Lua不支持三目运算符，模拟三目运算符
x=3
y=2
res=(x>y) and x or y

--(x>y) and x -> x  --x>y为真
--x or y -> x

--(x>y) and x -> (x>y)  --x>y为假
--(x>y) or y -> y

17、协同程序

--协程的创建 协程的本质是一个线程对象
--第一种方法：coroutine.create() 常用方式 返回的是一个thread
fun = function()
	print(123)
end
co = coroutine.create(fun)

--第二种方法：coroutine.wrap() 返回的是function
co2 = coroutine.wrap(fun)

--协程的运行
coroutine.resume(co)  --用第一种方法创建的协程的运行方法
co2()  --第二种

--协程的挂起
fun2 = function()
	local i=1
	while true do
		print(i)
		i = i + 1
		coroutine.yield(i)  --协程的挂起函数 可以有返回值
	end
end
co3 = coroutine.create(fun2)  
coroutinee.resume(co3)  --1
coroutinee.resume(co3)  --2
isOk,tempI = coroutinee.resume(co3)  --默认第一个返回值是协程是否启动成功，第二个是yield里面的返回值

co4 = coroutine.wrap(fun2)
co4()  --1
co4()  --2
print(co4)  --这种方式的协程调用 也可以有返回值 只是没有默认第一个返回值了

--协程的状态：coroutine.status(协程对象)
--有三种状态：dead 结束  suspended 暂停  running 进行中

--得到当前正在运行的协程的线程号
coroutine.running()

18、元表

--元表的概念
--任何表变量都可以作为另一个表变量的元表
--任何表变量都可以有自己的元表（爸爸）
--当我们子表中进行一些特定操作时 会执行元表中的内容

--设置元表
meta={}
myTable={}
--设置元表函数 第一个参数 子表 第二个参数 元表（爸爸）
setmetatable(myTable,meta)

--特定操作 __tostring 当子表要被当做字符串使用时 会默认调用这个元素中的tostring方法
meta2={
	__tostring = function(t)
		return t.name
	end
}
myTable2={
	name = "张三"
}
setmetatable(myTable2,meta2)
print(myTable2)

--特定操作 __call
meta3={
	__tostring = function(t)
		return t.name
	end,
	--__当子表被当做一个函数来使用时 会默认调这个__call中的内容
	__call = function()  --当希望传参数时 一定要记住 默认第一个参数 是调用者自己
		print("李四")
	end
}
myTable3={
	name = "张三"
}
setmetatable(myTable3,meta3)
print(myTable3)
myTable3()

--运算符重载
meta4={
	--相当于运算符重载 当子表使用+运算符时 会调用该方法
	__add = function(t1,t2)
		return t1.age + t2.age
	end
	-- 运算符-：__sub
	-- 运算符*：__mul
	-- 运算符/：__div
	-- 运算符%：__mod
	-- 运算符^：__pow
	
	-- 如果要用条件运算符来比较两个对象，这两个对象的元表一定要一致，才能准确调用方法
	-- 运算符==：__eq
	-- 运算符<：__lt
	-- 运算符<=：__le
	
	-- 运算符..：__concat
}
myTable4={age = 1}
setmetatable(myTable4,meta4)
myTable5={age = 2}
print(myTable4+myTable5) --3

--特定操作 __index 和 __newIndex
meta6={
	__index = {age = 1}
}
--meta6.__index = {age = 2}

--meta6={
--	age=1
--}
--meta6.__index = meta6

myTable6={}
setmetatable(myTable6,meta6)
--__index 当子表中找不到某一个属性时 会在元表中 __index指定的表去找索引 建议写在外面
print(myTable6.age)

print(getmetatable(myTable6))  --得到元表的方法

print(rawget(myTable6,"age"))  --rawget 当我们使用它时 会去找自己身上有没有这个变量

--newindex 当赋值时 如果赋值一个不存在的索引 那么会把这个值赋值到newIndex所指的表中 不会修改自己
meta7={}
meta7.__newindex={}
myTable7={}
setmetatable(myTable7,meta7)
myTable7.age=1
print(myTable7.age)  --nil
print(myTable.__newindex.age)  --1

rawset(myTable7,"age",2)  --该方法 会忽略newindex的设置 只会改自己的变量
print(myTable7.age)  --2

19、面向对象

-- 面向对象 类 其实都是基于table来实现的
-- 面向对象之封装
Object = {}
Object.id = 1
function Object:Test()
	print(self.id)
end
--冒号 是会自动将调用这个函数的对象 作为第一个参数传入的写法
function Object:new()
	--self 代表的是 我们默认传入的第一个参数
	local obj = {}
	--元表知识 __index 当找自己的变量 找不到时 就会去找元表当中 __index指向的内容
	self.__index = self

	obj.base = self  --子类 定义个base属性 代表父类
	
	setmetatable(obj,self)
	return obj
end

local myObj = Object:new()
print(myObj.id)  --1
myObj:Test()  --1
--对空表中 声明一个新的属性 叫做id
--myObj.id=2
--print(Object.id) --1

myObj.id = 2
myObj:Test()  --2

--面向对象之继承
function Object:subClass(className)
	-- _G知识点 是总表 所有声明的全局变量 都以键值对的形式存在其中
	_G[className]={}
	local obj = _G[className]
	self.__index = self
	setmetatable(obj,self)
end

Object:subClass("Person")
print(Person.id)  --1
local p = Person:new()
print(p.id)  --1

--面向对象之多态
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,self.posY)
end

GameObject:subClass("Player")
function Player:Move()
	self.base:Move()

	--我们如果要执行父类逻辑 就不能直接使用冒号调用 要通过.调用 然后自己传入第一个参数
	--self.base.Move(self)  --填坑
end

local p1 = Player:new()
p1:Move()  --1 1

--目前这种写法 有坑 不同对象使用的成员变量 居然是相同的成员变量 不是自己的
local p2 = Player:new()
p2:Move()  --2 2

20、面向对象总结

Object = {}

function Object:new()  -- 封装
	local obj = {}
	--给空对象设置元素 以及 __index
	self.__index = self
	setmetatable(obj,self)
	return obj
end

function Object:subClass(className)  -- 继承
	--根据大G表的特性 根据名字生成一张表 就是一个类
	_G[className] = {}
	local obj = _G[className]

	obj.base = self  --设置自己的“父类” 多态
	
	--给子类设置元表 以及 __index
	self.__index = self
	setmetatable(obj,self)
end

--多态
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,self.posY)
end

GameObject:subClass("Player")  --声明一个新的类 Player 继承 GameObject
function Player:Move()  --多态 重写了GameObject的Move方法
	--self.base.Move(self)  --base调用父类方法 用.自己传第一个参数
end

--实例化对象使用
local obj1 = GameObject:new()
print(obj1.posX)  --0
obj1:Move()
print(obj1.posX)  --1

local obj2 = GameObject:new()
print(obj2.posX)  --0
obj2:Move()
print(obj2.posX)  --1


local p1 = Player:new()
print(p1.posX)  --0
p1:Move()
print(p1.posX)  --1

local p2 = Player:new()
print(p2.posX)  --0
p2:Move()
print(p2.posX)  --1

21、自带库

--时间
print(os.time())  --系统时间

local nowTime = os.date("*t")  --详细时间
for k,v in pairs(nowTime) do
	print(k,v)
end
print(nowTime.year)

--数学运算
print(math.abs(-1))  --绝对值
print(math.deg(math.pi))  --弧度转角度
print(math.cos(math.pi))  --三角函数
print(math.floor(2.6))  -- 2 向上取整
print(math.ceil(5.2))  -- 6 向下取整
print(math.max(1,2))  -- 2 最大值
print(math.min(4,5))  -- 4 最小值
print(math.modf(1.2))  --小数分离 分成整数部分和小数部分
print(math.pow(2,5))  --幂运算
print(math.sqrt(4))  --开方
--随机数
math.randomseed(os.time)  --随机数种子
print(math.random(100))

--路径
print(package.path)  --lua脚本加载路径

22、Lua垃圾回收

--垃圾回收关键字：collectgarbage

--获取当前Lua占用内存数 K字节 用返回值*1024 就可以得到具体的内存占用字节数
print(collectgarbage("count"))

--进行垃圾回收
collectgarbage("collect")

--Lua中 有自动定时进行GC的方法
--Unity中热更新开发 尽量不要去用自动垃圾回收