最基础Lua语法教程，一看就会！（下篇）

接上篇，

今天我们继续学习Lua语法基础教程，下篇。

9.函数

9.1 初识函数

函数是指一段在一起的、可以做某一件事儿的程序，也叫做子程序。

在前面的内容中，我们已经接触过了函数的调用，这个函数就是前面用到了很多次的print(...)。

调用函数只需要按下面的格式即可：

函数名(参数1,参数2,参数3,......)

为何要使用函数？因为很多事情都是重复性操作，我们使用函数，可以快速完成这些操作

下面我们举一个最简单的函数例子，这个函数没有传入参数、没有返回值

它实现了一个简单的功能，就是输出Hello world!：

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

这个函数名为hello，我们可以按下面的方法进行调用（执行）：

function hello()print('Hello world!')endhello()

这行代码会输出Hello world!。

同时，在Lua中，函数也是一种变量类型，也就是说，hello实际上也是一个变量，里面存储的是一个函数，我们可以用下面的代码来理解：

function hello()print('Hello world!')enda = hello--把hello函数同时赋值给a变量a()hello()--a和hello变量指向同一个函数--所以执行结果和hello()相同

因为函数只是个变量，你甚至在一开始可以这样声明hello函数：

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

下面你需要做一件简单的事情：

• 新建一个函数变量biu，使其执行后会打印biubiubiu这个字符串

• 新建一个函数变量pong，使其与biu指向的函数相同

--请在此处补全代码--请使下面的调用可以正常打印出biubiubiubiu()pong()print("biu和pong相等吗？",biu==pong)

9.2 local变量

之前我们创建的变量，都是全局变量，这种变量在代码运行周期从头到尾，都不会被销毁，而且随处都可调用。

但是当我们代码量增加，很多时候大量新建全局变量会导致内存激增，我们需要一种可以临时使用、并且可以自动销毁释放内存资源的变量，要怎么解决呢？

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

参考下面的代码：

a = 123function add()local n = a+2print(n)endadd()print(n)

上面的代码中，n就是一个局部变量，它只在这个funcion中有效，并且函数运行完后会自动回收这部分的内存。

我们应该尽可能的使用局部变量，以方便lua虚拟机自动回收内存空间，同时减少资源占用提高运行速度。

下面请阅读以下代码，思考一下，正确的输出结果是什么：

str = 'abc'function connect()local s = str..'def'endprint(s,str)

9.3 函数参数

在前几章的使用中，我们知道函数是可以传入参数的，如print(123)

那么，我们如何编写可以传入参数的函数呢？可以按下面的模板来写

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

这里传入的参数，等价于在函数内部新建了一个local的变量，修改这些数据不会影响外部的数据（除了后面还没有讲到的table等类型）

举个例子，比如下面的函数，可以实现打印出两个传入值的和：

function add(a,b)print(a+b)endadd(1,2)--会输出3

这段代码其实等价于：

function add()local a = 1local b = 2print(a+b)endadd()

下面问题来了，请设计一个函数p，可以按下面的调用方式来打印出物体的密度：

--补全这个函数的代码，满足题目要求function p(a,b,c,m)print()end--一个长方体的长宽高分别为a、b、c（单位米）a = 1b = 2c = 3--这个物体重量为m（单位克）m = 230--下面打印出密度--注：密度计算公式 密度 = 质量 / 体积p(a,b,c,m)

9.4 函数返回值

在前面的代码中，我们实现了一个函数，输入变量a、b，函数会自动输出两个数值的和。

但是一般来说，我们的需求远远不止这些，我们可能需要一个如下功能的函数：

执行函数，输入两个值，获取这两个值的和

如果还是按上面几节的内容，我们只会输出这个值，并不能把这个值传递给其他的变量进行后续使用，如何解决这个需求呢？

我们可以使用函数的返回值来实现这个需求，结合上面的需求，我们可以用下面的代码实现：

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

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

