合宙780E开发学习-Lua语法速查

打印

print("测试")
print("aabcdefg")
print("xxxxx","第二个参数","第三个参数")

代码注释

print("这段代码会运行")
--print("我被注释掉了，所以不会运行")
--[[
    我是多行注释
    不管我写多少行
    都不会影响代码运行
]]

变量

数字变量

a = 2025

空值

b = nil

字符

c = 'hello'

赋值

使用等号对左边的变量进行赋值

n = 2
n = 3
n = n + 1
b = n

Lua可以对多个变量同时赋值，变量用逗号分开，赋值语句右边的值会依次赋给左边的变量。

n = 1
a, b = 10, 2*n

当左右值的数量不一致时，Lua会进行下面的设定：

• 变量个数 > 值的个数：按变量个数补足nil
• 变量个数 < 值的个数：多余的值会被忽略

数学运算

+ 加法
- 减法
* 乘法
/ 除法
% 取余，求出除法的余数
^ 乘幂，计算次方
- 负号，取负值

字符串string

赋值

--双引号间的一串字符
str1 = "Lua"
--单引号间的一串字符
str2 = 'Lua'
--[[和]]--间的一串字符
str3 = [[Lua]]
str4 = [[使用双括号时，甚至能包含换行数据
换行了
最后一行]]

转义字符

输出单引号时，声明字符串用双引号括起来，同理，输出双引号时，声明字符串用单引号括起来
转义字符表

字符串拼接

使用..进行拼接

print('abc'..'def')
str1 = '123'
str2 = '999'
print(str1..str2)

number转string

使用tostring(value)函数

n = 123
s = 'm/s'

result = tostring(n)..s
print(result)

string转number

使用tonumber(value)函数

n = 123
s = '2333'

result = tonumber(s) + n
print(result)

逻辑运算

比较运算表

逻辑运算符

分支判断

if

单条件判断

if 条件 then
    符合条件的代码
end

多条件判断

if 条件1 then
    满足条件1
elseif 条件2 then
    不满足条件1，但是满足条件2
else
    前面条件全都不满足
end

没有switch！！！！

函数

需要注意的是，在lua语言中，函数是通过function实现的,注意以end结尾

function hello()
    print('Hello world!')
end
--执行
hello()

在Lua中，函数也是一种变量类型，所以可以通过=传递

hello = function()
    print('Hello world!')
end
hello()

local

使用local标志来新建临时变量，使用local创建一个局部变量，与全局变量不同，局部变量只在被声明的那个代码块内有效

传参

function 函数名(参数1,参数2,...)
    代码内容
end

eg.

function add(a,b)
    print(a+b)
end
add(1,2)
--等价于
function add()
    local a = 1
    local b = 2
    print(a+b)
end
add()

返回值

return表示返回一个值，并且立刻结束这个函数的运行

function add(a,b)
    return a+b
end
all = add(1,2)
--这里all的值就是3了
print(all)

数组

在Lua中，我们可以使用table（表）来实现这个功能

t = {1,3,8,5,4}

接使用元素的下标，来访问、或者对该元素进行赋值操作

t = {1,3,8,5,4}
print(t[1]) --打印1
print(t[3]) --打印8

t[2] = 99 --更改第二个元素的值
print(t[2]) --打印99

t[6] = 2 --凭空新建第六个元素并赋值
print(t[6]) --打印2

print(t[10])
--因为不存在，打印nil

table中可以包括任意类型的数据比如我们可以在table中放置number和string数据

t = {
    function() return 123 end,
    function() print("abc") end,
    function(a,b) return a+b end,
    function() print("hello world") end,
}

下标

每个元素的下标都是自动从1排列的，实际上，Lua中，下标可以直接在声明时进行指定

t = {6,7,8,9}
--上面和下面的代码等价
t = {
    [1] = 6,
    [2] = 7,
    [3] = 8,
    [4] = 9,
}

--甚至你可以跳过某些下标
t = {
    [1] = 6,
    [3] = 7,
    [5] = 8,
    [7] = 9,
}
print(t[7])
--输出9

