【Unity】Lua入门

最新推荐文章于 2024-05-09 22:35:39 发布

凋零叶子

最新推荐文章于 2024-05-09 22:35:39 发布

阅读量6.1k

点赞数 6

分类专栏：热更新文章标签： unity visual studio 游戏引擎

本文链接：https://blog.csdn.net/HG2131/article/details/123464908

版权

热更新专栏收录该内容

1 篇文章 0 订阅

订阅专栏

一、Lua基础

1.1 变量类型

nil(空)、boolean、number(数字-不区分数字类型)、string、function、table、userdata(自定义)、thread(线程)

1.2 特点

动态类型、弱类型、大小写敏感、默认全局、带GC

二、运算符

2.1 数学运算

5 + 3 = 8
5 - 3 = 2
5 * 3 = 15
5 // 3 = 1
5 / 3 = 1.6666666666667
5 % 3 = 2
5.5 % 3 = 2.5
5 ^ 3 = 125.0
不存在：++ += =+

2.2 关系运算

< > >= <= == ~=

2.3 逻辑运算

and(&&)：逐个判断，遇到false返回
or(||) ：逐个判断，遇到true返回
not(!)
-注意：
a、false与nil 为false
b、没有三目运算符(? : )

--模拟三目运算
function JudgeAge(age)
	return age > 18 and "adult" or "child"
end

result = JudgeAge(20) print(result)--adult
result = JudgeAge(15) print(result)--child

c、and优先级大于or
d、除…和^为右结合优先，其余为左结合优先

2.4 位运算

a = 3 --0000 0011
b = 5 --0000 0101

result = a&b print(result)  -- a&b = 1
result = a|b print(result)  -- a|b = 7
result = ~b print(result)   -- ~b = -6
result = a<<2 print(result) -- a<<2 = 12
result = b>>1 print(result) -- b>>1 = 2

-注意：
lua5.1使用位运算，需引入第三方库，如bitlib
lua5.2使用位运算，使用内置库bit32
lua5.3使用位运算，可直接使用运算符

2.5 其它

2.5.1#

解释：相当于Length或Count
a、

s= "test"

result = #s
print(result)--4

b、
1）

nums = {1,nil,3,nil,4}

result = #nums
print(result )--5

2）

nums = {1,nil,3,nil,4,nil}

result = #nums
print(result )--3

3）

nums = {1,nil,3,nil,4,nil,x=100,y=200}

result = #nums
print(result )--3

注意：
#返回的个数，不包含Table中自定义键的键对数。
当最后一个默认键对的值为nil时，不统计所有键值为nil的键对数。

2.5.2 . .

解释：连接字符串

function Concat(a,b)
	return a..b
end

result = Concat("str","ing")
print(result)--string

-注意：性能消耗大

三、数据结构-Table

3.1 说明

Lua唯一数据结构，下标从1开始，以键值对的方式存储（nil不能作为键）

3.2 举例

定义：

table = {1,"a",x = 100,y = 200,x = 300,2,table1 = {["x"] = 101, 2}}
table.z = 50
table[7] = 7

使用：

print(table[1])--1
print(table[2])--a
print(table["x"])--300
print(table.y)--200
print(table[3])--2
print(table["z"])--50
print(table[7])--7
print(table.table1.x)--101
print(table.table1[1])--2

print(table[10])--nil
print(table.table1["z"])--nil

3.3 遍历方式

3.3.1 pairs

for k,v in pairs(table) do
	print(k,":",v)
end

输出结果：
1 : 1
2 : a
3 : 2
y : 200
z : 50
table1 : table: 0x21d76d0
7 : 7
x : 300

3.3.2 ipairs

for k,v in ipairs(table) do
	print(k,":",v)
end

输出结果：
1 : 1
2 : a
3 : 2

-注意：
a、定义：table = {1,2,3,4,5}
table[7] = 7

for k,v in ipairs(table) do
	print(k,":",v)
end

输出结果：
1 : 1
2 : 2
3 : 3
4 : 4
5 : 5

b、定义：table = {1,2,3,4,5,6}
table[7] = 7

for k,v in ipairs(table) do
	print(k,":",v)
end

输出结果：
1 : 1
2 : 2
3 : 3
4 : 4
5 : 5
6 : 6
7 : 7

四、语句

4.1 添加注释

单行：–
多行：–[[ ]]
嵌套：[=[ ]=]