同时，和输入值可以有多个一样，返回值也可以有多个

function add(a,b)return a+b,"ok"endall, result = add(1,2)--这里all的值就是3了--这里result的值就是string "ok"print(all,result)

下面问题来了，请设计一个函数p，可以按下面的调用方式来返回出物体的密度，返回值为number类型：

function p(a,b,c,m)--请补全代码end--一个长方体的长宽高分别为a、b、c（单位米）a = 1b = 2c = 3--这个物体重量为m（单位克）m = 230--下面返回密度值--注：密度计算公式 密度 = 质量 / 体积result = p(a,b,c,m)print(result)

9.5 判断三角形合法性2（自测题）

你需要使用前面几章的知识，来完成下面的题目

• 已知三个number类型的变量，分别代表三根木棒的长度

• 请判断，使用这三根木棒，是否可以组成一个三角形（两短边之和大于第三边）

• 请新建一个函数triangle，并可以用如下形式调用（如果可以组成，就返回true）：

function triangle(a,b,c)--请补全代码endresult = triangle(1,2,3)--传入值为三边长度，多改几个测试下print(result)

9.6 返回多个值（自测题）

你需要使用前面几章的知识，来完成下面的题目

• 已知2个number类型的变量，分别代表一个长方体的长和宽

• 请计算这个长方形的周长和面积

• 请新建一个函数rectangle，并可以用如下形式调用：

function rectangle(a,b)--补全代码endarea,len = rectangle(1,2)--结果：--面积area为2--周长len为6print(area,len)10table

10.table

10.1 认识数组

数组，使用一个变量名，存储一系列的值

很多语言中都有数组这个概念，在Lua中，我们可以使用table（表）来实现这个功能

在Lua中，table是一个一系列元素的集合，使用大括号进行表示，其中的元素之间以逗号分隔，类似下面的代码：

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

我们可以直接使用元素的下标，来访问、或者对该元素进行赋值操作。

在上面的table变量t中，第一个元素的下标是1，第二个是2，以此类推。

我们可以用变量名+中括号，中括号里加上下标，来访问或更改这个元素，如下面的例子：

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

以上就是table最简单的一个例子了，就是当作数组来用（注意，一般语言中的数组基本都为不可变长度，这里的table为可变长度）

下面你需要完成：

• 新建一个table，名为cards，存入1-10十个数字

• 将第3个元素与第7个元素交换

• 将第9个元素与第2个元素交换

• 增加第11个变量，值为23

--请补全代码cards =

10.2 简单table

上一节里，我们将table来表示数组，实际上，table中可以包括任意类型的数据

比如我们可以在table中放置number和string数据，类似下面的代码：

t = {"abc",223,",..a",123123}

我们甚至能在里面放function变量

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]()

这些table访问每个元素的方式仍然是直接用下标，并且也能用下标来进行修改

下面你需要完成：

• 新建一个table，名为funcList，并实现以下功能

• 调用funcList[1](a,b)，返回a和b的乘积

• 调用funcList[2](a,b)，返回a减b的差

• 调用funcList[3](a)，返回a的相反数（-a）

--请补全代码funcList = {}a,b = 1,2--提供两个数print("a,b值为",a,b)print("a和b的乘积：",funcList[1](a,b))print("a和b的差：",funcList[2](a,b))print("a和相反数：",funcList[3](a))

10.3 table下标

在前两节，我们的table都只是一些简单的List（列表），每个元素的下标都是自动从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 = {}--空的tablet[101] = 10print(t[101])--输出10

下面你需要：

• 新建一个变量t，并按下面的格式声明

• 下标为1的元素，值为123（number）

• 下标为13的元素，值为"abc"（string）

• 下标为666的元素，值为"666"（string）

--请补全代码t = {}print("下标为1的元素：",t[1],type(t[1]))print("下标为13的元素：",t[13],type(t[13]))print("下标为666的元素：",t[666],type(t[666]))

