lua脚本基础语法

Lua基础语法

1.          注册C语言函数

lua语言的工作原理实例：

 

int foo(lua_State *L)//在C语言中定义函数foo

{

 int  n = lua_tonumber(L, 1);//计算一个数值加1

 lua_pushnumber(L, n + 1);

 return 1;

}

lua_State *L =stack->getLuaState()；//在lua解释器中注册这个函数

lua_register(L, "foo",foo);第一个foo是lua中使用的函数

                       第二个foo是上边的定义的的函数名---相当于一个指针，lua中的                  foo自动的指向这个foo

 

 

//local i = foo (99)              

 //print("lua bind: " .. tostring(i))

print(foo(99))        //在lua脚本中我就可以调用

## 如果lua中没有这个函数，就调用c++中的---先看lua中有没有

就可以证明lua是怎样工作的

 

 

2.

Lua是一种动态类型的语言。在语言中没有类型定义的语法，每个值都带有其自身的类型信息。在Lua中有8种基本类型，分别是：nil（空）类型

•     boolean（布尔）类型

•     number（数字）类型

•     string（字符串）类型

•     userdata（自定义类型）

•     function（函数）类型

•     thread（线程）类型

•     table（表）类型

 

 

3.

•     nil（空）nil是一种类型，它只有一个值nil。一个全局变量在第一次赋值前的默认值就是nil，将nil赋予一个全局变量等同于删除它。Lua将nil用于表示一种“无效值”的情况，即没有任何有效值得情况。

•     boolean（布尔）boolean类型有两个可选值：false和true。一定需要注意的是，在Lua中只有false和nil是“假”的，而除此之外的都是“真”，这和其它语言有所区别的。

•     number（数字）number类型用于表示双精度浮点数。Lua没有整数类型，而Lua中的数字可以表示任何32位整数。

•     string（字符串）Lua中的字符串通常表示“一个字符序列”。Lua完全采用8位编码。Lua的字符串是不可变的值。不能像C语言中那样直接修改字符串的某个字符，而是应该根据修改要求来创建一个新的字符串。Lua的字符串和其它对象都是自动内存管理机制所管理的对象，不需要担心字符串的内存分配和释放。在Lua中，字符串可以高效的处理长字符串。当字符串是多行存在时，可以使用“[[]]”符号来界定一个多行字符串

 

 

4.

•     table（表）table类型实现了关联数组，关联数组是一种具有特殊索引方式的数组；不仅可以通过整数来索引它，还可以使用字符串或其它类型的值（除了nil）来索引它。

•     此外，table没有固定的大小，可以动态得添加任意数量的元素到一个table中。

•     在Lua中，table既不是“值”，也不是“变量”，而是对象。

•     可以将table想象成一种动态分配的对象，程序中仅仅有一个队它们的引用（指针）。

•     table的创建是通过“构造表达式”完成的，最简单的构造表达式就是{}。

•     table永远是匿名的，一个引用table的变量与table自身之间没有固定的关联性，例如以下代码：

•     locala = {} -- 创建一个table，并将它的引用存储在a

•     a["x"]= 10      //表里边有一个x。a的x是10

•     localb = a       // b与a引用同一个table

•     print(b["x"])   //输出的是b里边的x----10

•     b["x"]= 20

•     print(a["x"])   //20

•     b =nil     // 现在只有a还在引用table

•     -- 错误：print(b["x"])

•     print(a["x"])   //20

•     a =nil -- 现在不存在对table的引用

5.

•     当对一个table的引用为0时，Lua的垃圾收集器最终会删除该table，并释放它所占用的内存空间。

•     当table的某个元素没有初始化时，它的内容就是nil；

•     另外还可以像全局变量一样，将nil赋予table的某个元素来删除该元素。

•     在Lua中，对于a["name"]这种形式的写法提供了一种更简便的写法，可以直接输入a.name。

•     先看看以下代码：

•     locala = {}

•     a["name"]= 10

•     print(a.name)-- 等价于print(a["name"])

•     这种写法本身提供了简便性，但是有的时候，却给程序员带来了困惑；我就常常会把a.x和a[x]搞错，

•     a.x表示a["x"]，表示以字符串”x”来索引table；

•     而a[x]是以变量x的值来索引table。

•     通过下面这段代码，来看看它们之间的区别：

•     locala = {}

•     x="y”

•     a[x] =10

•     print(a[x])  -->10 相当于a["y"]