--在声明后赋予元素值也是可以的
t = {}--空的table
t[101] = 10
print(t[101])
--输出10

下标也可以是字符串

t = {
    ["apple"] = 10,
    banana = 12,
    pear = 6,
}
--使用["下标"] = 值
--和  下标 = 值
--都是正确写法
--当第二种方式有歧义时，应该用第一种方式

--可以用下面两种方式访问：
print(t["apple"])
--输出10
print(t.apple)
--输出10
--当第二种方式有歧义时，应该用第一种方式

Lua全局变量与table

在Lua中，所有的全局变量全部被存放在了一个大table中，这个table名为：_G

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")

有点意思，感觉是比较方便的一个东西

table连接

将元素是string或者number类型的table，每个元素连接起来变成字符串并返回。
可选参数sep，表示连接间隔符，默认为空。

local a = {1, 3, 5, "hello" }
print(table.concat(a))
print(table.concat(a, "|"))

-->打印的结果：
--135hello
--1|3|5|hello

删减

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

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

local a = {1, 8}             --a[1] = 1,a[2] = 8
table.insert(a, 1, 3)   --在表索引为1处插入3
print(a[1], a[2], a[3])
table.insert(a, 10)    --在表的最后插入10
print(a[1], a[2], a[3], a[4])

-->打印的结果：
--3    1    8
--3    1    8    10


local a = { 1, 2, 3, 4}
print(table.remove(a, 1)) --删除速索引为1的元素
print(a[1], a[2], a[3], a[4])

print(table.remove(a))   --删除最后一个元素
print(a[1], a[2], a[3], a[4])

-->打印的结果：
--1
--2    3    4    nil
--4
--2    3    nil    nil

循环

while

while 继续循环判断依据 do
    执行的代码
end

local result = 0
local num = 1

while num <= 100 do
    result = result + num
    num = num + 1
end

print(result)

for

for 临时变量名=开始值,结束值,步长 do
    循环的代码
end

local result = 0

for i=1,100 do
    result = result + i
end

print(result)

break-用于中断循环

string库

string.sub

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

print(string.sub("Hello Lua", 4, 7))
print(string.sub("Hello Lua", 2))
print(string.sub("Hello Lua", 2, 1))
print(string.sub("Hello Lua", -3, -1))

-->打印的结果：
lo L
ello Lua

Lua

值得注意的是，我们可以使用冒号来简化语法

s1 = string.sub(s, 4, 7)
s2 = s:sub(4, 7)
--两种写法是等价关系

string.rep

string.rep(s, n)
返回字符串 s 的 n 次拷贝。

print(string.rep("abc", 3))
--输出结果：
--abcabcabc

string.len

string.len(s)
接收一个字符串，返回它的长度。

s = "hello lua"
print(string.len(s))
--输出结果：
9

--同时也可以使用简便语法
print(s:len())

大小写转换

string.lower(s)
接收一个字符串 s，返回一个把所有大写字母变成小写字母的字符串。

string.upper(s)
接收一个字符串 s，返回一个把所有小写字母变成大写字母的字符串。

s = "hello lua"
print(string.upper(s))
print(string.lower(s))
--输出结果：
HELLO LUA
hello lua

--同时也可以使用简便语法
print(s:upper())
print(s:lower())

string.format

string.format(formatstring, …)
按照格式化参数formatstring，返回后面...内容的格式化版本。
编写格式化字符串的规则与标准 c 语言中 printf 函数的规则基本相同

print(string.format("%.4f", 3.1415926))     -- 保留4位小数
print(string.format("%d %x %o", 31, 31, 31))-- 十进制数31转换成不同进制
d,m,y = 29,7,2015
print(string.format("%s %02d/%02d/%d", "today is:", d, m, y))
--控制输出2位数字，并在前面补0

-->输出
-- 3.1416
-- 31 1f 37
-- today is: 29/07/2015

string.char

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

str1 = string.char(0x30,0x31,0x32,0x33)
str2 = string.char(0x01,0x02,0x30,0x03,0x44)
print(str1)
print(str2)

-->输出（不可见字符用�代替）
--0123
--��0�D

string.byte