10.4 下标进阶

在上一节，我们学习了如何自定义下标，其实在Lua中，下标也可以是字符串，如下面的例子

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

--当第二种方式有歧义时，应该用第一种方式

可见，在使用string作为下标时，table的灵活性提升了一个数量级。

string作为下标时，也可以动态赋值：

t = {} -- 空tablet["new"] = "新的值"print(t.new)--输出 新的值

下面你需要完成：

• 新建table变量t

• 下标为apple的元素，值为123（number）

• 下标为banana的元素，值为"abc"（string）

• 下标为1@1的元素，值为"666"（string）

--请补全代码t = {}print("下标为apple的元素：",t["apple"],type(t["apple"]))print("下标为banana的元素：",t["banana"],type(t["banana"]))print("下标为1@1的元素：",t["1@1"],type(t["1@1"]))

10.5 table小测验

下面的代码，将会打印什么？

t = {apple = {price = 7.52,weight = 2.1,},banana = {price = 8.31,weight = 1.4,year = '2018'},year = '2019'}print(t.price,t.apple.price,t.banana.weight,t.year)

10.6 table小测验2

下面的代码，将会打印什么？

t = {{price = 7.52,weight = 2.1,},{price = 8.31,weight = 1.4,year = '2018'},year = '2019'}print(t["price"],t[1].price,t[2].weight,t["year"])

10.7 Lua全局变量与table

在前面我们知道了，在table中，可以直接用table名[下标]或table名.string下标来访问元素

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

我们可以用下面的例子来示范：

n = 123--新建变量print(n)--输出123print(_G.n)--输出123_G.abc = 1--相当于新建全局变量print(abc)--输出1_G["def"] = 23--相当于新建全局变量print(def)--输出23--甚至你可以像下面这样_G.print("hello")_G["print"]("world")现在，你明白为什么说万物基于table了吧？你需要完成下面的任务：已知有一个全局变量，名为@#$请新建一个变量result将@#$变量里的值赋值给result_G["@#$"] = 123result = --请补全代码print("result值为",result)

10.8 table小测试3

请新建一个名为t的table，满足以下要求

• t[10]可获得number类型数据100

• t.num可获得number类型数据12

• t.abc[3]可获得string类型数据abcd

• t.a.b.c可获得number类型数据789

--请补全代码t = {}print("t[10]可获得number类型数据100:",t[10],type(t[10]))print("t.num可获得number类型数据12:",t.num,type(t.num))print("t.abc[3]可获得string类型数据abcd:",t.abc[3],type(t.abc[3]))print("t.a.b.c可获得number类型数据789:",t.a.b.c,type(t.a.b.c))10.9 table.concat

table.concat (table [, sep [, i [, j ] ] ])

将元素是string或者number类型的table，每个元素连接起来变成字符串并返回。

可选参数sep，表示连接间隔符，默认为空。

i和j表示元素起始和结束的下标。

下面是例子：

local a = {1, 3, 5, "hello" }print(table.concat(a))print(table.concat(a, "|"))-->打印的结果：--135hello--1|3|5|hello

请完成下面的任务：

• 已知table变量t，

• 将t中的结果全部连起来

• 间隔符使用,

• 并使用print打印出来

t = {"a","b","c","d"}print("连接结果：")--补全代码