•     print(a.x)   -->nil 相当于a["x"]

•     print(a.y)   -->10 相当于a["y"]

 

 

6. Lua表达式

•     算术操作符

–     Lua支持常规的算术操作符有：”+”（加法）,”-”（减法）,”*”（乘法）,”/”（除法）,”^”（指数）,”%”（取模）,一元的”-”（负号）。所有的这些操作符都用于实数。例如：x^0.5将计算x的平方根，x^3将计算x的3次方。

•     关系操作符

–     Lua提供的关系操作符有：”<”,”>”,”<=”,”>=”,”==”,”~=”；不等于

–     所有这些操作符的运算结果都是true或false。

–     操作符==用于相等性测试，操作符~=用于不等性测试。这两个操作符可以应用于任意两个值。如果两个值具有不同的类型，Lua就认为它们是不相等的；特别需要说明的是，nil只与其自身相等。对于table、userdata和函数，Lua是作引用比较的。也就是说，只有当它们引用同一个对象时，才认为它们相等。

•     逻辑操作符

–     Lua提供的逻辑操作符有and、or和not。与条件控制语句一样，所有的逻辑操作符将false和nil视为假，而将其它的任何东西视为真。

–     对于操作符and来说，如果它的第一个操作数为假，就返回第一个操作数；不然就返回第二个操作数。对于操作符or来说，如果它的第一个操作数为真，就返回第一个操作数；不然就返回第二个操作数。这里和C++等语言是存在区别的，Lua的逻辑操作符并不是简单的返回true或false，而是返回操作数的值。例如以下代码：

–     print(4 and 5)               -->5

–     print(nil and 13)          -->nil

–     print(false and 13)     -->false

–     print(4 or 5)               -->4

–     print(false or 5)          -->5

–     and和or都使用“短路求值”，也就是说，它们只会在需要时才去评估第二个操作数。

•     字符串连接

–     要在Lua中连接 两个字符串，可以使用操作符“..”（两个点）。如果其任意一个操作数是数字的话，Lua会将这个数字转换成一个字符串。在Lua中，字符串是不可变的值，连接操作符只会创建一个新字符串，而不会对其原操作数进行任何修改。

 

 

7.

•     table构造式构造式是用于创建和初始化table的表达式。

•     最简单的构造式就是一个空构造式{}，用于创建一个空table。

•     构造式还可以用于初始化数组，数组的下标从1开始。

•     例如：

•     localtbDays ={"Sunday", "Monday", "Tuesday","Wednesday", "Thursday", "Friday","Saturday"}

•     print(tbDays[1])          -->Sunday

•     print(tbDays[2])          -->Monday

•     print(tbDays[3])          -->Tuesday

•     print(tbDays[4])          -->Wednesday

•     print(tbDays[5])          -->Thursday

•     print(tbDays[6])          -->Friday

•     print(tbDays[7])          -->Saturday

•     Lua还提供了一种特殊的语法用于初始化table：

•     localtb1 = {x=10, y=20}

•     print(tb1.x)          -->10

•     print(tb1["x"])          -->10

•     除此之外，Lua还提供了一种更通用的格式，这种格式允许在方括号之间，显式地用一个表达式来初始化索引值，例如：

•     localtb1 = {["+"] = "add", ["-"] = "sub",["*"] = "mul", ["/"] = "div"}

•     print(tb1["+"])

•     比如localtb1 = {x=10, y=20}这种构造方式，其实是和

•     local tb1 = {["x"] = 10,["y"] = 20}是等价的。在实际编程中，这两种构造式，都可以替换的用。

 

8.

•     在Lua 5.1中，长度操作符“#”用于返回一个数组或线性表的最后一个索引值。在实际项目中，

•     我们经常使用该操作符来获取数组或线性表的长度。但是使用该操作符是存在陷阱的，比如下面一段代码：

•     locala = {}

•     a[1000]= 1

