Lua语言快速学习笔记

为什么学lua

芯片高度集成话的好处是之前需要用c写的嵌入式可以被高级语言替代，合宙推出了luat开发方式，移远推出了mricopython开发，阿里支持JavaScript开发，不得不说高级语言在厂家写好底层库的支持下做应用开发效率极其高，代码量也少，适合快速输出原型，因此以lua为起始，体验下高级语言下的嵌入式开发。

在线运行工具

https://c.runoob.com/compile/66

helloworld

print("test")
printf("one","two","three");

注释

• – 单行注释
• –[[xxxxx]] 多行注释

变量及数据类型

1.number

name = "zhangsan"
age = 14
print(name,age)

2.nil

表示未申明或者没有有效值的值

a = 123
print(a)
print(b) --nil

3.多变量赋值

a,b = 10,20
print(a,b) 
c,d = 10,20,30 //多余值会被忽略 
print(c,d) 
e,f = 10 //变量会被赋值未nil
print(e,f)

--输出
10	20
10	20
10	nil

4.string

表达方式

字符串三种表达方式

str1 = "abc"
str2 = 'abc'
str3 =[[abc]]
print(str1,str2,str3)

--输出
abc	abc	abc

注意： 与c不一样的是字符串里面可以填充0x00

转义字符

转义字符	含义
\n	换行(LF),将当前位置移到下一行开头
\r	回车(CR),将当前位置移到本行开头
\	反斜杠字符\
’	单引号
"	双引号
\0	空字符(NULL)
\ddd	1到3位八进制数所代表的任意字符

print('大括号字符串包含"小括号"')
print("输出回车换行\r\n哈哈")

--out

大括号字符串包含"小括号"
输出回车换行
哈哈

常用方法

1.字符串拼接

a = 'hello'
b = "world"
c = a..b --神奇的操作符
print(c)

--out
helloworld

2.字符串转数字

a = "123"
b = tonumber(a)
print(b)

--out
123

3.数字转字符串

a = 29
b="我今年"..tostring(a).."岁了"
print(b)

--out
我今年29岁了

5.boolean

• true
• false

Lua 把 false 和 nil 看作是false，其他的都为true（包括0这个值，也是相当于true）

比较运算符

符号	含义
==	等于，检测两个值是否相等，相等返回 true，否则返回 false
~=	不等于，检测两个值是否相等，相等返回 false，否则返回 true
>	大于，如果左边的值大于右边的值，返回 true，否则返回 false
<	小于，如果左边的值大于右边的值，返回 false，否则返回 true
>=	大于等于，如果左边的值大于等于右边的值，返回 true，否则返回 false
<=	小于等于， 如果左边的值小于等于右边的值，返回 true，否则返回 false

a = 3
b = 4
print(a~=b)
print(a>b)

--out
true
false

逻辑运算符

符号	符号
and	逻辑与操作符。 若 A 为 false，则返回 A，否则返回 B
or	逻辑或操作符。 若 A 为 true，则返回 A，否则返回 B
not	逻辑非操作符。与逻辑运算结果相反，如果条件为 true，逻辑非为 false

逻辑与c一样

6.table

lua中的表类似于js中的object，特别灵活，既能存储同种类型，也能存储不同类型数据。

表达方式

1.直接赋值

a = {1,3,5,"str",true}
print(a[1]);
print(a[4]);
print(a[5]);

--out
1
str
true

注意： lua对table操作下标识从 1 开始的，与其他语言不一样

table中也可以存储函数

t = {  
    function() return 123 end,  
    function() print("abc") end,  
    function(a,b) return a+b end,  
    function() print("hello world") end,  
}  
t[1]()  
t[2]()  
t[3](1,2)  
t[4]()  

--out
abc
hello world

2.指定下标

t = {
    [1] = "h",
    [2] = "e",
    [3] = "l",
    [4] = "l",
    [5] = "0",
    [10] = "w",--可以跳过下标
    [20] = 1200, -- 也可以赋值不同类型
    ["www"] = "o",-- 下标可以是不同类型
    --[what] = "r" ,-- 这种方式也合法，如果有歧义，建议使用上一种
}
print(t[10])
print(t[20])
print(t["www"])

--out
w
1200
o

• 可以跳过下标
• 也可以赋值不同类型
• 下标也可以是不同类型，太TM灵活了

3.动态赋值（模仿对象）