string.byte(s [, i [, j ] ])
返回字符 s[i]、s[i + 1]、s[i + 2]、······、s[j] 所对应的 ASCII 码。i 的默认值为 1，即第一个字节,j 的默认值为 i 。
这个函数功能刚好和前面的string.char相反，是提取字符串中实际的数值。

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

-->输出（十进制数据）
--50
--50
--49

string.find

string.find(s, p [, init [, plain] ])
这个函数会在字符串s中，寻找匹配p字符串的数据。如果成功找到，那么会返回p字符串在s字符串中出现的开始位置和结束位置；如果没找到，那么就返回nil。
第三个参数init默认为1，表示从第几个字符开始匹配，当init为负数时，表示从s字符串的倒数第-init个字符处开始匹配。
第四个参数plain默认为false，当其为true时，只会把p看成一个字符串对待

有点像正则表达式

string.gsub

string.gsub(s, p, r [, n])
将目标字符串s中所有的子串p替换成字符串r。
可选参数n，表示限制替换次数。
返回值有两个，第一个是被替换后的字符串，第二个是替换了多少次

print(string.gsub("Lua Lua Lua", "Lua", "hello"))
print(string.gsub("Lua Lua Lua", "Lua", "hello", 2)) --指明第四个参数

-->打印的结果：
-- hello hello hello   3
-- hello hello Lua     2

夸文件调用

新建一个文件叫tools.lua，放进一个函数
tools.lua

---函数功能：
-- 生成从1-max的table
-- @输入值：table的最大值
-- @返回：  table结果
-- @例子：  local list = getNumberList(10)
local function getNumberList(max)
    local t = {}
    for i=1,max do
        table.insert(t,i)
    end
    return t
end

--手动返回一个table，包含了上面的函数
return {
    getNumberList = getNumberList,
}

那么在main.lua中，可以这样调用
main.lua

--引用tools.lua文件，并加载
local tool = require("tools")
local list = tool.getNumberList(12)

或者可以这样写
文件1

--以便一会儿返回使用的table
local temp = {}

--把全局变量a更改了
a = 1

--local变量无法被外部调用
--但是可以在文件内被调用
local b = 2

--文件在被require的时候，会被执行
--把全局变量c更改了
c = a + b

--使函数在table里
function temp.addB()
    --文件内部可以调用变量b
    b = b + 1
    return b
end

--返回table
return temp

文件2

local test = require("test")
print(a)--输出1
print(b)--输出nil，因为b是local变量
print(c)--输出3

print(test.addB())--输出3
print(test.addB())--输出4
print(test.addB())--输出5

每个文件最多只会被require一次，如果有多个require，只有第一次会执行

正则表达式

print(string.find('hello world','(%a+)')) --> 1 5 hello

正则表达式表

元字符	描述	备注
%a	匹配字母，无论大小写
%b	匹配对称字符，一般写法为"%bxy"，x为开始匹配字符，y为结束匹配字符，xy可随意指定	例如："%b<>"为匹配包括<>在内的所有字符
%c	匹配控制字符	例如：换行符\n、制表符\t等
%d	匹配数字0-9
%l	匹配小写字母a-z
%p	匹配标点符号
%s	匹配空白符号
%u	匹配大写字母A-Z
%w	匹配字母和数字
%x	匹配十六进制数字
%z	匹配代表0的字符
.	匹配任意字符
%	特殊字符的转义字符	例如：“%.“为匹配点号，”%%“为匹配百分比符号，跟””"用来转义引号类似
()	匹配与返回括号内的内容
[]	自定义匹配字符集	例如："[a-z0-9,%]"匹配a-z、0-9、逗号以及百分比号
+	匹配前一字符1次或多次
*	匹配前一字符0次或多次	最长匹配
-	匹配前一字符0次或多次	最短匹配
?	匹配前一字符0次或1次
^	匹配字符串开头	例如："^%d+"为以数字开头的匹配
$	匹配字符串结尾	例如："%d+$"为以数字结尾的匹配
这里推荐合宙自己的正则表达式测试工具
比如我需要提取字符串中的数字,可以在这里进行调试