4.2 赋值

单变量：a = 100
多变量：a,b = 100,“string”
交换： a,b = b,a

4.3 分支

num = 100

if num > 100 then
	print("more")
elseif num > 50 then
	print("middle")
else 
	print("less")
end

4.4 循环

a、for循环
从1开始，100结束，每次+2，

for i = 1,100,2 do
	print("i = ",i)
end

b、while循环
当i<10

i = 0
while i < 10 do
	i = i + 1	
	if a>= 8 do
		break
	end
end

c、repeat循环
i=0，i+2，直到i>=10

i = 0
repeat 
	i = i + 2
until i>=10

Lua没有关键字：continue

五、函数

5.1 定义方式

a、基础写法

add = function(a,b)
	return a+b
end

result = add(1,2)
print(result)--3

b、语法糖写法

function add(a,b)
	return a+b
end

result = add(1,2)
print(result)--3

-注意：

传入：
1）定义两个参数，传入三个参数，不报错，第三个直接丢弃
2）定义三个参数，传入两个参数，若不使用未传参的参数不报错

传出：
1）返回三个返回值，接收两个返回值，不报错，第三个直接丢弃
2）返回两个返回值，接收三个返回值，不报错，接收到的第三个为nil

5.2 多返回值

function fun(a,b)
	return a+b,a*b
end

sum,product = fun(1,2)

print(sum)--3
print(product)--2

5.3 高阶函数

解释：Lua中的函数，可作为参数传递

function add(a,b)
	return a + b
end

function fun(f,a,b)
	return f(a,b)
end

result = fun(add,1,2)
print(result)--3

5.4 可变参数

解释：当参数个数不确定时，用…代替

function add(...)
	local sum = 0
	local arg = {...}
	
	for k,v in ipairs(arg) do
		sum = sum +v
	end
	
	return sum
end

result = add(1,2,3,4)
print(result)--10

六、函数库

6.1 引用方式

a、基础写法

str = "string"

result = string.upper(str)
print(result)--STRING

b、语法糖写法-不适用于多参数

str = "string"

result1 = str : upper()
print(result1)--STRING

result2 = str.upper(str)
print(result2)--STRING

6.2 函数库浏览

Lua5.3参考手册

七、协程

7.1 create示例

1）

co = coroutine.create(
	function()
		print("start")--(1)
		coroutine.yield()
		print("after yield")--(3)
	end
)

coroutine.resume(co)
print("yield")--(2)
coroutine.resume(co)

输出：
(1)start
(2)yield
(3)after yield

2）

co = coroutine.create(
	function(num1,num2)
		print("First num1 =",num1," num2 =",num2)--(1)
		temp1,temp2 = coroutine.yield("startCor",1)
		print("Second num1 =",num1," num2 =",num2)--(3)
		print("Second temp1 =",temp1," temp2 =",temp2)--(4)
	end
)

result1,result2,result3 = coroutine.resume(co,100,101)
print(result1, result2, result3)--(2)
coroutine.resume(co,200,201)

输出：
(1)First num1 = 100 num2 = 101
(2)true startCor 1
(3)Second num1 = 100 num2 = 101
(4)Second temp1 = 200 temp2 = 201

7.2 wrap示例

1）

fun = coroutine.wrap(
	function()
		print("start")--(1)
		coroutine.yield()
		print("after yield")--(3)
	end
)

fun()
print("yield")--(2)
fun()

输出：
(1)start
(2)yield
(3)after yield

2）

fun= coroutine.wrap(
	function(num1,num2)
		print("First num1 =",num1," num2 =",num2)--(1)
		temp1,temp2 = coroutine.yield("startCor",1)
		print("Second num1 =",num1," num2 =",num2)--(3)
		print("Second temp1 =",temp1," temp2 =",temp2)--(4)
	end
)

result1,result2 = fun(100,101)
print(result1, result2)--(2)
fun(200,201)

输出：
(1)First num1 = 100 num2 = 101
(2)startCor 1
(3)Second num1 = 100 num2 = 101
(4)Second temp1 = 200 temp2 = 201

7.3 create与wrap

定义：
co = coroutine.create()
fun = coroutine.wrap()

不同点：
1）返回类型不同。
create()返回类型为thread。
wrap()返回类型为function。
2）执行方式不同。
create依靠coroutine.resume(co)。
wrap依靠fun()。
3）默认返回不同。
coroutine.resume()默认返回bool-即是否成功执行。
fun()默认返回nil。
4）调用Dead不同。
coroutine.resume()调用处于dead状态的协程无效果。
fun()调用处于dead状态的协程报错。

