str = "双引号字符串"
str2 = '单引号字符串'
--获取字符串的长度
print(#str)

--字符串多行打印
--lua中支持转义字符
print("123\n123")
--定义多行字符串
s = [[你好
我的宝贝
欢迎来到
lua]]
print(s)

str = "双引号字符串"
str2 = '单引号字符串'

--字符串拼接，通过..拼接
print(str..str2)
s1 = "123"
s2 = 1232
s3 = true
--print(s1..s2..s3)  报错，boolean值不能拼接
print(s1..s2)

--字符串拼接，通过format函数拼接
print(string.format("你好，我今年%d岁，尚未婚配",18))
--%d：配对数字
--%a：配对字母
--%s：配对字符

--非字符串类型转字符串
print(tostring(true))
--使用tostring函数，直接打印默认也会调用tostring函数（和C#其他类型转字符串方式是一致的）
print(true)

--其他字符串函数
s = "addDEIN"
--小写转大写
print(string.upper(s))
--大写转小写
print(string.lower(s))
--反转字符串
print(string.reverse(s))
--字符串索引查找
print(string.find(s,"ddD"))
--截取字符串
print(string.sub(s,3,5))
--字符串重复
print(string.rep(s,3))
--字符串修改
print(string.gsub(s,"dd","**"))
--字符转ASCII码
a = string.byte("lua",2)
print(a)
--ASCII码转字符
print(string.char(a))

--条件语句
a = 2

--单分支
if a < 3 then
    print("a<3")
end

--双分支
if a < 4 then
    print("a<4")
else
    print("a>=4")
end

--多分支
if a < 5 then
    print("a<5")
elseif a == 5 then
    print("a=5")
else
    print("a>5")
end

--循环语句

--while循环
num = 0
while num < 5 do
    print(num)
    num = num + 1
end

print("***********************")
--do while循环
--注意：until后面是结束循环的条件，而c#中do while语句while后是继续循环的条件，这一点不同
num = 0
repeat
    print(num)
    num = num + 1
until num > 5

print("************************")
--for循环
--默认自增1，i从1自增到大于5结束
for i = 1,5 do
    print(i)
end
--指定i自增2，i从1自增到大于5结束
for i = 1,5,2 do
    print(i)
end

--函数

--无参无返回值
--函数定义方式一
function F1()
    print("F1函数")
end
--函数定义方式二，类似C#中的委托
F2 = function()
    print("F2函数")
end

F1()
F2()

--函数

--有参数
F1 = function(a)
    print(a)
end

F1(345)

--函数

--有返回值
--函数可以任意返回多个返回值，使用逗号隔开
F1 = function()
    return 1,2,3,"true"
end

print(F1())
--使用多个变量接多返回值，变量个数和返回值个数不统一时也会补空或者丢弃返回值
a,b,c,d = F1()
print(a..b..c..d)

--函数

--变长参数
F1 = function(...)
    arg = {...}
    for i = 1,#arg do
        print(arg[i])
    end
end

F1(1,2,3,4,5,6,7,1,2,12,1)

--函数

--函数嵌套
F1 = function()
    return function()
        print(1234)
    end
end

--返回函数时可以使用一个变量来接收返回函数再调用
F2 = F1()
F2()
--也可以直接使用两个括号调用，第一个括号调用F1，第二个括号调用F1()返回的函数
F1()()


--闭包
F3 = function(x)
    --x作为参数本来是一个临时变量，但是在返回函数中被调用，改变了x的生命周期，称为闭包
    return function(y)
        return x + y
    end
end

print(F3(2)(3))

--数组

--定义数组，任意类型的数据都可以放到同一个表中
a = {1,2,3,"字符串",nil,true,nil}
--lua中数组索引从1开始，所以索引0值为nil
print(a[0])
print(a[1])
print(a[4])
--#是通用的获取长度的关键字，注意：计算长度时，从第一个nil开始的所有数据会被忽略，因此这里计算出来的数组长度为4，取数组长度时true和nil都没有计算在内
print(#a)

--遍历
--通过#遍历数组是一种不可靠的遍历，这里就没有遍历到true
for i = 1,#a do
    print(a[i])
end

--二维数组

a = {{1,2,3},{4,5,6}}
--取值
print(a[1][2])
--遍历
for i = 1,#a do
    for j = 1,#a[i] do 
        print(a[i][j])
    end
end

--自定义索引

a = {[0] = 1,2,3,[-1] = 4,5}
--取值
print(a[0])
print(a[-1])
--获取长度时实际上从下标1开始获取元素个数，所以这里得到的长度是3
print(#a)

--自定义索引跳过其中某些索引出现的异常情况
m = {[1] = 1,[2] = 2,[4] = 4,[6] = 6}
print(#m)  --实际有4个元素，索引值3和5对应的值是nil，但是实际得到的元素个数是6
n = {[1] = 1,[2] = 2,[5] = 5,[6] = 6,[9] = 9,[10] = 10}
print(#n)  --实际有6个元素，有两处跳过了连续两个索引3、4和7、8，但是实际得到的元素个数是2

--迭代器遍历
--#得到的表的长度不准确，使用#遍历不推荐使用，一般使用迭代器遍历

a = {[0] = 1,2,[-1] = 3,4,5}

--ipairs遍历，仍然是从1开始遍历，也只能找到连续索引值，索引值断开会出现遍历不准确的问题
for i,k in ipairs(a) do
    print(i..":"..k)
end

print("******************")

--pairs遍历，能遍历出所有值，推荐使用的遍历方法
for i,v in pairs(a) do
    print(i..":"..v)
end

print("******************")
--pairs遍历，只遍历键的方法
for i in pairs(a) do
    print(i)
end

--字典

--使用自定义索引的方式就可以自定义表
a = {["name"] = "movin",["age"] = 14,["sex"] = true,["1"] = 2}

--使用类似于C#索引器的方式访问字典
print(a["name"])
print(a["age"])
print(a["sex"])
print(a["1"])

print("******************")
--使用类似于成员变量的方式访问
print(a.name)
print(a.age)
--print(a.1)会报错，使用这种方式访问时索引不能是数字

print("******************")
--修改和新增，直接赋值即可，有这个索引就是修改，没有这个索引就是新增
a["sex"] = false
print(a["sex"])
print(a.sex)
a["mm"] = 14
print(a["mm"])
print(a.mm)

print("******************")
--删除，置空即可
a["age"] = nil
print(a["age"])

print("******************")
for k,v in pairs(a) do
    print(k,v)
end

--类

--lua中默认没有面向对象，但是我们可以使用表来表现类
Student = {
    --声明变量age
    age = 1,
    --声明变量sex
    sex = false,

    --成员函数Up
    Up = function()
        print("我成长了")
    end,
    --成员函数Study
    Study = function()
        print("我在学习")
    end,
}

--lua中类的属性和方法更类似于静态的属性和方法
print(Student.age)
Student.Up()
Student.Study()

--类

Student = {
    age = 1,
    sex = false,

    Up = function(s)
        --在表中使用表内的变量和方法，不能直接调用如print(age)，这样访问不到表中的变量age
        --可以通过表名点出调用的变量
        print(Student.age)
        --可以将自己作为参数传递，然后调用
        print(s.name)
    end,

    Study = function()
        print("我在学习")
    end,
}

--在表的外部为表添加属性或方法
Student.name = "movin"
print(Student.name)

--表的外部调用函数Up，将表自身作为参数传递
Student.Up(Student)
--使用冒号可以简写，冒号可以将自身作为第一个参数传递。
Student:Up()


--注意：定义函数时也可以使用冒号进行定义，使用self作为自身
 function Student:Up2()
    print(self.sex)
end

Student:Up2()

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

--表的插入
print(#t1,#t2)
table.insert(t1,t2)  --将t2插入t1最后
print(#t1,#t2)

--删除指定元素
--默认remove函数移除表中最后一个值
print(t1[1])
print(t1[2])
print(t1[3])
table.remove(t1)
print(t1[1])
print(t1[2])
print(t1[3])
--指定移除表中某个元素
table.remove(t1,1)
print(t1[1])
print(t1[2])
print(t1[3])

--表的排序
t3 = {1,3,8,-1,0,5}
--默认升序排序
table.sort(t3)
for _,v in pairs(t3) do
    print(v)
end
--自定义排序规则，类似于C#中list的sort函数的使用，这里实现降序排序
table.sort(t3,function(a,b)
    if a>b then
        return true  --这个返回值可以理解为a和b是否交换位置
    end
end)
for _,v in pairs(t3) do
    print(v)
end

--表的拼接
t4 = {"123","456","789","111"}
--将表中元素使用第二个参数的符号连接成一个字符串
print(table.concat(t4,","))

--局部变量和全局变量

--全局变量
if true then
    a = "全局变量"
end

print(a)

--局部变量
if true then
    local b = "局部变量"
end

print(b)

--被引用的脚本
A = "全局变量A"
local B = "局部变量B"

--引用其他脚本

--同文件夹下直接引用脚本文件名即可，注意：同一个脚本require引入两次及以上，并不会执行两次，也就是说require已经引用的脚本是无效的
require("BeenRequired")
print(A)
print(B) --B是局部变量，这个脚本中看不到

--使用load方法获取一个boolean值，代表脚本是否执行过
print(package.loaded["BeenRequired"])

--卸载脚本，直接把loaded的值置为nil即可
package.loaded["BeenRequired"] = nil
print(package.loaded["BeenRequired"])

--多变量赋值
a,b,c = 1,2
d,e,f = 3,4,5,6
print(a)
print(b)
print(c)
print(d)
print(e)
print(f)

--使用and和or模拟三目运算符的实现
local x = 3
local y = 2
--执行逻辑：利用and和or的短路运算特性
--如果x>y运算的结果为true，则根据and的短路规则会接着判断x的值是真还是假，显然x不为nil当作true处理，因此(x>y) and x的结果是true，根据or的短路特性，不会继续判断y，因此最后返回x
--如果x>y运算的结果为false，则根据and的短路特性，不会判断x，(x>y) and x的结果为false，根据or的短路特性，会继续判断y，显然y不为nil当作true处理，因此false or y的最终返回结果为y
local result = (x>y) and x or y
print(result)

--创建协程

--首先声明一个函数作为协程函数
function fun()
    print(123)
end

--创建方法一：使用coroutine表中的create函数创建协程
co = coroutine.create(fun)
print(co)
print(type(co))

--创建方法二：使用coroutine表中的wrap函数创建协程
co2 = coroutine.wrap(fun)
print(co2)
print(type 
                       
                    
                    
 
                      




鲜花




握手




雷人




路过




鸡蛋