•     print(#a)

•     这该输出多少呢？在Lua中，对于所有未初始化的元素的索引结果都是nil。Lua将nil作为界定数组结尾的标志。当一个数组有“空隙”时，即中间含有nil时，长度操作符会认为这些nil元素就是结尾标记。因为a[1] = nil，所以，对于上述代码的输出应该是0。所以，在处理table的时候，需要考虑这个问题。那么对于含有nil的table，如何获取它的长度呢？我们可以使用table.maxn，它将返回一个table的最大正索引数，如下所示：local a = {}

•     a[1000]= 1

•     print(table.maxn(a))-->1000

 

9.

 

•     function（函数）

–     在Lua中，函数被当做值来对待，这表示函数可以存储在变量中，可以通过参数传递给其它函数，还可以作为其它函数的返回值。

–     Lua既可以调用自身Lua语言编写的函数，又可以调用以C语言编写的函数。

–     Lua所有的标准库都是用C语言写的。

•     userdata（自定义类型）

–     userdata用于表示一种由应用程序或C语言库所创建的新类型。由于userdata类型可以将任意的C语言数据存储到Lua变量中。在Lua中，这种类型没有太多的预定义操作，只能进行赋值和相等性测试。

•     thread主要用于“线程”。

10.

•     赋值

–    赋值的基本含义是修改一个变量或一个table中字段的值，这个和其它语言没有多少区别，但是对于Lua，有一个特性，它允许“多重赋值”，也就是一下子将多个值赋予多个变量，例如以下代码

–    localx1, x2 = 2, 4

–    print(x1)     -->2

–    print(x2)     -->4

•     在多重赋值中，

–    Lua先对等号右边的所有元素求值，然后才执行赋值，例如以下用法，可以非常简便的交换两个元素的值：

–    localx1, x2 = 2, 4

–    x1, x2= x2, x1

–    print(x1)     -->4

–    print(x2)     -->2

–    Lua总是会将等号右边值得个数调整到与左边变量的个数相一致，规则是：如果值得个数少于变量的个数，那么多余的变量会被赋为nil；

–     如果值得个数更多的话，那么多余的值会被忽略掉。

11：

•     局部变量与块

•     相对于全局变量，Lua同时也提供了局部变量。

•     通过local语句来创建局部变量：

•     i = 10     -->全局变量

•     local i = 10     -->局部变量

•     在Lua中，局部变量也是有作用范围的，也就是说，出了局部变量的作用范围，局部变量就会失去作用，这个和C++等高级语言是一样的道理。

•     我们在编程的过程中，也可以使用do…end来显示的声明一个块，例如以下代码：

•     do   

•      local a1 = 10   

•      local a2 = 10

•     end          -->a1和a2的作用域到此结束

•     至于使用局部变量和全局变量，关系到编程风格和实际需要，这里不做多说。

 

12

•     Lua提供了用于条件执行的

•     if，

•     循环的while、repeat和for。

•     所有的控制结构都有一个显式的终止符：

•     if、for和while以end作为结尾，

•     repeat以until作为结尾。

•     特别注意，在Lua中是不支持switch结构的

 

13：

•     While

–    Lua中的while与其它语言是一样的，示例代码如下：

local a = 10

while a > 0do   

    a = a - 1     -- Do something else

end

•     Repeat

–     repeat就好比C++中的do…while结构，循环体至少会执行一次。repeat-until语句重复执行其循环体直到条件为真时结束。

14：

•     数字型for的语法如下：

for var = exp1,exp2, exp3 do   

 -- Do something

End

•     var从exp1变化到exp2，每次变化都以exp3作为步长进行递增，并执行一次do…end之间的代码。第三个表达式exp3是可选的，若不指定的话，Lua会将步长默认为1。

•     例如以下代码：

for var = 1, 10do    

  print(var)

end

for var = 10, 1,-1 do    

  print(var)

End

在使用for时，需要注意以下两点：

1.for的exp1,exp2和exp3，这三个表达式是在循环开始前一次性求值得；

并不会每次循环都进行求值；

2.控制变量var会被自动的声明为for语句的局部变量，并且仅在循环体内可见。

 

 

15：

•     泛型for泛型for循环通过一个迭代器函数来遍历所有值。

•     在Lua的基础库中提供了ipairs，这是一个用于遍历数组的迭代器函数。

•     从外观上看泛型for比较简单，但其实它是非常强大的。通过不同的迭代器，几乎可以遍历所有的东西。

•     标准库提供了几种迭代器，包括用于迭代文件中每行的io.lines、

•     迭代table元素的pairs、

•     迭代数组元素的ipairs和迭代字符串中单词的string.gmatch等。

16：

•     break与return break和return语句用于跳出当前的块。

•     这里的break、return和C++等语言是一样的。break语句用于结束一个循环，

•     return语句用于从一个函数中返回结果

17：函数：

 

•     Lua中的函数和C++中的函数的含义是一致的，Lua中的函数格式如下：

•     functionMyFunc(param)   

•      -- Do something

•     end

•     在调用函数时，也需要将对应的参数放在一对圆括号中，即使调用函数时没有参数，也必须写出一对空括号。

•     对于这个规则只有一种特殊的例外情况：一个函数若只有一个参数，并且此参数是一个字符串或table构造式，那么圆括号便可以省略掉。

•     看以下代码：

•     print"Hello World"          -->print("Hello World")等价

•     print[[a multi-line          message]]       

•       -->print([[a multi-line                              -->               message]]) 等价

•     -- f是一个函数

•     f{x=10,y=20}               -->f({x=10, y=20})等价

•     上面代码的一些简便写法，如果不熟悉的话，在阅读别人的代码时，就会是一头雾水

18：

•     一个函数定义具有一个名称、一系列的参数和一个函数体。

•     函数定义时，所定义的参数的使用方式与局部变量非常相似，它们是由调用函数时的“实际参数”初始化的。

•     调用函数时提供的实参数量可以与形参数量不同。

•     Lua会自动调整实参的数量，以匹配参数表的要求，若“实参多余形参，则舍弃多余的实参；若实参不足，则多余的形参初始化为nil”。

•     这个与接下来要介绍的多重返回值非常相似。

•     多重返回值这个应该是Lua的一个特征吧。允许函数返回多个结果，只需要在return关键字后列出所有的返回值即可。以下根据带来来说明情况：

function foo0()

 end                                -- 无返回值

function foo1()

  return “a”

 end            -- 返回一个结果

function foo2()

return"a", "b"

end     -- 返回两个结果

 

19：

•     多重返回值这个应该是Lua的一个特征吧。允许函数返回多个结果，只需要在return关键字后列出所有的返回值即可。以下根据带来来说明情况：

function foo0()

 end                                -- 无返回值

function foo1()

  return “a”

 end            -- 返回一个结果

function foo2()

return"a", "b"

end     -- 返回两个结果

 

•     -- 在多重赋值时，如果一个函数调用是最后，或仅有的一个表达式，-- 那么Lua会保留其尽可能多的返回值，用于匹配赋值变量

•     x, y =foo2()               -- x ="a", y = "b”

•     x =foo2()                    -- x ="a", "b"被丢弃

•     x, y, z= 10, foo2()     -- x = 10, y ="a", z = "b"

 

•     -- 如果一个函数没有返回值或者没有足够多的返回值，那么Lua会用-- nil来补充缺失的值

•     x, y =foo0()               -- x = nil, y = nil

•     x, y =foo1()               -- x ="a", y = nil

•     x, y,z = foo2()          -- x = "a",y = "b", z = nil

 

 

 

20：

•     -- table构造式可以完整的接收一个函数调用的所有结果，即不会有任何数量-- 方面的调整

•     localt = {foo0()}          -- t = {}(一个空的table)

•     localt = {foo1()}          -- t ={"a"}

•     localt = {foo2()}          -- t ={"a", "b"}

•     -- 但是，对于上述的行为，只有当一个函数调用作为最后一个元素时才会发生，-- 而在其他位置上的函数调用总是只产生一个结果值

•     localt = {foo0(), foo2(), 4}          -- t[1]= nil, t[2] = "a", t[3] = 4

•     -- 我们也可以在一个函数中，使用return返回另一个函数

functionMyFunc()          -- 返回a    

return foo1()          -- 注：这里是return foo1()，而不是return (foo1())

end

-- return foo1()和return (foo1())是两个完全不同的意思–

•     将一个函数调用放入一对圆括号中，从而迫使它只返回一个结果

•     print((foo0()))          -- nil

•     print((foo1()))          -- a

•     print((foo2()))          -- a

•     在C语言中，函数可以接受不同数量的实参，Lua中的函数也可以接受不同数量的实参，例如以下代码：

•     -- 打印所有的参数

•     functionVarArguments(...)    

•     for i,v in ipairs{...} do      

•        print(v)    

•     end

•     end

21

•     在Lua中，函数与其它传统类型的值具有相同的权利。

•     函数可以存储到变量或table中，也可以作为实参传递给其它函数，还可以作为其它函数的返回值。

•     在Lua中有一个容易混淆的概念是，函数与所有其它值一样都是匿名的，即它们都没有名称。

•     当讨论一个函数名时，实际上是在讨论一个持有某函数的变量，例如以下代码：

•     -- 我们经常这样定义函数

•     functionfoo(x) return 2 * x end

•     -- 实际上

•     -- 上述代码只是下面代码的一种简化书写形式

•     foo =function (x) return 2 * x end

•     实际上，一个函数定义实际就是一条语句（更准确地说是一条赋值语句），这条语句创建了一种类型为“函数”的值，并将这个值赋予一个变量。由于函数在Lua中就是一个普通的值，所以不仅可以将其存储在全局变量中，还可以存储在局部变量甚至table的字段中。

22：

•     若将一个函数写在另一个函数之内，那么这个位于内部的函数便可以访问外部函数中的局部变量，这个特征叫做“词法域”。我们来看看下面一段有趣的代码：

•     functionnewCounter()   

•      local i = 0    

•     returnfunction () -- 匿名函数        

•      i = i + 1        

•      return i    

•     End

•     End

•     c1 =newCounter()

•     print(c1())     -->输出什么？

•     print(c1())     -->又输出什么？

 

 

 

23：闭包

•     functionnewCounter()    

•     locali = 0    

•     returnfunction () -- 匿名函数         

•     i = i+ 1         

•     returni    

•     End

•     End

•     c1 =newCounter()print(c1()) print(c1())根据刚刚说的闭包的概念，结合上面的代码，来说说这个概念。

•     闭包=函数+引用环境。

•     上述代码中的newCounter函数返回了一个函数，而这个返回的匿名函数就是闭包的组成部分中的函数；

•     引用环境就是变量i所在的环境。

•     实际上，闭包只是在形式和表现上像函数，但实际上不是函数，我们都知道，函数就是一些可执行语句的组合体，这些代码语句在函数被定义后就确定了，并不会再执行时发生变化，所以函数只有一个实例。

•     而闭包在运行时可以有多个实例，不同的引用环境和相同的函数组合可以产生不同的实例，就好比相同的类代码，可以创建不同的类实例一样。

•     子函数可以使用父函数中的局部变量，这种行为就叫做闭包！

 

 

 

•     首先，在Lua中，创建一个函数，就像定义一个普通类型值一样的，

•     Lua中的函数就是所谓的“第一类值”，它可以被存放在变量或数据结构中，可以当做参数传递给另一个函数，可以是一个函数的返回值，还可以在运行期间被创建。Lua中的函数就是这样的一种“东西”，它很灵活。

•     它可以理解为不是在局部作用范围内定义的一个变量，同时，它又不是一个全局变量，由于有了这样的一种变量的存在，就成全了Lua中的闭包。

•     这种变量主要应用在嵌套函数和匿名函数里。

•     我们都知道，可以在Lua的函数中再定义函数，也就是内嵌函数，内嵌函数可以访问外部函数已经创建的所有局部变量，而这些变量就被称为该内嵌函数的upvalue，upvalue实际指的是变量而不是值，这些变量可以在内部函数之间共享，比如以下代码：

•     functionFun1()   

•      local iVal = 10          -- upvalue   

•      function InnerFunc1()     -- 内嵌函数        

•      print(iVal)          --   

•      end   

•      function InnerFunc2()     -- 内嵌函数        

•      iVal = iVal + 10   

•      end   

•      return InnerFunc1, InnerFunc2

•     end-- 将函数赋值给变量，此时变量a绑定了函数InnerFunc1, b绑定了函数InnerFunc2

•     locala, b = Fun1()

•     -- 调用a

•     a()          -->10

•     -- 调用b

•     b()          -->在b函数中修改了upvalue iVal

•     -- 调用a打印修改后的upvalue

•     a()          -->20上述这段简单的代码，就验证了在内嵌函数中是共享upvalue的，就好比C++类中的成员函数可以访问和修改成员变量一样

 

 

 

•     可以看到闭包是数据和行为的结合体，就好比C++中的类，这样就使得闭包具有较好的抽象能力，在某些场合下，我们需要记住某次调用完成以后数据的状态，

•     就好比C++中的static类型的变量，每次调用完成以后，static类型的变量并不会被清除

 

 

 

24：

•     可以看到闭包是数据和行为的结合体，就好比C++中的类，这样就使得闭包具有较好的抽象能力，在某些场合下，我们需要记住某次调用完成以后数据的状态，

•     就好比C++中的static类型的变量，每次调用完成以后，static类型的变量并不会被清除

•     通常，Lua中的每个值都有一套预定义的操作集合，比如数字是可以相加的，字符串是可以连接的，但是对于两个table类型，则不能直接进行“+”操作。

•     这需要我们进行一些操作。

•     在Lua中有一个元表，也就是上面说的metatable，我们可以通过元表来修改一个值得行为，使其在面对一个非预定义的操作时执行一个指定的操作。

•     比如，现在有两个table类型的变量a和b，我们可以通过metatable定义如何计算表达式a+b，具体的在Lua中是按照以下步骤进行的：

•     1. 先判断a和b两者之一是否有元表；

•     2. 检查该元表中是否有一个叫__add的字段；

•     3. 如果找到了该字段，就调用该字段对应的值，这个值对应的是一个metamethod；（Lua中函数是可以放在一个字段中的）

•     4. 调用__add对应的metamethod计算a和b的值。

 

 

24：数组：

 

•     在Lua中通过整数下标访问表中的元素即可简单的实现数组。并且数组不必事先指定大小，大小可以随需要动态的增长。

•     a = {}

•     for i= 1,100 do  

•      a[i] = 0

•     End

•     print("Thelength of array 'a' is " .. #a)

•      squares = {1, 4, 9, 16, 25}

•     print("Thelength of array 'a' is " .. #squares)

•     在Lua中习惯上数组的下表从1开始，Lua的标准库与此习惯保持一致，因此如果你的数组下标也是从1开始你就可以直接使用标准库的函数，否则就无法直接使用。

 

 

 

25：二维数组

•     Lua中主要有两种表示矩阵的方法，

•     第一种是用数组的数组表示。也就是说一个表的元素是另一个表。

•     localN = 3

•     localM = 3

•     mt ={}

•     for i= 1,N do  

•      mt[i] = {}  

•      for j = 1,M do      

•      mt[i][j] = i * j   

•     End

•     end

•     第二种是直接设置行列

•     mt ={}

•     for i= 1, N do  

•      for j = 1, M do      

•      mt[(i - 1) * M + j] = i * j  

•      end

•     end

 

 

26：链表

•     list =nil

•     for i= 1, 10 do   

•     list ={ next = list ,value = i}

•     End

•      local l = list

•     whilel do   

•      --print(l.value)   

•     l = l.next

end

27：集合

•     在Lua中用table实现集合是非常简单的，见如下代码：

•     reserved= {["while"] = true, ["end"] = true,["function"]= true, ["local"] = true,}

•     fork,v in pairs(reserved) do   

•     print(k,"->",v)

•     end

28：time

•     print(os.time())-- 输出当前时间的描述print(os.time({year=2014,month=8,day=14}))

29：date

•     函数date是time的一个反函数，它可以将一个表示日期和时间的数字转换成某些高级的表现形式。其第一个参数是格式字符串，指定了期望的表示形式；第二个参数是日期和时间的数字，默认为当前日期和时间。例如：

•     localtbCurrentTime = os.date("*t")

•      for k, v in pairs(tbCurrentTime) do   

•     print(k.. "=" .. tostring(v))

•     end

 

 

 

 

30：

•     string.find()函数用于在一个给定的目标字符串中搜索一个模式。最简单的模式就是一个单词，它只会匹配与自己完全相同的拷贝。当find找到一个模式后，它会返回两个值：匹配到的起始索引和结尾索引；如果没有找到任何匹配，它就返回nil。示例代码：

•     localstr = "Hello World”

•     locali, j = string.find(str, "Hello")

•     -- 返回Hello在str中的起始位置和终止位置

•     print(i,j)

•     string.find函数还具有一个可选的第三个参数，它是一个索引，告诉函数应该从目标字符串的哪个位置开始搜索。

•     当我们处理一个字符串中与给定模式相匹配的所以内容时，这个设置是非常有用的。我们可以循环的进行查找操作。当然了，这里只是说了最普通，也是最简单的一种方式，对于第二个参数，我们完全可以传递一个正则表达式，也就是一个pattern，进行正则匹配。示例代码：tr = "Hello12345World”

•     locali, j = string.find(str, "%d+")

•     print(i,j) -- 6   10

31：

•     函数string.match与string.find非常相似，它也是用于在一个字符串中搜索一种模式。区别在于，string.match返回的是目标字符串中与模式相匹配的那部分子串，并不是该模式所在的位置。示例代码：

•     localstr = "Hello12345World”

•     localsubStr = string.match(str, "%d+")

•     print(subStr) 

•     locali, j =string.find(str, "%d+")

•     subStr=string.sub(str, i, j)

•     print(subStr)

-----------------------------------------------------------