1.Lua基础变量、运算符（不包含thread）、表的基础知识、迭代器

一、变量

包含 nil​、number​、string​、boolean​、function​、thread（携程）​、userdata（数据结构）​、table（表）​

1. ​number​包含了所有的数字
2. lua声明变量类似于python，不需要加类型
3. lua可以使用没有初始化的变量，默认为​​nil​​

print("**********变量************")
--lua当中的简单变量类型
-- nil number string boolean
--lua中所有的变量申明 都不需要申明变量类型 他会自动的判断类型
--类似C# 里面的 var
--lua中的一个变量 可以随便赋值 ——自动识别类型
--通过 type 函数 返回值时string 我们可以得到变量的类型

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

--nil 有点类似 C#中的null
print("**********nil************")
a = nil
print(a)
print(type(a))
-- type返回的是一个string
print(type(type(a)))
--number 所有的数值都是number
print("**********number************")
a = 1
print(a)
print(type(a))
a = 1.2
print(a)
print(type(a))
print("**********string************")
a = "12312"
print(a)
print(type(a))
--字符串的声明 使用单引号或者双引号包裹
--lua里 没有char
a = '123'
print(a)
print(type(a))
print("**********boolean************")
a = true
print(a)
a = false
print(a)
print(type(a))

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

输出：

**********变量************
nil
**********nil************
nil
nil
string
**********number************
1
number
1.2
number
**********string************
12312
string
123
string
**********boolean************
true
false
boolean

二、字符串操作

1. 一个英文字母占一个字符，一个中文字符占3个字符
2. 字符串拼接使用 ..​
3. 多行字符串使用 [[]]​包裹
4. 字符串索引查找，返回起始和终止的下标，​注意下标从1开始​​

‍

print("**********字符串************")
str = "双引号字符串"
str2 = '单引号字符串'