相同点：
1）每次调用coroutine.resume(co)或fun()，执行协程一部分代码，即可调用次数与coroutine.yield数量有关。
2）
每次调用coroutine.resume(co)或fun()传入的参数，作为coroutine.yield的传出参数返回。
每个coroutine.yield的传入参数作为对应coroutine.resume(co)或fun()的传出参数返回。
仅第一次调用coroutine.resume(co)或fun()传入的参数，作为create()或wrap()的传入参数。

-注意：
Lua中的协程可以无coroutine.yield

协程生命周期：start-suspend-running-dead-end
说明：通过coroutine.resume(co)或fun()，使状态由suspend转为running，之后可通过coroutine.yield转回suspend

八、元表与元方法

8.1 元表

（1）lua中的每个值都可以有一个元表，只是table和userdata可以有各自独立的元表，而其他类型的值则共享其类型所属的单一元表。
（2）lua代码中只能设置table的元表，至于其他类型值的元表只能通过C代码设置。
（3）多个table可以共享一个通用的元表，但是每个table只能拥有一个元表。
（4）我们称元表中的键为事件（event），称值为元方法（metamethod）。
（5）可通过函数getmetatable查询任何值的元表。
（6）可通过函数setmetatable替换表的元表
详细解释

8.2 元方法

8.2.1 __index

定义：索引 table[key]。当 table 不是表或是表 table 中不存在 key 这个键时，这个事件被触发。此时，会读出 table 相应的元方法。
尽管名字取成这样，这个事件的元方法其实可以是一个函数也可以是一张表。

解释：
__index用于查询键对应的值。
1)首先判断table中的是否存在想要查询的键，如果存在则返回
2)如果不存在或table不是表，则判断table是否存在元表
3)如果存在元表，则判断元表中是否有__index方法
4)如果存在__index方法，则调用该方法。
--如果该方法是函数则调用该函数，并将table作为第一个参数。
--如果该方法是表，则将该表作为初始table，从第一步开始判断。

(1)如果__index方法是一个函数，则以 table 和 key 作为参数调用它

table = {a = 1}
metatable = {
	__index = function(table,key)
		return 123
	end
}

print(table["b"])---nil

setmetatable(table,metatable)

print(table["b"])---123

(2)如果__index方法是一张表，最终的结果就是以 key 取索引这张表的结果。（这个索引过程是走常规的流程，而不是直接索引，所以这次索引有可能引发另一次元方法。）

table = {a = 1}
metatable = {
	__index = {
		b = 2
	}
}

print(table["b"])---nil
print(table["c"])---nil

setmetatable(table,metatable)

print(table["b"])---2
print(table["c"])---nil

8.2.2 __newindex

定义：索引赋值 table[key] = value 。和索引事件类似，它发生在 table 不是表或是表 table 中不存在 key 这个键的时候。此时，会读出 table 相应的元方法。
同索引过程那样，这个事件的元方法即可以是函数，也可以是一张表。一旦有了 “newindex” 元方法， Lua 就不再做最初的赋值操作。（如果有必要，在元方法内部可以调用 rawset 来做赋值。）

解释：
__newindex用于对键赋值。
1)首先判断table中的是否存在想要查询的键，如果存在则重新赋值该键
2)如果不存在或table不是表，则判断table是否存在元表
3)如果存在元表，则判断元表是否存在__newindex方法
4)如果存在__newindex方法，则调用该方法。
--如果该方法是函数则调用该函数，并将table作为第一个参数传入。
--如果该方法是表，则将该表作为初始table，从第一步开始判断。
5)如果table不存在元表或元表不存在__newindex方法，且table是表，则在当前表新增键值对。

(1)如果是一个函数，则以 table、 key、以及 value 为参数传入。

table = {a = 1}
metatable = {
	__newindex = function(table,key,value)
	end
}

print(table["b"])---nil
print(table["c"])---nil

table["b"] = 2
setmetatable(table,metatable)
table["c"] = 3

print(table["b"])---2
print(table["c"])---nil

table = {a = 1}
metatable = {
	__newindex = function(table,key,value)
		--table[key] = value --stack overflow 死循环
							 --t["c"]=3 -> mt.__newindex () ->  table[key]=value -> mt.__newindex () -> table[key]=value -> ...
		rawset(table,key,value)
	end
}