10.10 table删减

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] = 8table.insert(a, 1, 3)   --在表索引为1处插入3print(a[1], a[2], a[3])table.insert(a, 10)    --在表的最后插入10print(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

请完成下面的任务：

• 已知table变量t，

• 去除t中的第一个元素

• 然后这时，在t的第三个元素前，加上一个number变量，值为810

t = {1,2,3,4,5,6,7,8,9}--补全代码print("第一个元素应为2：",t[1])print("第三个元素应为810：",t[3])

11.循环

11.1 while循环

在实际功能实现中，经常会遇到需要循环运行的代码，比如从1到100填充table数据，我们可以直接用循环语句来实现

我们首先来学习while这个循环语法，整体的格式如下：

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

下面举一个例子，我们计算从1加到100的结果：

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

上面的代码，就是当num≤100时，result不断地加num，并且num每次循环后自己加1

理解了上面的代码，我们来完成下面一个简单的任务吧：

• 已知两个number类型的变量min和max

• 请计算从min与max之间，所有3的倍数的和

• 打印出结果

min,max = 114,514 --这个结果应为42009result = 0--结果存放到这个变量while 请完善 do--补全代码endprint("结果：",result)

11.2 for循环

for循环在某些程度上，和while循环很相似，但是for循环可以更加简洁地表达中间累积的量

我们首先来学习for这个循环语法，整体的格式如下：

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

其中，步长可以省略，默认为1

临时变量名可以直接在代码区域使用（但不可更改），每次循环会自动加步长值，并且在到达结束值后停止循环

下面举一个例子，我们计算从1加到100的结果：

local result = 0for i=1,100 doresult = result + iendprint(result)

上面的代码，就是当i≤100时，result不断地加i，并且i每次循环后增加1

理解了上面的代码，我们来完成下面一个简单的任务吧：

• 已知两个number类型的变量min和max

• 请计算从min与max之间，所有7的倍数的和

• 打印出结果

min,max = 114,514 --这个结果应为17955result = 0--结果存放到这个变量for --补全代码print("结果：",result)

11.3 中断循环

前面我们学习了循环语句，有些时候循环运行到一半，我们不想再继续运行了，怎么办呢？

我们可以在一个循环体中使用break，来立即结束本次循环，继续运行下面的代码

比如像下面这样，计算1-100相加途中，小于100的最大的和：

result = 0for i=1,100 doresult = result + iif result > 100 thenresult = result - ibreakendendprint(result)

可以看见，当发现和大于100后，代码立即把result的值还原到了加上当前数字之前的状态，并且调用break语句，立即退出了本次循环

在while中，我们也可以使用break:

result = 0c = 1while true doresult = result + cif result > 100 thenresult = result - c  breakendc = c + 1endprint(result)

我们在这里直接使用了死循环（因为while的继续运行判断依据始终为true），整体逻辑也和之前for的代码一致，当发现和大于100后，代码立即把result的值还原到了加上当前数字之前的状态，并且调用break语句，立即退出了本次循环

现在你需要完成一项任务：

• 请求出小于变量max的13的倍数的最大值（max大于0）

• 并将结果打印出来

• 本题理论上不用循环就能实现，但是为了练习一下技巧，请用for循环来实现

max = 810 --结果应为806result = 0for --请补全代码print(result)

11.4 循环测试题1（自测题）

前面我们学习了循环语句，我们需要完成下面的任务

我们知道，print函数可以打印一行完整的输出

那么，已知变量a，请打印出下面的结果：

（a为大于0的整数，且需要输出a行数据，数据从1开始，每行与上一行的差为2）

13579

（上面例子为当a为5的情况）

做题区域：

a = 10--需要用print输出要求的结果print("输出结果：")for --请补全代码

11.5 循环测试题2（自测题）

我们需要完成下面的任务

那么，已知变量a，请打印出下面的结果：

（a为大于0的整数，且需要输出a行数据，第一行为一个，后面每行多一个）

***************

（上面例子为当a为5的情况）

做题区域：

a = 10--需要用print输出要求的结果print("输出结果：")for --请补全代码

11.6 循环测试题3（自测题）

我们需要完成下面的任务

那么，已知变量a，请打印出下面的结果：

（a为大于0的整数，且需要输出a行数据，按图示规律输出）

112123123412345123456123456712345678123456789123456789101234567891011

（上面例子为当a为11的情况）

做题区域：

a = 20--需要用print输出要求的结果print("输出结果：")for --请补全代码

11.7 循环测试题4（自测题）

• 有一只猴子，第一天摘了若干个桃子 ，当即吃了一半，但还觉得不过瘾 ，就又多吃了一个。

• 第2天早上又将剩下的桃子吃掉一半，还是觉得不过瘾，就又多吃了两个。

• 以后每天早上都吃了前一天剩下的一半加天数个（例如，第5天吃了前一天剩下的一半加5个）。

• 到第n天早上再想吃的时候，就只剩下一个桃子了。

• 那么，已知变量a为最后一天的天数，请打印出第一天的桃子数。

• 如：a为5时，输出114

做题区域：

a = 6--需要用print输出要求的结果print("输出结果：")for --请补全代码

12.详解string库

12.1 string.sub

接下来几节会讲解string库的各种接口

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 Lello LuaLua值得注意的是，我们可以使用冒号来简化语法，像下面这样：s = "12345"s1 = string.sub(s, 4, 7)s2 = s:sub(4, 7)--两种写法是等价关系print(s1,s2)

请完成下面的任务：

• 已知字符串变量s，请分别打印出（每种一行）：

• s从第4个字符开始，到最后的值

• s从第1个字符开始，到倒数第3个字符的值

• s从倒数第5个字符开始，到倒数第2个字符的值

s = "1919810"--补全代码print()print()print()

12.2 string.rep

string.rep(s, n)

返回字符串 s 的 n 次拷贝。

示例代码：

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

请完成下面的任务：

打印一行数据，数据内容为810个114514

--补全代码print()

12.3 string.len

string.len(s)

接收一个字符串，返回它的长度。

示例代码：

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

请完成下面的任务：

• 新建一个变量s，使数据内容为810个114514

• 并打印出字符串s的长度

s = --补全代码print()

12.4 大小写转换

string.lower(s)

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

string.upper(s)

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

示例代码：

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

请完成下面的任务：

已知一个变量s，打印出全是大写字母的s字符串

s = "asd8938KJjsidiajdl;(()k)"print --补全代码

12.5 string.format

string.format(formatstring, ...)

按照格式化参数formatstring，返回后面...内容的格式化版本。

编写格式化字符串的规则与标准 c 语言中 printf 函数的规则基本相同：

它由常规文本和指示组成，这些指示控制了每个参数应放到格式化结果的什么位置，及如何放入它们。

一个指示由字符%加上一个字母组成，这些字母指定了如何格式化参数，例如d用于十进制数、x用于十六进制数、o用于八进制数、f用于浮点数、s用于字符串等。

示例代码：

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

请完成下面的任务：

• 已知一个变量n，为number类型整数

• 打印出n:连上n值的字符串

n = 810print --补全代码

12.6 string的本质

这一节我们来讲解字符串的本质

字符串，是用来存储一串字符的，但是它的本质就是一串数字。如何用一串数字来代表一串字符呢？

在计算机中，每一个符号都对应着一个数字，但是在讲解这个知识之前，我们了解一下补充知识：

在

大多数编程语言中，我们使用0x开头来表示这个数字是16进制的。比如10等价于0x0a256等价于0xff

接下来，你需要了解，每一个符号都对应着一个数字，比如：

0对应着0x30、1对应着0x31 a对应着0x61、b对应着0x62 A对应着0x41、B对应着0x42

上面的编码规则，我们称之为ascii码，具体想了解可以打开下面的网址查看：http://ascii.911cha.com/

当然，1字节最大为0xff，即256，只能存下一部分符号，大部分的中文按某些编码，一个中文占用2或3个字节

计算机如何解析这些数据，我们不需要了解，当你知道了上面的知识后，你应该可以理解下面的描述：

字符串"apple"实际上的内容就是下面的一串数字：0x61,0x70,0x70,0x6c,0x65

同时，lua的字符串中可以保存任何数值，即使是0x00这种不代表任何含义的数，也可以保存

补充：在其他语言中（如C），0x00代表字符串结束，但是在lua中并不是这样。lua的字符串每字节可以存储任意的一字节数据。

比如下面的描述：

有一串lua字符串中的数据为：0x01,0x02,0x30,0x00,0x44实际人能看到的（不可见字符用�代替）：��0�D当然，你不能说你看不见的数据就不存在，他们都完好无损地在这个字符串中

下面你需要思考一个问题：一串字符串数据如下，它的实际内容是什么（指人能看见的字符串内容，如abcd）？

0x62,0x61,0x6e,0x61,0x6e,0x61

12.7 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

请完成下面的任务：

• 已知一个字符串的每个字符在数组t中按顺序排列

• 请根据t的值，打印出字符串内容（一行数据）

• 注：这个字符串存储的不一定是可见的字符

t = {0x79,0x6F,0x75,0x20,0x61,0x72,0x65,0x20,0x72,0x69,0x67,0x68,0x74}print("真正的字符串内容：")--补全代码

12.8 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

请完成下面的任务：

• 已知字符串s

• 请把s中代表的数据，全部相加，并打印出来

s = string.char(1,2,3,4,5,6,7,8,9)print("s内数据的和是：")--补全代码

12.9 string.find

string.find(s, p [, init [, plain] ])

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

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

第四个参数plain默认为false，当其为true时，只会把p看成一个字符串对待。

可能你会奇怪，第四个参数有什么存在的必要吗？p不是本来就应该是个字符串吗？ 实际上，lua中的匹配默认意义是正则匹配，同时，这里的正则与其它语言也有些许不同。

由于篇幅有限，本节和下面的几节涉及匹配内容时，均不会考虑正则的使用方法，Lua正则教程将会在最后几节单独详细地列出来。

第四个参数为true时，便不会使用正则功能。

示例代码：

--只会匹配到第一个print(string.find("abc abc", "ab"))-- 从索引为2的位置开始匹配字符串：abprint(string.find("abc abc", "ab", 2))-- 从索引为5的位置开始匹配字符串：abprint(string.find("abc abc", "ab", -3))-->输出--1  2--5  6--5  6

请完成下面的任务：

• 已知字符串s，里面有很多相同的字符串

• 请找出字符串s中，所有字符串awsl的位置

• 使用print打印结果，结果一行一个

• 如字符串12awslawslaw，输出3和7

s = "12awsaslwlaawsllslllswasllalssawwlawslaw"print("两个awsl的位置分别是：")--补全代码

12.10 string.gsub

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

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

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

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

特别提示：这个函数的目标字符串s，也是支持正则的

下面是例子：

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

同样的，我们也可以使用冒号来简化语法，像下面这样：

s = "12345"r = s:gsub("2","b")print(r)

请完成下面的任务：

• 已知字符串变量s，请分别打印出（每种一行）：

• 把字符串s中，前5个a，替换为b

• 把字符串s中，前3个c，替换为xxx

• 把结果打印出来，一行数据

s = "asdicagydausckfugdaflgscdabgsdbahhacbshbsd"print("s变换前的值：",s)--补全代码

13.跨文件调用

在编写代码时，随着逻辑逐渐复杂，我们的代码量也会变大。虽然有函数可以把一部分代码逻辑封装起来，但是所有代码都放到一个文件里，显然也不是个好办法。

所以我们需要将一些代码放到不同文件中，通过文件来区分这些代码的功能。

比如我们有下面这个函数：

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

我们新建一个文件叫tools.lua，把这个函数放进去，现在，整个文件如下面这样：

tools.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 tend--手动返回一个table，包含了上面的函数return {getNumberList = getNumberList,}

现在，我们封装的这个函数就能在其他文件里被调用了，具体代码如下：

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

当调用了require接口后，Lua虚拟机会自动加载你调用的文件，执行文件的内容，然后返回你文件里return的结果。

为了更好地理解这段话，我们可以看下面两个文件，其中run.lua是被运行的那个入口文件

test.lua

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

run.lua

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

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