--获取字符串的长度
print("**********字符串长度************")
s = "aBcdEfG字符串"
--一个汉字占3个长度
--英文字符 占1个长度
print(#s)

print("**********字符串多行打印************")
--lua支持转义字符的
print("123\n123")

s = [[你好
世
界
]]
print(s)

print("**********字符串拼接************")
--字符串拼接 通过..
print( "123" .. "456" )
s1 = 111
s2 = 111
print(s1 .. s2)

print(string.format("我今年%d岁了", 18))
--%d :与数字拼接
--%a：与任何字符拼接
--%s：与字符配对
--.......
print("**********别的类型转字符串************")
a = true
print(tostring(a))

print("**********字符串提供的公共方法************")
str = "abCdefgCd"
--小写转大写的方法
print(string.upper(str))
--大写转小写
print(string.lower(str))
--翻转字符串
print(string.reverse(str))
--字符串索引查找，返回起始和终止的下标
print(string.find(str, "Cde"))
--截取字符串
print(string.sub(str, 3, 4))
--字符串重复
print(string.rep(str, 2))
--字符串修改
print(string.gsub(str, "Cd", "||"))

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

输出：

**********字符串************
**********字符串长度************
16
**********字符串多行打印************
123
123
你好
世
界

**********字符串拼接************
123456
111111
我今年18岁了
**********别的类型转字符串************
true
**********字符串提供的公共方法************
ABCDEFGCD
abcdefgcd
dCgfedCba
3    5
Cd
abCdefgCdabCdefgCd
ab||efg||    2
76
L

三、运算符

3.1 注意

包含 +​、-​、*​、/​、^(幂运算)​、 >​、 <​、 >=​、 <=​、 ~=(不等于)​ 、and​、 or​、 not​

1. 没有自增自减 ++ --
2. 没有复合运算符 += 、 -=等
3. 字符串算术运算符操作，会自动转换number

print("**********运算符************")
print("**********算数运算符************")
-- + - * / % ^
-- 没有自增自减 ++ --
-- 没有复合运算符 += -= /= *= %=
--字符串 可以进行 算数运算符操作 会自动转成number
print("加法运算" .. 1 + 2)
a = 1
b = 2

a = a + b
a = a + 1
print(a + b)
print("123.4" + 1)

print("减法运算" .. 1 - 2)
print("123.4" - 1)

print("乘法运算" .. 1 * 2)
print("123.4" * 2)

print("除法运算" .. 1 / 2)
print("123.4" / 2)

print("取余运算" .. 1 % 2)
print("123.4" % 2)

--^ lua中 该符号 是幂运算
print("幂运算" .. 2 ^ 5)
print("123.4" ^ 2)

print("**********条件运算符************")
-- > < >= <= == ~=
print(3>1)
print(3<1)
print(3>=1)
print(3<=1)
print(3==1)
--不等于 是 ~=
print(3~=1)

print("**********逻辑运算符************")
--&&  ||  !   “短路”
--and  or  not  lua中 也遵循逻辑运算的 “短路” 规则
print( true and false)
print( true and true)
print( false and true)

print( true or false)
print( false or false)

print( not true)

print("**********位运算符************")
-- & | 不支持位运算符 需要我们自己实现

print("**********三目运算符************")
-- ? :  lua中 也不支持 三目运算

输出：

**********运算符************
**********算数运算符************
加法运算3
6
124.4
减法运算-1
122.4
乘法运算2
246.8
除法运算0.5
61.7
取余运算1
1.4
幂运算32
15227.56
**********条件运算符************
true
false
true
false
false
true
**********逻辑运算符************
false
true
false
true
false

四、条件运算符

1. 不支持switch和三目运算符（? :）
2. 格式：

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")
elseif a == 9 then
    print("9")
else
    print("other")
end

print("**********条件分支语句************")
a = 9
--if 条件 then.....end
--单分支
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....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")
elseif a == 9 then
    print("9")
else
    print("other")
end


if a >= 3 and a <= 9 then
    print("3到9之间")
end

--lua中没有switch语法  需要自己实现

输出：

**********条件分支语句************
123
321
9
3到9之间

五、循环

1. ​​while....do....​ ​ ：不满足条件跳出，先判断在执行
2. ​​repeat...unitl...​ ​ ：满足条件跳出，先执行再判断

print("**********循环语句************")

print("**********while语句************")
num = 0
--while 条件 do ..... end
while num < 5 do
    print(num)
    num = num + 1
end
print("**********do while语句************")
num = 0
--repeat ..... until 条件 （注意：条件是结束条件）
repeat
    print(num)
    num = num + 1
until num > 5 --满足条件跳出 结束条件

print("**********for语句************")

for i =2,5 do --默认递增 i会默认+1
    print(i)
end

for i =1,5,2 do --如果要自定义增量 直接逗号后面写
    print(i)
end

for i =5,1,-1 do --如果要自定义增量 直接逗号后面写
    print(i)
end

输出：

**********循环语句************
**********while语句************
0
1
2
3
4
**********do while语句************
0
1
2
3
4
5
**********for语句************
2
3
4
5
1
3
5
5
4
3
2
1

六、函数（function）

1. function可以直接取名字或者使用变量存储
2. 传参多少不会报错，多丢弃，少补nil，返回值同理，可以返回多个，接受的时候，少丢弃，多补nil
3. 不支持重载
4. 变长参数，先用table接取，在去使用
5. ​​闭包​​： 简短来说，在Lua中当你创建了一个内部函数，并且这个内部函数引用了外部函数中的局部变量，那么就形成了一个闭包。这使得这些局部变量的生命周期不仅限于外部函数的执行期间，而是延长到这些内部函数不再使用为止

--闭包
function F9(x)
    --改变传入参数的生命周期
    return function(y)
        return x + y
    end
end

print("**********函数************")
--function 函数名()
--end

--a = function()
--end
print("**********无参数无返回值************")
function F1()
    print("F1函数")
end
F1()
--有点类似 C#中的 委托和事件
F2 = function()
    print("F2函数")
end
F2()

print("**********有参数************")
function F3(a)
    print(a)
end
F3(1)
F3("123")
F3(true)
--如果你传入的参数 和函数参数个数不匹配
--不会报错 只会补空nil 或者 丢弃
F3()
F3(1,2,3)
print("**********有返回值************")
function F4(a)
    return a, "123", true
end
--多返回值时 在前面申明多个变量来接取即可
--如果变量不够 不影响 值接取对应位置的返回值
--如果变量多了 不应 直接赋nil
temp, temp2, temp3, temp4 = F4("1")
print(temp)
print(temp2)
print(temp3)
print(temp4)

print("**********函数的类型************")
--函数类型 就是 function
F5 = function( )
    print("123")
end
print(type(F5))

print("**********函数的重载************")
--函数名相同 参数类型不同 或者参数个数不同
--lua中 函数不支持重载 
--默认调用最后一个声明的函数
function F6()
    print("测试")
end
function F6(str)
    print(str)
end

F6()

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

print("**********函数嵌套************")
function F8()
    return function()
        print(123);
    end
end
f9 = F8()
f9()

--闭包
function F9(x)
    --改变传入参数的生命周期
    return function(y)
        return x + y
    end
end

f10 = F9(10)
print(f10(5))

输出：

**********函数************
**********无参数无返回值************
F1函数
F2函数
**********有参数************
1
123
true
nil
1
**********有返回值************
1
123
true
nil
**********函数的类型************
function
**********函数的重载************
nil
**********变长参数************
1
123
true
4
5
6
**********函数嵌套************
123
15

七、表

一切复杂数据的基础（要看源代码，坑很多）

print("**********复杂数据类型 talbe************")
--所有的复杂类型都是table（表）
print("**********数组************")
a = {1,2,3,"1231",true,nil}
--lua中 索引从1开始
print(a[1])
print(a[5])
print(a[6])
print(a[7])
--#是通用的获取长度的关键字
--在打印长度的时候 空被忽略
--如果表中（数组中）某一位变成nil 会影响#获取的长度
print(#a)
print("**********数组的遍历************")
for i=1,#a do
    print(a[i])
end
print("**********二维数组************")
a={{1,2,3},{4,5,6}}
print(a[1][1])
print("**********二维数组的遍历************")
for i=1,#a do
    b=a[i]
    for j=1,#b do
        print(b[j])
    end
end
print("**********自定义索引************")
aa={[0]=1,2,3,[-1]=4,5}
print(aa[0])
print(aa[-1])
-- 即便使用自定义索引 也会导致  2 3 5是连续的
print(aa[1])
print(aa[2])
print(aa[3])

print("----------------------------")
-- 深坑,与table底层实现有关系 索引断掉两个会被认为是单独的两个
-- 不建议使用
bb={[1]=1,[2]=2,[4]=4,[5]=5}
cc={[1]=1,[2]=2,[5]=4,[6]=5}
print("bb长度"..#bb)
print("cc长度"..#cc)
print(bb[1])
print(bb[2])
print(bb[3])
print(bb[4])
print(bb[5])

输出：

**********复杂数据类型 talbe************
**********数组************
1
true
nil
nil
5
**********数组的遍历************
1
2
3
1231
true
**********二维数组************
1
**********二维数组的遍历************
1
2
3
4
5
6
**********自定义索引************
1
4
2
3
5
----------------------------
bb长度5
cc长度2
1
2
nil
4
5

八、迭代器

1. 建议使用pairs，ipairs只能找到连续的部分

print("**********迭代器遍历************")
--迭代器遍历 主要是用来遍历表的
--#得到长度 其实并不准确 一般不要用#来遍历表

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

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

print("**********pairs迭代器遍历************")
--它能够把所有的键都找到 通过键可以得到值
for i,v in pairs(a) do
    print("pairs遍历键值"..i.."_"..v)
end

print("**********pairs迭代器遍历键************")
for i in pairs(a) do
    print("pairs遍历键"..i)
end

输出：

**********迭代器遍历************
**********ipairs迭代器遍历************
ipairs遍历键值1_2
ipairs遍历键值2_4
ipairs遍历键值3_5
**********ipairs迭代器遍历键************
ipairs遍历键1
ipairs遍历键2
ipairs遍历键3
**********pairs迭代器遍历************
pairs遍历键值1_2
pairs遍历键值2_4
pairs遍历键值3_5
pairs遍历键值0_1
pairs遍历键值-1_3
pairs遍历键值5_6
**********pairs迭代器遍历键************
pairs遍历键1
pairs遍历键2
pairs遍历键3
pairs遍历键0
pairs遍历键-1
pairs遍历键5

这篇文章介绍了Lua编程语言的基础知识，主要包括以下内容：

1. 变量类型：nil、number、string、boolean、function、thread、userdata和table

2. 字符串操作：

   • 长度计算（中文字符占3字节）
   • 拼接使用".."
   • 多行字符串使用[[]]
   • 字符串查找返回起始和终止索引（从1开始）

3. 运算符：

   • 算术运算符：+、-、*、/、^（幂运算）
   • 比较运算符：>、<、>=、<=、~=（不等于）
   • 逻辑运算符：and、or、not
   • 注意：没有自增自减运算符
     文章通过代码示例详细说明了各种变量类型的声明和使用方法，字符串的常见操作，以及运算符的使用规则。