print(table["b"])---nil
print(table["c"])---nil

table["b"] = 2
setmetatable(table,metatable)
table["c"] = 3

print(table["b"])---2
print(table["c"])---3

(2) 如果是一张表， Lua 对这张表做索引赋值操作。（这个索引过程是走常规的流程，而不是直接索引赋值，所以这次索引赋值有可能引发另一次元方法。）

local k = {}
local metatable = {
	__newindex = k
}
local table = {}

setmetatable(table, metatable)

print("赋值前：")--赋值前：
for k,v in pairs(k) do
	print(k ,v)--无输出
end

table[1] = 20

print("赋值后：table表中的值:")--赋值后：table表中的值:
for k,v in pairs(table) do
	print(k ,v)--无输出
end

print("赋值后：k表中的值:")--赋值后：k表中的值:
for k,v in pairs(k) do
	print(k ,v)--1	20
end

详细解释–文章

详细解释–视频

8.2.3 __call

定义：函数调用操作 func(args)。当 Lua 尝试调用一个非函数的值的时候会触发这个事件（即 func 不是一个函数）。查找 func 的元方法，如果找得到，就调用这个元方法， func 作为第一个参数传入，原来调用的参数（args）后依次排在后面。

解释：
当把非函数table当做函数使用时，
先判断table是否存在对应元表，
如果存在则判断元表中是否存在__call方法，
如果存在__call方法，且该方法是函数则调用该方法，
并将table当做第一个参数传入，其余参数依次排在后面。

function fun(table,x,y) 
	return table.n+x+y 
end

table = {}
table.n = 100

metatable = {}
metatable.__call = fun

setmetatable(table,metatable)

print(table(1,2))--103

九、面向对象(Object Oriented)

9.1 模拟对象

1)初始版本

local monster = {
	name = "Monster1",
	HP = 100,
	pos = {x=100,y=200}
}

monster.TakeDamage = function(self,damage)
	self.HP = self.HP - damage
end

monster.TakeDamage(monster,10)

result = monster.HP
print(result)--90

2)语法糖版本

local monster = {
	name = "Monster1",
	HP = 100,
	pos = {x=100,y=200}
}

function monster:TakeDamage(damage)
	self.HP = self.HP - damage
end

monster:TakeDamage(10)

result = monster.HP
print(result)--90

3)合并版本

local monster = {
	name = "Monster1",
	HP = 100,
	pos = {x=100,y=200},
	TakeDamage = function(self,damage)
		self.HP = self.HP - damage
	end
}

monster:TakeDamage(10)

result = monster.HP
print(result)--90

9.2 模拟类

1)初始版本

CMonster = {
	name="Monster",
	HP=100,
	TakeDamage = function(self,damage)
		self.HP = self.HP - damage
	end,
	ShowInfo = function(self)
		print(self.Name,self.HP)
	end
}

function CMonster:new(name,hp,x,y)
	local obj = {}
	obj.Name = name
	obj.HP = hp
	obj.X = x
	obj.Y = y
	setmetatable(obj, {__index = CMonster})
	return obj
end

local obj1 = CMonster:new("Monster1",100,100,101)
obj1:ShowInfo()--Monster1 100
obj1:TakeDamage(20)
obj1:ShowInfo()--Monster1 80

2)优化版本

CMonster = {
	name="Monster",
	HP=100,
	TakeDamage = function(self,damage)
		self.HP = self.HP - damage
	end,
	ShowInfo = function(self)
		print(self.Name,self.HP)
	end
}

CMonster.__index = CMonster

function CMonster:new(name,hp,x,y)
	local obj = {}
	obj.Name = name
	obj.HP = hp
	obj.X = x
	obj.Y = y
	setmetatable(obj, CMonster)
	return obj
end

setmetatable(CMonster,{__call = function(self,name,hp,x,y)
	return self:new(name,hp,x,y)
end
})

local obj1 = CMonster("Monster1",100,100,101)
obj1:ShowInfo()--Monster1 100
obj1:TakeDamage(20)
obj1:ShowInfo()--Monster1 80

9.3 模拟继承

说明：8.2脚本文件名为Monster.lua

local monster = require("Monster")--继承Monster.lua

local MagicMonster = {
	MP =200,
	Attack = function(self,consume)
		self.MP = self.Mp - consume
	end
}

