Lua环境搭建
1、下载 lua for window
https://github.com/rjpcomputing/luaforwindows
Download-->LuaForWindows_v5.1.5-52.exe
安装完成后，cmd--->lua，显示lua版本则成功
2、Sublime Text
https://www.sublimetext.com/download
参考课程：【唐老狮】Unity热更新之Lua语法_哔哩哔哩_bilibili
打印与注释
Lua
--单行注释及打印函数
--lua语句 可以省略分号
--[[
实际项目开发，使用的IDE（集成开发环境）
VSCode
IDEA
LuaStudio
使用Sublime Text是因为轻便快捷，且没有代码提示
]]
--print打印函数
print("hello world")
print("测试")
--ctrl+B 运行
--[[
多行注释
]]
--[[
第二种多行
注释
]]--
--[[
第三种多行注释
--]]变量
Lua
--变量
--Lua当中的简单变量类型
--nil number string boolean
--lua中的变量可以随便赋值，自动识别类型
--lua中所有的变量申明的都不需要申明变量类型，会自动判断类型
--类似C#中的var C#中的null
a = nil
print(a)
--number 所有的数值都是number
a = 1
print(a)
a = 1.2
print(a)
--string
a = "12312"
--字符串的声明，使用单引号或双引号包裹
a = '123'
--lua中没有char
--boolean
a = true
print(a)
a = false
print(a)
--通过type函数获得变量的类型
print(type(a))
--type返回值为string
print(type(type(a)))
--lua中使用没有声明过的变量
--不会报错，默认值为nil
print(b)
--[[
函数 function
表 table
数据结构 userdata
协同程序 thread(线程)
]]String字符串
Lua
--字符串
str = "双引号字符串"
str2 = '单引号字符串'
--获取字符串的长度
print(#str) --18
--一个汉字占3个长度
s = "abCD"
--英文字符占1个长度
print(#s) --4
--字符串多行打印
--lua支持转义字符
print("123\n123")
s = [[
多行
进行输
出
]]
print(s)
--字符串拼接 通过..
print("123" .. "456")
s1 = "123456"
s2 = 2
print(s1 .. s2) -- 可以不同类型变量进行拼接
print(string.format("进行了测试，测试了%d次", 20))
--%d：与数字拼接
--%a 与任何字符拼接
--%s 与字符拼接
--别的类型转为字符串
a = true
print(tostring(a))
--字符串提供的公共方法
str = "abCdEfg"
--小写转为大写
print(string.upper(str))
--大写转小写
print(string.lower(str))
--翻转字符串
print(string.reverse(str))
--字符串索引查找
print(string.find(str, "CdE")) --3 5
--lua索引是从1开始
print(string.find(str, "C")) --3 3
--截取字符串
print(string.sub(str, 3)) --从索引开始截取
print(string.sub(str, 3, 4)) --截取两个数字之间
--字符串重复
print(string.rep(str, 2)) --abCdEfgabCdEfg
--字符串修改
print(string.gsub(str, "Cd", "**")) --ab**Efg 1
--字符 转 ASCII码
a = string.byte("Lua", 1) --指定位置字符转为ASCII码
print(a)
--ASCII码 转 字符
print(string.char(a))
--[[
长度获取 #
多行打印 转义字符
字符串拼接 ../string.format %d %s
别的类型转字符串 tostring()
字符串提供的公共方法 upper lower reverse find sub rep gsub字符串修改 sring.byte string.char
]]运算符Operator
Lua
--运算符
--算术运算符
-- + - * / % ^
--没有++ -- 和 复合运算符 += -= *= /= %=
print("加法运算" .. 1 + 2)
a = 1
b = 2
print(a + b)
--字符串可以进行算术运算符，会自动转成number
print("123" + 1) --122
print("123.4" + 1) --122.4
print("减法运算" .. 1 - 2)
print("123" - 1) --124
print("123.4" - 1) --124.4
print("乘法运算" .. 1 * 2) --2
print("123.4" * 2) --246.8
print("除法运算" .. 1 / 2) --0.5
print("123.4" / 2) --61.7
print("取余运算" .. 1 % 2) --1
print("123.4" % 2) --1.4
--lua中，^ 符号是幂运算
print("幂运算" .. 2 ^ 2) --4
print("123.4" ^ 2) --15227.56
--条件运算符
--> < >= <= == ~=(不等于)
print(3>1)
print(3<1)
print(3>=1)
print(3<=1)
--不等于 ~=
print(3==1)
print(3~=1)
--逻辑运算符
--and与 or或 not非
--C# 是&& || ~
--在lua中，也遵循逻辑运算的"短路"规则
print(true and false)
print(true or false)
print(not true)
print(false and print("info")) --短路，直接不执行后面的语句
--位运算符
--不支持位运算，需要自己实现
--C#是& |
--三目运算符
--lua不支持三目运算符
--C#为 a ? b：c条件分支语句
Lua
--条件分支语句
--if else
a = 6
--if 条件 then ... and
--单分支
if a > 5 then
print("123")
end
--双分支
--if 条件 then ... else ... end
if a < 5 then
print("123")
else
print("321")
end
--多分支
--if 条件 ... then ..。 elseif 条件 then ... else ... end
if a < 5 then
print("123")
-- lua中 elseif需要连起来，否则报错
elseif a == 6 then
print("6")
elseif a == 7 then
print("7")
elseif a == 8 then
print("8")
else
print("other")
end
--lua中没有switch语法
if a >= 3 and a <= 9 then
print("3到9之间")
end循环语句Loop
Lua
--循环语句
--while
num = 0
--while 条件 do ... end
while num <= 5 do
print(num)
num = num + 1
end
--do while
--repeat ... until 结束条件
num = 0
repeat
print(num)
num = num + 1
until num > 5 --直到num大于5，跳出 满足条件跳出(结束条件)
--for
--lua默认递增，i默认+1
for i = 1, 5 do
print(i) --1~5
end
for i = 1,5,2 do --如果要自定义增量，直接逗号后面添加
print(i) --输出1 3 5
end
for i = 5,1,-1 do --如果要自定义增量（减少），直接逗号后面添加
print(i) --输出5 4 3 2 1
end
--[[
while 条件 do ... end
repeat ... until 条件
for 变量名=起始值,结束值,增值 do ... end
]]函数Function
Lua
--函数
--从上到下依次读取 lua是解释型语言，逐条读取，逐条执行
--function 函数名()
--end
--a = function()
--end
--无参数无返回值
function f1()
print("f1函数")
end
f1()
f2 = function() --类似C#中的委托和时间
print("f2函数")
end
f2()
--有参数
--如果传入的参数和函数参数个数不匹配，不会报错
--如果没有传入参数，只会补空nil，如果传入多个参数，会丢弃
function f3(a)
print(a)
end
f3(1)
f3("123")
f3("true")
f3() --nil
f3(1,2,3) --1
--有返回值
--多返回值时，在前面申明多个变量来接取即可
--如果变量不够，不受影响，值接取对应位置的返回值
--如果变量多了，直接赋值nil
function f4(a)
return a, "456", true
end
temp = f4("123")
temp1, temp2, temp3, temp4 = f4("123")
print(temp) --123
print(temp1) --123
print(temp2) --456
print(temp3) --true
print(temp4) --nil
--函数的类型
--函数类型为function
f5 = function()
print("123")
end
print(type(f5))
--函数的重载 不支持重载，默认调用最后一个声明的函数
---函数名相同，参数列表不同
function f6()
print("输出信息")
end
function f6(str)
print(str)
end
f6() --输出nil
--变长参数
function f7( ... )
arg = {...}
for i=1,#arg do
print(arg[i])
end
end
f7(1,2,3,4,5,6,7)
f7(1,"123",true,4,5,6)
--函数嵌套
function f8( ... )
return function()
print(123)
end
end
f9 = f8()
f9()
--闭包函数closure
function f10(x)
--改变传入参数的生命周期
return function(y)
return x + y
end
end
f11 = f10(10)
print(f11(5)) --15
--[[
a = function()
function f()
函数传参时，多了会丢弃，少了会补空
外部用多个变量来接取，少了丢弃，多了为nil
函数不支持重载
变长函数 ... 先用表接，再使用
函数嵌套：函数里面声明函数 闭包改变变量声明周期
]]表Table
Lua
--复杂数据类型 Table 迭代器遍历
--所有的复杂类型都是table表
--数组
a = {1, 2, 3, 4, "5", true, nil}
--lua中，索引从1开始
print(a[0])
print(a[1])
--#是通用的获取长度的关键字
--在打印长度时，空被忽略
print(#a)
--数组的遍历
--中间为nil会断掉长度，获取不准确
for i=1,#a do
print(a[i])
end
--二维数组
a = {{1,2,3},{4,5,6}}
print(a[1][1])
print(a[2][3])
--二维数组的遍历
for i=1,#a do
b = a[i]
for j=1,#b do
print(b[j])
end
end
--自定义索引
--忽略小于等于0的索引
aa = {[0] = 1, 2, 3, [-1]=4, 5}
print(aa[0])
print(#aa) --3
bb = {[1] = 1, [2] = 2, [4] = 4, [5] = 5}
print(#bb) --5
--自定义索引跳跃性设置
bb = {[1] = 1, [2] = 2, [5] = 5} --空的多于2个，则只显示前面的，后面的都不要
print(#bb) --2
--迭代器遍历 Pairs
--主要用来遍历表
--#得到的长度，其实并不准确，一般不要用#来遍历表
c = {[0]=1, 2, [-1]=3, 4, 5}
--ipairs
--ipairs遍历，从1开始往后遍历，小于等于0的值得不到
--只能找到连续索引的键，如果中间断序了，无法遍历出后面的内容
for i,k in ipairs(c) do
print("ipairs遍历键值" .. i .. "_" .. k)
end
--pairs迭代器遍历
--能够将所有的键都找到，通过键可以得到值
for i,v in pairs(c) do
print("pairs遍历键值" .. i .. "_" .. v)
end
--[[
ipairs 不能找到0和0以下的自定义索引内容
如果从1开始索引顺序断了，后面的内容也找不到
pairs 建议使用此来遍历各种不规则的表
可以得到所有信息
]]字典、类和结构体
Lua
--复杂数据类型 字典、类和结构体、表的公共操作
--字典
--字典的声明 键值对
a = {["name"]="aaa", ["age"]=18, ["1"]=5}
--访问单个变量，用中括号填键访问
print(a["name"])
print(a["age"])
print(a["1"])
--还可以类似成员变量的形式得到值
print(a.name)
print(a.age)
--虽然可以通过成员变量的形式得到值，但是不能时数字
--print(a.1) --报错
--修改
a["name"] = "BBB"
print(a.name)
--新增
a["sex"] = false
print(a["sex"])
print(a.sex)
--删除
a["sex"] = nil
print(a["sex"])
print(a.sex)
--如果要模拟字典，遍历一定要用pairs
for k,v in pairs(a) do
--可以传多个参数一样可以打印出来
print(k,v)
end
for k in pairs(a) do
print(k)
print(a[k])
end
for _,v in pairs(a) do
print(v)
end
--类和结构体
--Lua中默认没有面向对象，需要自己来实现
--成员变量 成员函数
Student = {
--成员变量
age = 1,
sex = true,
--成员函数
Up = function()
--print(age) --nil 这个age和表中age没有任何关系，是一个全局变量
--想要在表内部函数中调用表本身的属性或方法，一定要指定是谁的，使用表名.属性 或 表名.方法
print(Student.age)
print("我成长了")
end,
Learn = function(t)
--在函数内部调用自己属性或方法
--把自己作为一个参数传进来，在内部访问
print(t.sex)
print("我学习了")
end
}
--申明表后，在表外去申明表有的变量和方法
Student.name = "姓名"
Student.Speak = function()
print("说话")
end
function Student:Speak2()
--lua中，关键字self表示
print()
print("说话2")
end
--C# 使用类：实例化对象new 静态
--Lua中类的表现更像是一个中有很多静态变量和函数
print(Student.age)
Student.Up()
Student.Speak()
Student.Speak2()
Student.Learn(Student)
--**Lua中，.和:的区别------冒号调用方法，会默认将调用者作为第一个参数传入方能法中
Student:Learn()
--表的公共操作
t1 = {{name = "123", age = 1}, {name = "456", age = 22}}
t2 = {name = "测试", age = 3}
print(#t1)
--插入
table.insert(t1, t2)
print(#t1)
print(t1[1].name)
print(t1[3].name)
--remove方法，传表进去会移除最后一个索引的内容
table.remove(t1)
print(#t1)
print(t1[1].name)
print(t1[2].name)
print(t1[3])
--第一个参数：要移除内容的表 第二个参数：移除表中内容的索引
table.remove(t1, 1)
print(t1[1].name)
--排序 升序
t3 = {5,2,7,9,5}
table.sort(t3)
for _,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)b
end
--拼接
--用于拼接表中元素，返回值为字符串
tb = {"123", "456", "789"}
str = table.concat(tb, ",")
print(str)多脚本执行
test.lua
Lua
print("测试")
test_a = "123456"
local test_b = 789
--将本地变量返回
return test_b全局变量、局部变量、 _G
Lua
--多脚本执行
--全局变量和本地变量
--全局变量
a = 1
b = "123"
for i = 1,2 do
c = "输出"
end
print(c) --c全局全局变量 输出
--局部变量
for i = 1,2 do
local d = "信息"
end
print(d) --nil
fun = function()
tt = "123456"
end
fun()
print(tt) --123456
fun2 = function()
local t2 = "789"
end
fun2()
print(t2) --nil
local t3 = "456789"
print(t3) --456789
--多脚本执行
--关键字 require("脚本名")
--创建Lesson11_test.lua
require("Lesson11_test")
print(test_a) --输出test中全局变量test_a的值
print(test_b) --nil
--脚本卸载
--如果require加载执行的脚本，加载一次后不会再被执行
require("Lesson11_test")
--package.loaded["脚本名"]
--返回值为boolean，该脚本是否被执行
print(package.loaded["Lesson11_test"])
package.loaded["Lesson11_test"] = nil
print(package.loaded["Lesson11_test"])
--执行一个脚本时，可以在脚本最后返回一个外部希望获取的内容
local test_b = require("Lesson11_test")
print(test_bb) --789
--大G表
--_G时是一个总表(table)，将我么声明的所有全局变量都存储在其中
for k,v in pairs(_G) do
print(k,v)
end
--本地变量 加了local的变量不会存到大_G表中
--[[
局部变量 local
多脚本执行 require("脚本名")
脚本的最后可以return一个外部希望获取的内容，一般情况下是一个局部变量
脚本卸载 package.loaded["脚本名"] = nil
_G总表，将声明的所有全局变量都存储在其中，加了local的变量不会存在大_G表中
]]特殊用法
Lua
--特殊用法
--多变量赋值
a, b, c = 1, 2, "123"
print(a)
print(b)
print(c)
--后面的值不够，会自动补空
d,e,f = 1, 2
print(d)
print(e)
print(f) --nil
--如果后面值多了，会自动省略
--多返回值
function test()
return 10, 20, 30, 40
end
aa, bb, cc = test()
print(aa)
print(bb)
print(cc)
--and or
--逻辑与 逻辑或
--and or 不仅可以连接boolean，任何类型都可以连接
--在lua中，只有nil和false才认为是假
--短路：对于and，有假则假 对于or，有真则真
--只需要判断第一个是否满足就停止计算
--and 有假直接输出 or 有真直接输出
print(1 and 2) --2
print(nil and 1) --nil
print(false and 1) --false
print(true and 3) --3
print(true or 3) --true
print(false or 5) --5
--lua不支持三目运算符
--但是可以模拟三目运算符
x = 3
y = 2
local temp = (x > y) and x or y
print(temp) --3元表
Lua
--元表
--[[
任何表变量都可以作为另一个表变量的元表
任何表变量都可以有自己的元表
当我们子表中进行了一些特定擦做时，会执行元表中的内容
]]
meta = {}
my_table = {}
setmetatable(my_table, meta)
--特定操作
--__tostring
meta2 = {
--子表被当作字符串使用，会默认调用元表中的__tostring方法
__tostring = function(t) ---子表将自己作为参数传入，打印子表的成员变量
return t.name
end
}
my_table2 = {
name = "姓名"
}
--设置元表函数
-- 参数一：子表 参数二：元表(父表)
setmetatable(my_table2, meta2)
print(my_table2)
--__call
meta3 = {
__tostring = function(t)
return t.name
end,
--子表被当作函数来使用，默认调用__call中的内容
__call = function(a, b)
print(a) --将子表作为参数，执行print，调用__tostring方法，输出t.name
print(b) --1 第二个参数作为
print("子表被作为函数调用")
end
}
my_table3 = {
name = "子表姓名"
}
setmetatable(my_table3, meta3)
my_table3(1) --子表被作为函数调用
--运算符重载
meta4 = {
--add
__add = function(t1, t2)
return t1.age + t2.age
end,
--sub
__sub = function(t1, t2)
return t1.age - t2.age
end,
--mul
__mul = function(t1, t2)
return t1.age * t2.age
end,
--div
__div = function(t1, t2)
return t1.age / t2.age
end,
--mod
__mod = function(t1, t2)
return t1.age % t2.age
end,
--pow
__pow = function(t1, t2)
return t1.age ^ t2.age
end,
--equ
__eq = function(t1, t2)
return t1.age == t2.age
end,
--lt
__lt = function(t1, t2)
return t1.age < t2.age
end,
--le
__le = function(t1, t2)
return t1.age <= t2.age
end,
__concat = function(t1, t2)
return t1.age .. t2.age
end
}
my_table_4_1 = {
age = 3
}
setmetatable(my_table_4_1, meta4)
my_table_4_2 = {
age = 2
}
setmetatable(my_table_4_2, meta4)
print("两个表指定成员变量相加为：" .. my_table_4_1 + my_table_4_2)
print("两个表指定成员变量相减为：" .. my_table_4_1 - my_table_4_2)
print("两个表指定成员变量相乘为：" .. my_table_4_1 * my_table_4_2)
print("两个表指定成员变量相除为：" .. my_table_4_1 / my_table_4_2)
print("两个表指定成员变量取余为：" .. my_table_4_1 % my_table_4_2)
print("两个表指定成员变量幂函数为：" .. my_table_4_1 ^ my_table_4_2)
--如果要用条件运算符比较两个对象，两个对象的元表要一致，才能准确调用
print(my_table_4_1 == my_table_4_2)
print(my_table_4_1 < my_table_4_2)
print(my_table_4_1 <= my_table_4_2)
print("两个表指定成员变量拼接为：" .. my_table_4_1 .. my_table_4_2)
--__index和__newIndex
--__index 当子表中找不到某一个属性时，会到元表中__index指定的表去找索引
meta6 = {}
my_table6 = {}协程
Lua
--协程程序
--协程的创建
--coroutine.create()
fun = function()
print(123)
end
co = coroutine.create(fun)
--协程的本质是一个线程对象
print(co)
print(type(co))
--coroutine.wrap()
co2 = coroutine.wrap(fun)
print(co2)
print(type(co2))
--协程的运行
--第一种 对应通过create创建的协程
coroutine.resume(co)
--第二种 对应wrap的协程
co2()
--协程的挂起
fun2 = function()
local i = 1
while true do
print(i)
i = i + 1
--协程的挂起函数
print(coroutine.status(co3))
coroutine.yield()
return i
end
end
co3 = coroutine.create(fun2)
--默认第一个返回值是协程是否启动成功
--yield里面的返回值
coroutine.resume(co3) --只执行一次
isok, temp1 = coroutine.resume(co3) --只执行一次
print(isok, temp1) --true
co4 = coroutine.wrap(fun2)
--也可以有返回值，只是没有默认第一个返回值
co4()
print("返回值"..co4())
--协程的状态
--[[
coroutine.status(协程对象)
dead 结束
suspended 暂停
running 进行中
]]
print(coroutine.status(co3))
print(coroutine.status(co))
coroutine.running()
--[[
创建协程程序
coroutine.create 返回值为一个thread对象
coroutine.wrap 返回值为一个函数
启动协程
coroutine.resume(协程对象) 默认返回值第一个为是否开启
coroutine.wrap 直接调用函数
协程挂起
coroutine.yield(返回值)
协程的状态
coroutine.status(协程对象或协程函数) dead suspended running
coroutine.running() 返回一个线程编号
]]