t = {} --空
t["name"] = "张三"
t.age = 22
print(t.name)
print(t.age)

--out
张三
22

还可以嵌套

t = {  
    zs = {  
        name = "张珊",  
        age = 22,  
    },  
    ls = {  
        name = "李四",  
        age = 22,  
        score = 99,
    },  
    name = "北京大学第1班"
}  
print(  
    t.name,  
    t.ls.name,  
    t.ls.age,  
    t.zs.age  
)  

--out
北京大学第1班	李四	22	22

常用方法

1.拼接

table.concat

table.concat (table [, sep [, i [, j ] ] ])
将元素是string或者number类型的table，每个元素连接起来变成字符串并返回。
可选参数sep，表示连接间隔符，默认为空。
i和j表示元素起始和结束的下标

a = {1,2,3,"hello"}
print(table.concat(a))
print(table.concat(a,"-"))

--out
123hello
1-2-3-hello

2.插入元素

table.insert (table, [pos ,] value)
在（数组型）表 table 的 pos 索引位置插入 value，其它元素向后移动到空的地方。pos 的默认值是表的长度加一，即默认是插在表的最后。

t = {1,2}
print[t[1],t[2]]
table.insert(t,1,0) -- 在索引1的位置插入0
print(t[1],t[2],t[3])

table.insert(t,100) -- 在表最后插入100
print(t[1],t[2],t[3],t[4])

--out
1	2
0	1	2
0	1	2	100

3.删除元素

table.remove

table.remove (table [, pos])
在表 table 中删除索引为 pos（pos 只能是 number 型）的元素，并返回这个被删除的元素，它后面所有元素的索引值都会减一。pos 的默认值是表的长度，即默认是删除表的最后一个元素。

t = {1,2,3,4}
print(t[1],t[2],t[3],t[4])
table.remove(t,1) --删除第一个元素
print(t[1],t[2],t[3],t[4])

print(table.remove(t)) --删除自最后一个元素,注意返回最后一个元素
print(t[1],t[2],t[3],t[4])

--out
1	2	3	4
2	3	4	nil
4
2	3	nil	nil

全局变量

lua中所有全局变量全部存储在_G的table中，可以利用它进行操作和赋值

n = 123--新建变量  
print(n)--输出123  
print(_G.n)--输出123  

_G.abc = 1--相当于新建全局变量  
print(abc)--输出1  

_G["def"] = 23--相当于新建全局变量  
print(def)--输出23  

--甚至你可以像下面这样  
_G.print("hello")  
_G["print"]("world")

--out
123
123
1
23
hello
world

程序结构

1.选择

与go相同，没有小括号，但是有个 then,且 if 与 end 成对出现

a = 1
if a < 2 then
    print("a<2")
end

--out
a<2

多条件

a = 69
if a>=80 and a<=100  then
    print("优秀")
elseif a>=60 and a<80  then
    print("良好")
else
    print("不及格")
end

--out
良好

2.循环

1.while

结构

while 循环条件 do
	循环体
end

计算1-100的累加和

temp = 0
res = 0
while temp <= 100 do
    res = res + temp
    temp = temp+1
end
print(res)

--out
5050

2.for

结构

for 临时变量名=开始值，结束值[,变量步长] do
	循环体
end

• 注意：步长可以省略，默认为1

temp = 0
res = 0
for temp=1,100 do
    res = res + temp
end
print(res)

--out
5050

break 可以跳出循环

函数

--定义一个函数
function log()
   print('log..ehhlo');
end

--调用一个函数
log()

lua中函数也是一个变量，可以直接赋值给一个变量

--定义一个函数
function log()
   print('log..ehhlo');
end
a = log
log()
a()
print(a==b) --注意是false

--out
log..ehhlo
log..ehhlo
false

常用函数

type

a = "abc"
b = 1
print(type(a),type(b))

--out
string	number

常用库

字符串截取string.sub

string.sub(s, i [, j])

返回字符串 s 中，从索引i到索引 j之间的子字符串。
i 可以为负数，表示倒数第几个字符。
当 j 缺省时，默认为 -1，也就是字符串 s 的最后位置。
当索引 i 在字符串 s 的位置在索引 j 的后面时，将返回一个空字符串。

s = "abcdefg"
s1 = string.sub(s,1,3)
print(s1)
s2 = string.sub(s,3)
print(s2)

--out
abc
cdefg

简化方法

