Lua语法

打印输出

-- 注释 --xxx 或者 多行注释--[[ xxx ]]
--使用print()
print("这里是输出内容")

变量类型

--lua中简单变量类型
-- nil number string booleam
--lua中的一个变量 可以随意赋值，会自动识别类型
--通过 type 函数返回值string 可以得到变量类型

-- 使用没有声明过的变量不会报错
--默认值是nil
print(a)

--number
b = 1
c = 1.2
print(type(b))
print(type(c))

--string
--字符串声明使用单引号或者双引号包裹
d = "123"
e = '123'
print(d)
print(e)

--boolean
a = true
b = false
print(a)
print(b)

--复杂数据类型
--function 函数
--table 表
--userdata 数据结构
--thread 协同程序

字符串操作方法

--字符串长度 使用 #变量 
a = "123456"
print(#a) 

--多行打印 /n
print("123" /n "123")
--或者
s = [[
123
456
789
]]
print(s)
--[[结果：
	123
	456
	789
]]

--拼接 使用 ..
print("123" .. 123)

--其他类型转字符串 tostring()
a = true
print(tostring(a))

--公共方法
s = "aBcdE"
--大小写
print(string.upper(s))
print(string.lower(s))

--翻转
print(string.reverse(s))

--查找
print(string.find(s,"cd")) --返回首尾位置

--截取
print(string.sub(s , 1 , 2)) --返回 aB

--修改
print(string.gsub(s,"a" , "c"))

--转ASCII码
a = string.byte("Lua",3)
print(a)
--ASCII码转字符
print(string.char(a))

运算符

-- 运算符： + - * / % ^（幂运算）
--没有自增自减 ++ --
--没有符合运算 += -= 等
--字符串可以进行算数运算符操作 会自动转为number
print("123.4" + 1) -- 结果： 124.4
print(2 ^ 5) -- 结果：32

--条件运算符
-- > < >= <= == ~=(不等于)

--逻辑运算符
--对比其他语言 && || ! 与或非
-- 		     and   or  not  也遵循短路规则
print(false and true)
print(false or true)
print(not true)
--不支持位运算符和三目运算符

条件分支语句

-- if 条件 then ... end
a = 9
--单分支
if a > 5 then
	print("Yes")
end

--双分支
if a > 10 then
	print("大于10")
else
	print("不大于10")
end

-- 多分支
-- if 条件 then.....elseif 条件 then....elseif 条件 then....else.....end
if a > 15 then
	print("111")
elseif a > 10 then
	print("222")
elseif a > 9 then
	print("333")
else
	print("444")
end

--lua没有switch

循环语句

-- while 条件 do 循环体 end
num = 1
while num >= 10 do
	print(num)
	num = num + 1
end

--do while语句
--在lua中为  repeat 循环体 until 条件
a = 1
repeat
	print(a)
	a = a + 1
until a >= 10

--for循环

for i = 1,5 do --默认自增 i 默认+1 
	print(i) -- 1 2 3 4 5
end

for i = 1,5,2 do --第三个参数代表自定义增量 这里为自增2
	print(i) -- 1 3 5
end

函数

--两种写法
--function 函数名()
--end

-- 函数名 = function()
--end

--无参无返回
function F1()
	print("F1")
end
F1() --调用
--函数类型 就是 function
F2 = function()
	print('F2')
end

--有参数
function F3(a)
	print(a)
end
F3(1)
F3("123")
F3(1,2,3,4) --传入参数个数不匹配不会报错 只会不空或者丢弃

--多返回值
function F4(a)
	return a,1,true,"123"
end

--多返回值时 在前面申明多个变量来接取即可
--如果变量不够 不影响 值接取对应位置的返回值
--如果变量多了 不应 直接赋nil
temp, temp2, temp3, temp4 = F4("1")
print(temp)
print(temp2)
print(temp3)
print(temp4)

--函数重载 lua中不支持函数重载

--变长参数
function F5( ... )
--变长参数使用 用一个表存起来 再用
	arg = {...}
	for i = 1,#arg do	
		print(arg[i])
	end
end
F5(1,2,"3",true,4)

--函数嵌套
function F6()
	return function()
				print(123)
			end
end
f7 = F6()
f7()

--闭包
function F8(x)
	--改变传入参数的生命周期
	return function(y)
				return x + y
			end
end
f9 = F8(1)
print(f9(2))

Table —表

--所有的复杂数据类型都是表  下标从1开始
--数组
a = {1 , 2 , true , 4 , "123"}
print(a[1])
print(a[2])
print(a[3])
print(a[4])
print(a[5])
--通过#获取长度
print(#a)

--如果表中有nil 会影响#获取长度
b = {1 , 2 , true , 4 , "123"}
print(#b) -- 输出2

--迭代器遍历
--使用#获取长度并准确
--ipairs遍历从下标1开始往后遍历，小于等于0的下边无法遍历
--只能找到连续索引，如果断层了无法遍历后面内容
a = {[-1] = 1 , 1,2,3,[0] = 4}
for i,k in ipairs(a) do
	print("ipairs遍历键值"..i.."_"..k) -- i是key k是值
end

--pairs遍历
--能够找到所有值
for i,k in pairs(a) do
	print("pairs遍历键值"..i.."_"..v)
end

字典

--字典由键值对组成
a = {["name"] = "x同学", ["age"] = 18 , ["sex"] = false}
--访问变量
print(a["name"])
print(a.name)

--增
a["address"] = "xxxxx"
print(a["address"])

--删 置空即可
a["sex"] = nil

--改
a["sex"] = true

--遍历
for i,k in pairs(a) do
	print(i,k)
end

for k in pairs(a) do
	print(a[k])
end

类和结构体

--lua中没有类和结构体 需要自己实现

Student = {
	age = 1,
	sex = true,
	Up = function()
		print(age) -- 这个age和表中的age没有任何关系
		--想要在表内调用自己的成员方法或者属性 一定要指明是谁的
		print(Student.age)
	end
	--或者把自己作为参数传进来
	Learn = function(t)
				print(t.age)
			end
}

--lua中 .和冒号的区别
Student.Learn(Student)
--冒号会默认把调用者作为第一个参数传进去
Student:Learn()

--声明表后 在表外去声明变量和方法
Student.name = "x同学"
Studen.Speak = function()
					print("说话")
				end
				
function Student:Speak()
		--关键字 self 代表默认传进去的第一个参数
		print(self.name .. "说话2")
end

--C#要是使用类 实例化对象new 静态直接点
--Lua中类的表现 更像是一个类中有很多 静态变量和函数
print(Student.age)
print(Student.name)
Student.Up()
Student.Speak()
Student:Speak2()
Student.Speak2(Student)

--表的公共操作
t1 = { {age = 1, name = "123"}, {age = 2, name = "345"} }
t2 = {name = "小屁孩", sex = true}
--插入
table.insert(t1,t2)
--移除
--remove方法 传表进去 会移除最后一个索引的内容
table.remove(t1)
--remove方法 传两个参数 第一个参数 是要移除内容的表
--第二个参数 是要移除内容的索引
table.remove(t1 , 1)

--排序 默认升序
t2 = {5,2,7,9,5}
table.sort(t2)

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

-- 拼接
tb = {"123", "456", "789", "10101"}
--连接函数 用于拼接表中元素 返回值 是一个字符串
str = table.concat(tb, ",")
print(str) --123,456,789,10101

全局变量和本地变量

--全局变量
a = 1
b = "123"

--本地变量/局部变量 关键字 local
local aa = 2

--大G表
--_G表是一个总表(table) 他将我们申明的所有全局的变量都存储在其中
for k,v in pairs(_G) do
	print(k , v)
end

多脚本执行

--关键字 require("脚本名")
require("Test") --Test是另外新建脚本

--如果是require加载执行的脚本，加载一次后不会再被执行
--package.loaded["脚本名"] 返回值是boolean 判断脚本是否被执行
print(package.loaded["Test"])
--卸载已经执行过的脚本
package.loaded["Test"] = nil

--require 执行一个脚本时  可以再脚本最后返回一个外部希望获取的内容
local testLA = require("Test")
print(testLA)