1. 变量命名规范
弱类型语言(动态类型语言)，定义变量的时候，不需要类型修饰 而且，变量类型可以随时改变 每行代码结束的时候，要不要分号都可以 变量名 由数字，字母下划线组成，不能以数字开头，也不能是保留字,而且不可以使用特殊字符 变量名区分大小写,避免创建下划线开头加大写字母组成的变量名
2. 变量类型
变量分为三种类型，全局变量，局部变量，表字段 默认创建的都是全局变量，局部变量用 local 修饰
3. 保留字
4. 文档注释
-- [[
多行注释
]]
-- 单行注释
5. 基本数据类型
Lua 中有八种基本类型： nil、boolean、number、 string、function、userdata、 thread和table，库函数type返回一个描述给定值类型的字符串 type (v)返回其唯一参数的类型，编码为字符串
（1）nil ，在lua 中，只有false 和 nil 才表示假 0和空串表示真
（2）boolean 布尔类型
（3）string 字符串
str1="abcd";
str2=string.upper(str1);--转大写
print(str2);
print(string.lower(str2));--转小写
print(string.len(str1));--字符串长度
print(string.len("你好 lua"));--
print(string.reverse(str1));--反转
str3=789;
print("abc".."xyz"..str1..str2..123 ..456.56 ..str3..000);---连接符，number 如果在连接符左边，后面要空格
print("");
str4="abcd1234";
print(string.sub(str4,3,5));--截取，后面参数是开始位置和结束位置，结束位置可省略不写
print(string.sub(str4,-4,-2));--负数是从右往左数
--string.find(s, pattern, init, plain) 在字符串s中 查找pattern(可以是表达式)，如果找到，则返回pattern 第一次出现的开始位置和结束位置,如果没找到，返回nil
str1="abcd1234";
--print(string.find(str1,"cd"));
--print(string.find(str1,"cd",3));--从指定位置处开始查找
--print(string.find(str1,"cd",-6));--如果是负数，则是从字符串长度+该负数的位置开始找
--print(string.find(str1,"%d",6));--最后一个参数，默认就是false，开启正则匹配模式
--print(string.find(str1,"(%d%d%d%d)"));
--print(string.find(str1,"%d",6,true));--最后一个参数，true 是直接当子串处理（4）function
function 在lua 中一个基本的数据类型，是第一类值
格式
function funcName()
...
...
end
传参或返回值，都很自由
function 可以作为参数被传递，也可以作为值被赋值给另一个变量（5）number，包括整型和浮点型
（6）userdata ，自定义数据格式
（7）thread，协程
（8）table，表
表，不是指数据库中的表，而是一种数据类型，类似于map，用k-v的方式来表现，理论上来讲，除了nil，其它字符都可以作为k 值(索引值)
格式
类似于hash
tableName={
k=v,
}
类似于数组 -- 下标是从1开始
tableName={v,v,v}
可以用hash 格式和 array 格式混搭
x={11,22,33};
y={44,55,66};
t1={
{11,22,33},
{44,55,66}
};
--table.concat(list, sep, i, j) 将数组中的元素拼接成一个字符串
--table.remove(list, pos) 删除数组中元素，默认删除最后一个
--table.insert(list, pos, value) 向指定位置插入元素，默认插入到最后
--table.sort(list, comp) 数组排序，默认从小到大，可自定义排序规则
--table.move(a1, f, e, t, a2) 把数组a1中的元素往a2中拷贝
t1={"abc","DEF","xyz","123","456"};
print(table.concat(t1,"--"));
table.remove(t1,2);
print(table.concat(t1,"--"));
table.insert(t1,2,"123456");
print(table.concat(t1,"--"));
table.sort(t1);
print(table.concat(t1,"--"));
function func1(a,b)
return a>b;
end
table.sort(t1,func1);
print(table.concat(t1,"--"));
print("\n");
t2={"a","b"};
table.move(t1,1,2,3,t2);--把t1 里面的元素拷贝到t2 中
print(table.concat(t1,"--"));
print(table.concat(t2,"--"));
for 循环遍历
for k,v in pairs(tableName) do
print(k,v);
end
c++ 中 pairs 是对组
循环嵌套
for k,v in pairs(info3) do
print(k,"===",v);
if type(v)=="table" then
for k2,v2 in pairs(v) do
print("\t",k2,"===",v2);
end
end
end6.基本运算符
--[[
赋值=
lua 中变量是弱类型，就是说变量名是没有类型的，其类型取决于所赋的值，并且，同一个变量，可以随时切换成不同的数据类型
多重赋值
a,b=b,a 值交换 类似于swap
算术运算符
加+,减-,乘*,除/,取模%,指数(次方)^
关系运算符
等于==, 不等于~=, 大于>, 小于<, 大于或等于>=, 小于或等于<=
关系运算符的运算结果只能是true 或 false，且只能在相同类型的数据间运算(运算时不会做隐式类型转换)
对于对象型的数据(function,userdata,table)，比较运算是比较其引用
逻辑运算符
逻辑与 and, 逻辑或 or, 逻辑非 not
&&, ||, !
在lua 中，逻辑运算与其它语言的逻辑运算不是同一个意思，其运算结果返回值是参与运算的变量之一(not 除外，not 只返回true 或 false)
其它语言的逻辑运算，返回值是0 或 1(false 或 ture)，意思就是返回一个bool 值
在lua 中，只有 nil(null,NULL) 和 false 为假，其它都为真(包括空串或0值)
对于and 和 or，实行短路运算(又称短路规则，短路求值，就是说，当前面的表达式可以返回时，就直接返回，不管后面的表达式)
]]
info1={a='a',b='b'};
info2={a='a',b='b'};
info3=info1;
print(info1 == info2);--false 比较的是引用
print(info1 == info3);--true 比较的是引用
print(info1.a == info2.a);--true 比较的是值
print(info1.a);
info3.a='aaa';
print(info1.a);
a,b=1,2;
print(a and b);--如果a 为真，则返回b
a=nil;
print(a and b);--如果a 不为真，则返回a，不再往后运算(不管b是啥)
print("\n");
c,d=1,false;
print(c or d);--如果 c 为真，则返回c，不再往后运算(不管d 是啥)
c=nil;
print(c or d);--如果 c 不为真，则返回d
print("\n");
e,f=1,2;
--print(e not f); --错误写法
print(not e);--如果e为真，则返回假
f=false;
print(not f);--如果f 为假，则返回真7.流程控制
（1）判断语句
流程控制语句
if 条件 then
...
end（2）循环语句
while 条件 do
...
end
repeat
...
until 条件;
while 和 repeat 的区别
while 循环中，当条件不成立时，结束循环
repeat 循环中，当条件成立时，结束循环
没有 continue
break 只能跳出一重循环
goto FLAG 语句 跳转到指定标记处，也可用于跳出循环，FLAG是一个标记位，相当于一个锚点
两者区别是
break 只能跳出当前循环，而goto 可以跳转到指定位置，这样可以忽略一些代码
在lua 中，没有这些运算符 i++, i--, ++i, --i, +=, -=
a=b=1 这种写法会出错，不能连续赋值
--求和 1+2+3+...100 5050
i,sum=0,0;
while i<100 do
if i>49 then
goto FLAG;
--break;
end
i=i+1;
sum=sum+i;
end
print(i,sum);
print("111111");
::FLAG::
print("222");
i,sum=0,0;
repeat
i=i+1;
sum=sum+i;
until i>=100;
print(i,sum);
for 循环分为数值循环和泛型循环(类似于foreach)
数值循环
for 变量名=初始值,结束值,步长(默认值为1,可省略) do
...
end
泛型循环
for k,v in 迭代函数(table) do -- 此处 v 可以省略，k 不能少
...
end
迭代函数 ipairs，pairs
ipairs 顺序遍历，中间的序号不会断开，遇到k=>v 直接跳过，遇到第一个nil 就会直接终止，一般情况下，用于数组类型的集合遍历
pairs 遇到nil 会跳过，同时适用数组类型和k=>v 类型的集合，混搭也是没问题的，如果是混搭的时候，会优选获取数组类型数据
pairs 的适用范围大于 ipars
如果使用时不确定用哪个，就无脑pairs（3）goto语句
--[[
流程控制语句
goto FLAG 语句 跳转到指定标记处，也可用于跳出循环，FLAG是一个标记位，相当于一个锚点
代码块(作用域) do ... end
flag 不可见原则
1 不能从外面 goto 到代码块里面，因为代码块里面的flag，对于外面的 goto来说，是不可见的
2 不能跳出或跳入一个函数，因为函数也是一个block(块)
3 不能跳入本地变量(local)作用域
]]--
do
a=123;
::FLAG1::;
print(a);
::FLAG2::;
goto FLAG1;--此处goto 是在 local b 的作用域外面，所以报错
local b=456;
::FLAG3::;
print(b);
--goto FLAG1;--此处goto 是在 local b 的作用域里面
end
--print(a);
--print(b);
--[[
function func1()
::FLAG1::;
print("func1--11");
print("func1--22");
goto FLAG3;
::FLAG2::;
print("func1--33");
::FLAG3::;
end
::FLAG4::;
print("aaaa");
func1();
::FLAG5::;
print("bbb");
]]--
--[[
print("1234");
goto FLAG1;
do
print("a");
print("b");
::FLAG1::;
print("c");
print("d");
::FLAG2::;
end
::FLAG3::;
print("aa");
print("bb");
::FLAG4::;
print("cc");
print("dd");
]]--
--死循环
--[[
i=0;
::FLAG1::;
print(i);
i=i+1;
goto FLAG1;
]]--