s = "abcdefg"
print(s:sub(4,5))
print(s:sub(3))

--out
de
cdefg

字符串长度 string.len

a = "abcdefg"
print(string.len(a))

print(a:len()) --简化方法

--out
7
7

字符串大小写

• string.lower(s) 传入字符串，把大写转为小写
• string.upper(s) 传入字符串，把小写转为大写

a = "hello world"
print(string.upper(a))

b = "HELLO WORLD"
print(string.lower(b))

print(a:upper())--简化名称
print(b:lower))--简化名称
--out
HELLO WORLD
hello world
HELLO WORLD
hello world

字符串格式化 string.format

string.format(formatstring, …)
按照格式化参数formatstring，返回后面...内容的格式化版本。
编写格式化字符串的规则与标准 c 语言中 printf 函数的规则基本相同：
它由常规文本和指示组成，这些指示控制了每个参数应放到格式化结果的什么位置，及如何放入它们。
一个指示由字符%加上一个字母组成，这些字母指定了如何格式化参数，例如d用于十进制数、x用于十六进制数、o用于八进制数、f用于浮点数、s用于字符串等。

print(string.format("%.2f",3.1415))
print(string.format("%d %x %o",31,31,31))
print(string.format("%s %d/%02d/%02d", "today is:", 2021,7,31))  

--out
3.14
31 1f 37
today is: 2021/07/31

字节生成字符串 stirng.byte

string.char (…)

接收 0 个或更多的整数（整数范围：0~255），返回这些整数所对应的 ASCII 码字符组成的字符串。当参数为空时，默认是一个 0。

s = string.char(0x30,0x31,0x32,0x33)
print(s)

s = string.char(0x01,0x02,0x03)
print(s)

--out
0123

获取字符串中第n个字节的ascii码 string.byte

string.byte(s [, i [, j ] ])

返回字符 s[i]、s[i + 1]、s[i + 2]、······、s[j] 所对应的 ASCII 码。i 的默认值为 1，即第一个字节,j 的默认值为 i 。

这个函数功能刚好和前面的string.char相反，是提取字符串中实际的数值。

a = "helloworld"
print(string.byte(a,1))
print(a:byte(2))--也可以这样  
print(a:byte())--不填默认是1  

--out
104
101
104

字符串查找string.find

string.find(s, p [, init [, plain] ])
这个函数会在字符串s中，寻找匹配p字符串的数据。如果成功找到，那么会返回p字符串在s字符串中出现的开始位置和结束位置；如果没找到，那么就返回nil。

第三个参数init默认为1，表示从第几个字符开始匹配，当init为负数时，表示从s字符串的倒数第-init个字符处开始匹配。

第四个参数plain默认为false,意义是正则匹配(这里的正则与其它语言也有些许不同)，当其为true时，只会把p看成一个字符串对待。

** 注意：** 返回值是子串在目标串的开始位置和结束位置

a = "helloworld"
print(string.find(a,"wor"))第一个 --默认只会匹配到第一个

print(string.find(a,"ab",2)) --从索引2 开始匹配

print(string.find(a,"l", -3)) --从索引倒数第3开始查找

--out
6	8
nil
9	9

• 一般应用时可以利用find来确定位置，然后z爱用sub来获取要得到的字符串

字符串替换 string.gsub

string.gsub(s, p, r [, n])

将目标字符串s中所有的子串p替换成字符串r。

可选参数n，表示限制替换次数。

返回值有两个，第一个是被替换后的字符串，第二个是替换了多少次。

a = "a b c d e f"
print(string.gsub(a," ",""))

print(a:gsub(" ","-"))

--out

abcdef	5
a-b-c-d-e-f	5

包管理（跨文件调用）

子文件 tools.lua

--使这个代码在哪个文件里都能被调用  
module(..., package.seeall)  

a = 1
local b = 2
---函数功能：  
-- 打印log  
-- @输入值：要输出的字符串 
-- @返回：   
-- @例子：  mylog("abc")
function mylog(str)  
   print(str)
end  

主文件 main.lua

require"tools"
mylog("hello")

注意:

1. 变量定义为local时，只能在本文件内使用
2. 每个文件最多只会被require一次，如果有多个require，只有第一次会执行

待续。。。

参考链接

https://doc.openluat.com/wiki/21?wiki_page_id=1925

https://www.runoob.com/lua/lua-tutorial.html