setmetatable(MagicMonster,{
	__index = monster,
	__call = function(self,name,hp)
		local obj = CM(name,hp)
		setmetatable(obj,{__index = MagicMonster})
		return obj
	end
})

local magicMonster1 = MagicMonster("MagicMonster1 ",100)

magicMonster1 :ShowInfo()--MagicMonster1 100
magicMonster1 :TakeDamage(20)
magicMonster1 :ShowInfo()--MagicMonster1 80

9.4 模拟多态

说明：8.2脚本文件名为Monster.lua

local monster = require("Monster")--继承Monster.lua

local MagicMonster = {
	MP =200,
	Attack = function(self,consume)
		self.MP = self.Mp - consume
	end
}

setmetatable(MagicMonster,{
	__index = monster,
	__call = function(self,name,hp)
		local obj = CM(name,hp)
		setmetatable(obj,{__index = MagicMonster})
		return obj
	end
})

local magicMonster1 = MagicMonster("MagicMonster1 ",100)

magicMonster1 :ShowInfo()--MagicMonster1 100

function MagicMonster:ShowInfo()
	print("Magic Monster:", self.name, self.HP)
end

magicMonster1 :ShowInfo()--Magic Monster: MagicMonster1 80

9.5 模拟私有成员

1)直接封装

function GetMonster()
	local self = {HP = 123, Name = "monster"}
	
	local function GetHP()
		return self.HP
	end
	
	local function GetName()
		return self.Name
	end
	
	local function TakeDamage(_,count)
		self.HP = self.HP - count
		if self.HP <= 0 then
			self.HP = 0
		end
	end
	
	return {GetHP = GetHP, TakeDamage = TakeDamage, GetName = GetName}
end

local monster = GetMonster()

print(monster:GetHP())--123
monster:TakeDamage(20)
print(monster:GetHP())--103
monster.HP = 100
print(monster:GetHP())--103

2)元表封装

local Monster = {}
Monster.HP = 100
Monster.Type = "Monster"

function Monster:GetHP()
	return self.HP
end

function Monster:TakeDamage(damage)
	self.HP = self.HP - damage
end

function Monster:SetHP(hp)
	self.HP = hp
end

function Monster.new()
	local obj = {HP = Monster.HP}
	setmetatable(obj, Monster)
	Monster.__index = {GetHP = Monster.GetHP, TakeDamage = Monster.TakeDamage}
	Monster.__newindex = function(table,key,value)
		if key == "Type" then
			print("Forbiden operate.")
			return
		end
		rawset(table,key,value)
	end
	return obj
end

return Monster

local monster = require("Monster")
local obj = monster:new()
print(obj:GetHP())--100
obj:TakeDamage(10)
print(obj:GetHP())--90
--obj:SetHP(200) --报错 该方法为私有方法，不可访问

print(obj.Type)--Monster
obj.Type = "Monster Test"--Forbiden operate.
print(obj.Type)--Monster

print(obj.MP)--nil
obj.MP = 100
print(obj.MP)--100

十、闭包

function counter()
	local i = 0
	return function()
		i = i + 1
		return i
	end
end

local c1 = counter()
print(c1())--1
print(c1())--2
print(c1())--3

local c2 = counter()
print(c2())--1
print(c2())--2
print(c2())--3

定义：通过调用含有一个内部函数加上该外部函数持有的外部局部变量（upvalue）的外部函数（就是工厂）产生的一个实例函数
闭包详解

十一、关键字

11.1 local

lua中变量默认为全局变量，加local进行限制，转变为局部变量。

参考

Lua5.3参考手册：传送门
VipSkill-Lua语法入门：传送门
Lua在线编程：传送门

凋零叶子

关注

6
点赞
踩
54

收藏

觉得还不错? 一键收藏
1
评论
【Unity】Lua入门

文章目录一、Lua基础1、变量类型2、特点二、语句1、添加注释2、赋值3、分支4、循环三、运算符1.数学运算2.关系运算3.逻辑运算4.位运算三、关键字1.local总结一、Lua基础1、变量类型nil(空)、boolean、number(数字-不区分数字类型)、string、function、userdata、thread(线程)、table2、特点动态类型、弱类型、大小写敏感、默认全局、带GC二、语句1、添加注释单行：–多行：–[[ ]]嵌套：[=[ ]=]2、赋值单
复制链接

扫一扫