初学lua杂记

公司使用lua嵌套式语种开发，只能默默学习起，在学习和使用中在记事本上记录了一些相关的知识，有杂乱，但还好不算太乱。

boolean
在Lua中任何值都可以表示一个条件.Lua将值false和nil视为"假",而将除此之外的其他值视为"真".Lua在条件测试中, 将数字零和空字符串也都视为"真"
在Lua中,函数是作为"第一类值(first-class value)“来看待的,可以像操作其他值一样来操作一个函数值
…
在Lua中,”…“是字符串连接操作符.当直接在一个数字后面输入它的时候,必须要用一个空格来分隔它们.不然,Lua会将第一个点理解为一个小数点.
table(表)
table既不是"值"也不是"变量”,而是"对象".可以将一个table想象成一种动态分配的对象,程序仅持有一个对它们的引用(或指针),table的创建是通过"构造表达式(constructor expression)"完成的,最简单的构造表达式是{}.
a.x与a[x]
a.x=a[“x”]
前者表示a[“x”],表示以字符串"x"来索引table，而后者是以变量x的值来索引table。
a={}
x=“y”
a[x]=10
print(a[x])—>10
print(a.x) —>nil
print(a.y) —>10
交换
a=“one thing”
b= string.gsub(a,“one”,“a”)
print(a)
print(b)
#
字符串前放置获取该字符串长度
a=“hello”
print(#a)
print(#“good\0bye”)–>8
长度操作符“#”用于返回一个数组或线性表的最后一个索引值（或为其大小）
a={1,2,32,5}
for i=1,#a do
print(a[i]) -->打印所有行
end

print(a[#a]) -->打印最后一个值
a[#a]=nil     -->删除最后一个
print(a[#a]
a[#a+1]=5     -->加到列表末尾
print(a[#a])

索引实际类型不同的变化
i=10 j=“10” k="+10"
a={}
a[i]=“one thing”
a[j]=“another thing”
a[k]=“yet anther thing”
print(a[j])
print(a[k])
print(a[tonumber(j)])
print(a[tonumber(k)])

floor
向下取整
a=math.floor(3.6)
print(a)—>3

lua中的变量全是全局变量，无论语句块或是函数里，除非用local显式声明为局部变量，变量默认值为nil，只在被声明的代码块有效

and or not
and,如果它的第一个操作数为假，就返回第一个操作数，不然返回第二个数。
or，第一个操作数为真，就返回第一个操作数，不然返回第二个操作数。
not，永远返回false或true

repeat，until循环
sum = 2
repeat
sum = sum ^ 2 --幂操作
print(sum)
until sum >1000

lua中ipairs和pairs的区别 ipairs从1输出，pairs没有顺序可言
pairs遍历table中的所有的key-vale 而ipairs会根据key的数值从1开始加1递增遍历对应的table[i]值
pairs可以遍历表中所有的key，并且除了迭代器本身以及遍历表本身还可以返回nil;但是ipairs则不能返回nil,只能返回数字0，如果遇到nil则退出。它只能遍历到表中出现的第一个不是整数的key

多重返回值函数
如果一个函数调用不是一系列表达式的最后一个元素，那么将产生一个值
unpack:接受一个数组作为参数，并从下标1开始返回该数组的所有元素
print(unpack{10,20,30})–>10 20 30
a,b=unpack{10,20,30} -->a=10,b=20,30丢弃
print(unpack{[1]=10,[2]=20,[3]=30,[5]=50})–>10 20 30 第四个元素为nil，停止，和ipairs类似

**select("#",…)**会返回所有变长参数的总数，其中包括nil。

函数属第一类值
function derivative(f,delta)
delta = delta or 1e-4
return function(x)
return(f(x+delta)-f(x))/delta
end
end
c=derivative(math.sin)
–sin=f,delta=1e-4,return得到c代表：function(x) return(f(x+delta)-f(x))/delta end end
print(math.cos(10),c(10)) --赋值x=10,返回(f(x+delta)-f(x))/delta的结果

table.sort排序
network = {
{name = “grauna”,IP = “210.26.30.34”},
{name = “arraial”,IP = “210.26.30.23”},
{name = “lua”,IP = “210.26.23.12”},
{name = “derain”,IP = “210.26.23.20”},
}
table.sort(network,function(a,b) return(a.name>b.name) end)–按字符的反序输出排序
for i=1,#network do
print(network[i].name)
print(network[i].name,network[i].IP)
end

局部函数的递归
local fact 或local function fact (n) --注意这里不能写local fact = function(n),调用 fact = function(n) fact(n-1)时由于局部的fact尚未定义完，因此这句其实调用了全局的fact
if n == 0 then return 1
else return m*fact(n-1)
end
end

resume/yield
　　 Lua中协同的强大能力，还在于通过resume-yield来交换数据：

（1）resume把参数传给程序（相当于函数的参数调用）；

（2）数据由yield传递给resume;

（3）resume的参数传递给yield；

（4）协同代码结束时的返回值，也会传给resume
local co = coroutine.create(function(name)
for i = 1, 2, 1 do
print(name);
print(“co:” … coroutine.yield(“yield param”));
end
return “协同程序函数结束喇！”
end);
for i = 1, 3, 1 do
print("=========第" … i … “次执行：”)
local result, msg = coroutine.resume(co, “resume param”);
print(“msg:” … msg);
end

print输出自带换行
mt= {}
for i=1,5 do
mt[i]={}
for j=1,5 do
mt[i][j]=0
io.write(mt[i][j]," ")
if j==5 then print() end
end
end

Lua在创建一个新的table时不会创建元表。因此有两个函数可以获取与设置元表：
setmetatable( t1,t2 ) 设置t1的元表为t2。
getmetatable( t ) 获取t的元表。

lua 正则表达式与字符串匹配

正则表达式语言由两种基本字符类型组成：原义（正常）文本字符和元字符。元字符使正则表达式具有处理能力。所谓元字符就是指那些在正则表达式中具有特殊意义的专用字符，可以用来规定其前导字符（即位于元字符前面的字符）在目标对象中的出现模式。

（1）元字符
较为常用的元字符包括： “+”， “”，以及 “?”。其中，“+”元字符规定其前导字符必须在目标对象中连续出现一次或多次，“”元字符规定其前导字符必须在目标对象中出现零次或连续多次，而“?”元字符规定其前导对象必须在目标对象中连续出现零次或一次。
。
/fo+/
因为上述正则表达式中包含“+”元字符，表示可以与目标对象中的 “fo”, “foo”, 或者 “fooo” 等在字母f后面连续出现一个或多个字母o的字符串相匹配。
/eg*/
因为上述正则表达式中包含“*”元字符，表示可以与目标对象中的 “e”, “eg” 或者 “egg” 等在字母e后面连续出现零个或多个字母g的字符串相匹配。
/Wi?/
因为上述正则表达式中包含“？”元字符，表示可以与目标对象中的 “W”, 或者 “Wi”,等在字母i后面连续出现零个或一个字母 i 的字符串相匹配。
除了元字符之外，用户还可以精确指定模式在匹配对象中出现的频率。例如，
/jim{2,6}/
上述正则表达式规定字符m可以在匹配对象中连续出现2-6次，因此，上述正则表达式可以同jimmy或jimmmmmy等字符串相匹配。

string.find(s, pattern [, init [, plain]] )
s: 源字符串
pattern: 在字符串s中匹配pattern，如果匹配成功返回第一个匹配到的子串的起始索引和结束索引 ，如果pattern中有分组，分组匹配的内容也会接着两个索引值之后返回。如果匹配失败返回nil。
init: 可选， 起始位置，缺省值是1，可以为负索引
plain: 可选布尔值参数plain为true时，pattern作为普通字符串匹配，所有正则中的元字符都只被 作为普通字符解析。（这个参数并不是匹配字符串的结束索引）
%s 空白符
%p 标点
%c 控制字符
%d 数字
%x 十六进制数
%z 代表0的字符
%a 字母
%l 小写字母
%u 大写字母
%w 字母数字
字符类的大写形式代表相应集合的补集， 比如 %A 表示除了字母以外的字符集
*： 匹配前面指定的 0 或多个同类字符， 尽可能匹配更长的符合条件的字串
+： 匹配前面指定的 1 或多个同类字符， 尽可能匹配更长的符合条件的字串
-： 匹配前面指定的 0 或多个同类字符， 尽可能匹配更短的符合条件的字串
lua 使用 %1-%9 表示拷贝捕获

print(string.find('Hanazawa Kana', 'na'))  ----3  4
print(string.find('Hanazawa Kana', '[%a]+'))   ----1  8
print(string.find('  Hanazawa Kana', '[%a]+'))      --3    10    
print(string.find('2015-5-12 13:53', '(%d+)-(%d+)-(%d+)'))     --1  9  2015  5  12
print(string.find('%a1234567890%a', '%a', 3, true))    --13   14
print(string.find("haha", 'ah') )  ----- 输出 2 3
_, q=string.find("haha", 'ah')  --虚变量(即下划线)(_)
print(q)  ----- 输出 3

pair = " name = Anna "
print(string.find(pair,"(%a+)%s*=%s*(%a+)"))
----"(%a+)%s*=%s*(%a+)" 表示，先匹配一个或多个字母，然后是零个或多个空白符（比如空格）        ，然后是个 '='， 然后空白符， 然后字母。这样， 满足匹配的只有 "name = Anna"。所以输出       位置为2?12.

因为捕获了两个 (%a+)，也就是 name, Anna 这两个单词，所以还输出了这两 个单词

Lua 点调用和冒号调用的区别
点定义函数 ->需要显示传递或接收self
冒号定义函数 -> 可以省略self参数

math.round() 求该值最近的一个正数，小数点后第一位大于五个位数加，等于五大一，小于五不加
**math.ceil()**附近最大整数
math.floor() 附近最小整数

作者：抱正远大的年
来源：优快云
原文：https://blog.youkuaiyun.com/qq_40552268/article/details/88304103
版权声明：本文为博主原创文章，转载请附上博文链接！