打印

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

代码注释

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

变量

数字变量

lua">a = 2025

空值

lua">b = nil

字符

lua">c = 'hello'

赋值

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

lua">n = 2
n = 3
n = n + 1
b = n

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

lua">n = 1
a, b = 10, 2*n

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

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

数学运算

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

字符串string

赋值

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

转义字符

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

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

字符串拼接

使用..进行拼接

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

number转string

使用tostring(value)函数

lua">n = 123
s = 'm/s'result = tostring(n)..s
print(result)

string转number

使用tonumber(value)函数

lua">n = 123
s = '2333'result = tonumber(s) + n
print(result)

逻辑运算

比较运算表

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

逻辑运算符

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

分支判断

if

单条件判断

lua">if 条件 then符合条件的代码
end

多条件判断

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

没有switch！！！！

函数

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

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

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

lua">hello = function()print('Hello world!')
end
hello()

local

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

传参

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

eg.

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

返回值

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

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

数组

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

lua">t = {1,3,8,5,4}

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

lua">t = {1,3,8,5,4}
print(t[1]) --打印1
print(t[3]) --打印8t[2] = 99 --更改第二个元素的值
print(t[2]) --打印99t[6] = 2 --凭空新建第六个元素并赋值
print(t[6]) --打印2print(t[10])
--因为不存在，打印nil

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

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

下标

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

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

下标也可以是字符串

lua">t = {["apple"] = 10,banana = 12,pear = 6,
}
--使用["下标"] = 值
--和  下标 = 值
--都是正确写法
--当第二种方式有歧义时，应该用第一种方式--可以用下面两种方式访问：
print(t["apple"])
--输出10
print(t.apple)
--输出10
--当第二种方式有歧义时，应该用第一种方式

Lua全局变量与table

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

lua">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，表示连接间隔符，默认为空。

lua">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 的默认值是表的长度，即默认是删除表的最后一个元素。

lua">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    10local 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

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

lua">local result = 0
local num = 1while num <= 100 doresult = result + numnum = num + 1
endprint(result)

for

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

lua">local result = 0for i=1,100 doresult = result + i
endprint(result)

break-用于中断循环

string库

string.sub

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

lua">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 LuaLua

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

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

string.rep

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

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

string.len

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

lua">s = "hello lua"
print(string.len(s))
--输出结果：
9--同时也可以使用简便语法
print(s:len())

大小写转换

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

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

lua">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 函数的规则基本相同

lua">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。

lua">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相反，是提取字符串中实际的数值。

lua">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，表示限制替换次数。
返回值有两个，第一个是被替换后的字符串，第二个是替换了多少次

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

lua">---函数功能：
-- 生成从1-max的table
-- @输入值：table的最大值
-- @返回：  table结果
-- @例子：  local list = getNumberList(10)
local function getNumberList(max)local t = {}for i=1,max dotable.insert(t,i)endreturn t
end--手动返回一个table，包含了上面的函数
return {getNumberList = getNumberList,
}

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

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

或者可以这样写
文件1

lua">--以便一会儿返回使用的table
local temp = {}--把全局变量a更改了
a = 1--local变量无法被外部调用
--但是可以在文件内被调用
local b = 2--文件在被require的时候，会被执行
--把全局变量c更改了
c = a + b--使函数在table里
function temp.addB()--文件内部可以调用变量bb = b + 1return b
end--返回table
return temp

文件2

lua">local test = require("test")
print(a)--输出1
print(b)--输出nil，因为b是local变量
print(c)--输出3print(test.addB())--输出3
print(test.addB())--输出4
print(test.addB())--输出5

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

正则表达式

lua">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+$"为以数字结尾的匹配
这里推荐合宙自己的正则表达式测试工具
比如我需要提取字符串中的数字,可以在这里进行调试