Lua脚本语言——基础语法

Posted 2021-08-06 二宝小菜鸟

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Lua脚本语言——基础语法相关的知识，希望对你有一定的参考价值。

一.基本语法

1.交互式编程

Lua 提供了交互式编程模式。我们可以在命令行中输入程序并立即查看效果。Lua 交互式编程模式可以通过命令 lua -i 或 lua 来启用：

$ lua -i $ Lua 5.3.0 Copyright (C) 1994-2015 Lua.org, PUC-Rio>

在命令行中，输入以下命令:

> print("Hello World！")

接着我们按下回车键，输出结果如下：

> print("Hello World！")Hello World！>

2.脚本式编程

我们可以将 Lua 程序代码保存到一个以 lua 结尾的文件，并执行，该模式称为脚本式编程，如我们将如下代码存储在名为 hello.lua 的脚本文件中：

print("Hello World！")print("www.runoob.com")

使用 lua 名执行以上脚本，输出结果为：

$ lua hello.luaHello World！www.runoob.com

我们也可以将代码修改为如下形式来执行脚本（在开头添加：#!/usr/local/bin/lua）：

示例：

#!/usr/local/bin/lua
print("Hello World！")print("www.runoob.com")

以上代码中，我们指定了 Lua 的解释器 /usr/local/bin directory。加上 # 号标记解释器会忽略它。接下来我们为脚本添加可执行权限，并执行：

./hello.lua Hello World！www.runoob.com

3.注释

单行注释

两个减号是单行注释:

--

多行注释

--[[ 多行注释 多行注释 --]]

4.标示符

Lua 标示符用于定义一个变量，函数获取其他用户定义的项。标示符以一个字母 A 到 Z 或 a 到 z 或下划线 _ 开头后加上 0 个或多个字母，下划线，数字（0 到 9）。

最好不要使用下划线加大写字母的标示符，因为Lua的保留字也是这样的。

Lua 不允许使用特殊字符如 @, $, 和 % 来定义标示符。Lua 是一个区分大小写的编程语言。因此在 Lua 中 Runoob 与 runoob 是两个不同的标示符。以下列出了一些正确的标示符：

mohd zara abc move_name a_123myname50 _temp j a23b9 retVal

5.关键字

以下列出了 Lua 的保留关键词。保留关键字不能作为常量或变量或其他用户自定义标示符：

Lua脚本语言——基础语法

一般约定，以下划线开头连接一串大写字母的名字（比如 _VERSION）被保留用于 Lua 内部全局变量。

6.全局变量

在默认情况下，变量总是认为是全局的。

全局变量不需要声明，给一个变量赋值后即创建了这个全局变量，访问一个没有初始化的全局变量也不会出错，只不过得到的结果是：nil。

> print(b)nil> b=10> print(b)10>

如果你想删除一个全局变量，只需要将变量赋值为nil。

b = nilprint(b) --> nil

这样变量b就好像从没被使用过一样。换句话说, 当且仅当一个变量不等于nil时，这个变量即存在。

二.基本数据

Lua 是动态类型语言，变量不要类型定义,只需要为变量赋值。值可以存储在变量中，作为参数传递或结果返回。

Lua 中有 8 个基本类型分别为：nil、boolean、number、string、userdata、function、thread 和 table。

Lua脚本语言——基础语法

我们可以使用 type 函数测试给定变量或者值的类型：

print(type("Hello world")) --> stringprint(type(10.4*3)) --> numberprint(type(print)) --> functionprint(type(type)) --> functionprint(type(true)) --> booleanprint(type(nil)) --> nilprint(type(type(X))) --> string

1.nil

对于全局变量和 table，nil 还有一个"删除"作用，给全局变量或者 table 表里的变量赋一个 nil 值，等同于把它们删掉。

nil 作比较时应该加上双引号 "：

> type(X)nil> type(X)==nilfalse> type(X)=="nil"true>

type(X)==nil 结果为 false 的原因是 type(X) 实质是返回的 "nil" 字符串，是一个 string 类型：

type(type(X))==string

2.boolean（布尔）

boolean类型只有两个可选值：true（真）和 false（假），Lua把false和nil 看作是false，其他的都为true，数字0也是 true:

实例：

print(type(true))print(type(false))print(type(nil))
if false or nil then print("至少有一个是 true")else print("false 和 nil 都为 false")end
if 0 then print("数字 0 是 true")else print("数字 0 为 false")end

以上代码执行结果：

$ lua test.lua booleanbooleannilfalse 和 nil 都为 false数字 0 是 true

3.number（数字）

Lua默认只有一种number类型-- double（双精度）类型（默认类型可以修改 luaconf.h 里的定义），以下几种写法都被看作是 number 类型：

实例：

print(type(2))print(type(2.2))print(type(0.2))print(type(2e+1))print(type(0.2e-1))print(type(7.8263692594256e-06))

以上代码执行结果：

numbernumbernumbernumbernumbernumber

4.string（字符串）

字符串由一对双引号或单引号来表示。

string1 = "this is string1"string2 = 'this is string2'

也可以用 2 个方括号 "[[]]" 来表示"一块"字符串。

实例：

html = [[<html><head></head><body> <a href="http://www.runoob.com/">菜鸟教程</a></body></html>]]print(html)

以下代码执行结果为：

<html><head></head><body> <a href="http://www.runoob.com/">菜鸟教程</a></body></html>

在对一个数字字符串上进行算术操作时，Lua 会尝试将这个数字字符串转成一个数字:

> print("2" + 6)8.0> print("2" + "6")8.0> print("2 + 6")2 + 6> print("-2e2" * "6")-1200.0> print("error" + 1)stdin:1: attempt to perform arithmetic on a string valuestack traceback: stdin:1: in main chunk [C]: in ?>

以上代码中"error" + 1执行报错了

字符串连接使用的是 .. ，如：

> print("a" .. 'b')ab> print(157 .. 428)157428>

使用#来计算字符串的长度，放在字符串前面，如下实例：

> len = "www.runoob.com"> print(#len)14> print(#"www.runoob.com")14>

5.table（表）

在Lua里，table 的创建是通过"构造表达式"来完成，最简单构造表达式是{}，用来创建一个空表。也可以在表里添加一些数据，直接初始化表:

-- 创建一个空的 tablelocal tbl1 = {}
-- 直接初始表local tbl2 = {"apple", "pear", "orange", "grape"}

Lua中的表（table）其实是一个"关联数组"（associative arrays），数组的索引可以是数字或者是字符串。

-- table_test.lua 脚本文件a = {}a["key"] = "value"key = 10a[key] = 22a[key] = a[key] + 11for k, v in pairs(a) do print(k .. " : " .. v)end

脚本执行结果为：

$ lua table_test.lua key : value10 : 33

不同于其他语言的数组把0作为数组的初始索引，在Lua里表的默认初始索引一般以 1 开始。

-- table_test2.lua 脚本文件local tbl = {"apple", "pear", "orange", "grape"}for key, val in pairs(tbl) do print("Key", key)end

脚本执行结果为：

$ lua table_test2.lua Key 1Key 2Key 3Key 4

table 不会固定长度大小，有新数据添加时 table 长度会自动增长，没初始的 table 都是 nil。

-- table_test3.lua 脚本文件a3 = {}for i = 1, 10 do a3[i] = ienda3["key"] = "val"print(a3["key"])print(a3["none"])

脚本执行结果为：

$ lua table_test3.lua valnil

6.function（函数）

在 Lua 中，函数是被看作是"第一类值（First-Class Value）"，函数可以存在变量里:

-- function_test.lua 脚本文件function factorial1(n) if n == 0 then return 1 else return n * factorial1(n - 1) endendprint(factorial1(5))factorial2 = factorial1print(factorial2(5))

脚本执行结果：

$ lua function_test.lua 120120

7.thread（线程）

在 Lua 里，最主要的线程是协同程序（coroutine）。它跟线程（thread）差不多，拥有自己独立的栈、局部变量和指令指针，可以跟其他协同程序共享全局变量和其他大部分东西。

线程跟协程的区别：线程可以同时多个运行，而协程任意时刻只能运行一个，并且处于运行状态的协程只有被挂起（suspend）时才会暂停。

8.userdata（自定义类型）

userdata 是一种用户自定义数据，用于表示一种由应用程序或 C/C++ 语言库所创建的类型，可以将任意 C/C++ 的任意数据类型的数据（通常是 struct 和指针）存储到 Lua 变量中调用。

三.变量

1.变量

变量在使用前，需要在代码中进行声明，即创建该变量。

编译程序执行代码之前编译器需要知道如何给语句变量开辟存储区，用于存储变量的值。

Lua 变量有三种类型：全局变量、局部变量、表中的域。

Lua 中的变量全是全局变量，那怕是语句块或是函数里，除非用 local 显式声明为局部变量。

局部变量的作用域为从声明位置开始到所在语句块结束。

变量的默认值均为 nil。

-- test.lua 文件脚本a = 5 -- 全局变量local b = 5 -- 局部变量
function joke() c = 5 -- 全局变量 local d = 6 -- 局部变量end
joke()print(c,d) --> 5 nil
do local a = 6 -- 局部变量 b = 6 -- 对局部变量重新赋值 print(a,b); --> 6 6end
print(a,b) --> 5 6

2.赋值语句

赋值是改变一个变量的值和改变表域的最基本的方法。

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

a, b = 10, 2*x <--> a=10; b=2*x

遇到赋值语句Lua会先计算右边所有的值然后再执行赋值操作，所以我们可以这样进行交换变量的值：

x, y = y, x -- swap 'x' for 'y'a[i], a[j] = a[j], a[i] -- swap 'a[i]' for 'a[j]'

当变量个数和值的个数不一致时，Lua会一直以变量个数为基础采取以下策略：

a. 变量个数 > 值的个数 按变量个数补足nilb. 变量个数 < 值的个数 多余的值会被忽略

a, b, c = 0, 1print(a,b,c) --> 0 1 nil
a, b = a+1, b+1, b+2 -- value of b+2 is ignoredprint(a,b) --> 1 2
a, b, c = 0print(a,b,c) --> 0 nil nil

上面最后一个例子是一个常见的错误情况，注意：如果要对多个变量赋值必须依次对每个变量赋值。

a, b, c = 0, 0, 0print(a,b,c) --> 0 0 0

多值赋值经常用来交换变量，或将函数调用返回给变量：

a, b = f()

f()返回两个值，第一个赋给a，第二个赋给b。

应该尽可能的使用局部变量，有两个好处：

1. 避免命名冲突。
2. 访问局部变量的速度比全局变量更快。

3.索引

对 table 的索引使用方括号 []。Lua 也提供了 . 操作。

t[i]t.i -- 当索引为字符串类型时的一种简化写法gettable_event(t,i) -- 采用索引访问本质上是一个类似这样的函数调用

> site = {}> site["key"] = "www.runoob.com"> print(site["key"])www.runoob.com> print(site.key)www.runoob.com

四.Lua循环

循环语句是由循环体及循环的终止条件两部分组成的。

Lua脚本语言——基础语法

1.while循环

while(condition)do statementsend

a=10while( a < 20 )do print("a 的值为:", a) a = a+1end

2.for循环

（1）数值for循环

for var=exp1,exp2,exp3 do  <执行体> end

var从exp1变化到exp2，每次变化以exp3为步长递增var，并执行一次"执行体"。exp3 是可选的，如果不指定，默认为1。

for i=1,f(x) do print(i)end
for i=10,1,-1 do print(i)end

#!/usr/local/bin/lua function f(x)  print("function")  return x*2 end for i=1,f(5) do print(i) end

以上实例输出结果为：

function12345678910

（2）泛型for循环

泛型 for 循环通过一个迭代器函数来遍历所有值，类似 java 中的 foreach 语句。

Lua 编程语言中泛型 for 循环语法格式:

--打印数组a的所有值 a = {"one", "two", "three"}for i, v in ipairs(a) do print(i, v)end

i是数组索引值，v是对应索引的数组元素值。ipairs是Lua提供的一个迭代器函数，用来迭代数组。

#!/usr/local/bin/lua days = {"Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"} for i,v in ipairs(days) do  print(v) end

以上实例输出结果为：

SundayMondayTuesdayWednesdayThursdayFridaySaturday

3.repeat...until 循环

repeat statementsuntil(condition)

我们注意到循环条件判断语句（condition）在循环体末尾部分，所以在条件进行判断前循环体都会执行一次。

如果条件判断语句（condition）为 false，循环会重新开始执行，直到条件判断语句（condition）为 true 才会停止执行。

--[ 变量定义 --]a = 10--[ 执行循环 --]repeat print("a的值为:", a) a = a + 1until( a > 15 )

输出：

a的值为: 10a的值为: 11a的值为: 12a的值为: 13a的值为: 14a的值为: 15

4.循环控制语句

循环控制语句用于控制程序的流程，以实现程序的各种结构方式。

Lua 支持以下循环控制语句：

break语句：

--[ 定义变量 --]a = 10
--[ while 循环 --]while( a < 20 )do print("a 的值为:", a) a=a+1 if( a > 15) then --[ 使用 break 语句终止循环 --] break endend

以上代码执行结果如下：

a 的值为: 10a 的值为: 11a 的值为: 12a 的值为: 13a 的值为: 14a 的值为: 15

goto语句：

goto Label

Label 的格式为：

:: Label ::

local a = 1::label:: print("--- goto label ---")
a = a+1if a < 3 then goto label -- a 小于 3 的时候跳转到标签 labelend

输出：

--- goto label ------ goto label ---

5.无限循环

在循环体中如果条件永远为 true 循环语句就会永远执行下去，以下以 while 循环为例：

while(true)do print("循环将永远执行下去")end

五.流程控制

1.if语句

if(布尔表达式)then --[ 在布尔表达式为 true 时执行的语句 --]end

--[ 定义变量 --]a = 10;
--[ 使用 if 语句 --]if( a < 20 )then --[ if 条件为 true 时打印以下信息 --] print("a 小于 20" );endprint("a 的值为:", a);

输出：

a 小于 20a 的值为: 10

2.if...else语句

if(布尔表达式)then --[ 布尔表达式为 true 时执行该语句块 --]else --[ 布尔表达式为 false 时执行该语句块 --]end

注意：Lua认为false和nil为假，true 和非nil为真。要注意的是Lua中 0 为 true。

--[ 定义变量 --]a = 100;--[ 检查条件 --]if( a < 20 )then --[ if 条件为 true 时执行该语句块 --] print("a 小于 20" )else --[ if 条件为 false 时执行该语句块 --] print("a 大于 20" )endprint("a 的值为 :", a)

输出：

a 大于 20a 的值为 : 100

if...elseif...else 语句

Lua if 语句可以与 elseif...else 语句搭配使用, 在 if 条件表达式为 false 时执行 elseif...else 语句代码块，用于检测多个条件语句。

Lua if...elseif...else 语句语法格式如下：

if(布尔表达式 1)then   --[ 在布尔表达式 1 为 true 时执行该语句块 --]   elseif( 布尔表达式 2)then --[ 在布尔表达式 2 为 true 时执行该语句块 --]
elseif( 布尔表达式 3)then --[ 在布尔表达式 3 为 true 时执行该语句块 --]else  --[ 如果以上布尔表达式都不为 true 则执行该语句块 --]end

--[ 定义变量 --]a = 100
--[ 检查布尔条件 --]if( a == 10 )then --[ 如果条件为 true 打印以下信息 --] print("a 的值为 10" )elseif( a == 20 )then  --[ if else if 条件为 true 时打印以下信息 --] print("a 的值为 20" )elseif( a == 30 )then --[ if else if condition 条件为 true 时打印以下信息 --] print("a 的值为 30" )else --[ 以上条件语句没有一个为 true 时打印以下信息 --] print("没有匹配 a 的值" )endprint("a 的真实值为: ", a )

输出：

没有匹配 a 的值a 的真实值为: 100

if嵌套语句

if( 布尔表达式 1)then --[ 布尔表达式 1 为 true 时执行该语句块 --] if(布尔表达式 2) then --[ 布尔表达式 2 为 true 时执行该语句块 --] endend

--[ 定义变量 --]a = 100;b = 200;
--[ 检查条件 --]if( a == 100 )then --[ if 条件为 true 时执行以下 if 条件判断 --] if( b == 200 ) then --[ if 条件为 true 时执行该语句块 --] print("a 的值为 100 b 的值为 200" ); endendprint("a 的值为 :", a );print("b 的值为 :", b );

输出：

a 的值为 100 b 的值为 200a 的值为 : 100b 的值为 : 200

六.函数

在Lua中，函数是对语句和表达式进行抽象的主要方法。既可以用来处理一些特殊的工作，也可以用来计算一些值。

Lua 提供了许多的内建函数，你可以很方便的在程序中调用它们，如print()函数可以将传入的参数打印在控制台上。

Lua 函数主要有两种用途：

1.完成指定的任务，这种情况下函数作为调用语句使用；
2.计算并返回值，这种情况下函数作为赋值语句的表达式使用。

1.函数定义格式

optional_function_scope function function_name( argument1, argument2, argument3..., argumentn) function_body return result_params_comma_separatedend

解析：

optional_function_scope: 该参数是可选的制定函数是全局函数还是局部函数，未设置该参数默认为全局函数，如果你需要设置函数为局部函数需要使用关键字 local。
function_name: 指定函数名称。
argument1, argument2, argument3..., argumentn: 函数参数，多个参数以逗号隔开，函数也可以不带参数。
function_body: 函数体，函数中需要执行的代码语句块。
result_params_comma_separated: 函数返回值，Lua语言函数可以返回多个值，每个值以逗号隔开。

实例

以下实例定义了函数 max()，参数为 num1, num2，用于比较两值的大小，并返回最大值：

--[[ 函数返回两个值的最大值 --]]function max(num1, num2) if (num1 > num2) then result = num1; else result = num2;   end return result;end-- 调用函数print("两值比较最大值为 ",max(10,4))print("两值比较最大值为 ",max(5,6))

输出：

两值比较最大值为 10两值比较最大值为 6

Lua 中我们可以将函数作为参数传递给函数，如下实例：

myprint = function(param) print("这是打印函数 - ##",param,"##")end
function add(num1,num2,functionPrint) result = num1 + num2 -- 调用传递的函数参数 functionPrint(result)endmyprint(10)-- myprint 函数作为参数传递add(2,5,myprint)

输出：

这是打印函数 - ## 10 ##这是打印函数 - ## 7 ##

2.多返回值

Lua函数可以返回多个结果值，比如string.find，其返回匹配串"开始和结束的下标"（如果不存在匹配串返回nil）。

> s, e = string.find("www.runoob.com", "runoob") > print(s, e)5 10

Lua函数中，在return后列出要返回的值的列表即可返回多值，如：

function maximum (a) local mi = 1 -- 最大值索引 local m = a[mi] -- 最大值 for i,val in ipairs(a) do if val > m then mi = i m = val end end return m, miend
print(maximum({8,10,23,12,5}))

输出：

23 3

3.可变参数

lua 函数可以接受可变数目的参数，和 C 语言类似，在函数参数列表中使用三点 ... 表示函数有可变的参数。

function add(...) local s = 0  for i, v in ipairs{...} do --> {...} 表示一个由所有变长参数构成的数组  s = s + v  end  return s end print(add(3,4,5,6,7)) --->25

我们可以将可变参数赋值给一个变量。

例如，我们计算几个数的平均值：

function average(...) result = 0 local arg={...} --> arg 为一个表，局部变量 for i,v in ipairs(arg) do result = result + v end print("总共传入 " .. #arg .. " 个数") return result/#argend
print("平均值为",average(10,5,3,4,5,6))

输出：

总共传入 6 个数平均值为 5.5

我们也可以通过 select("#",...) 来获取可变参数的数量：

function average(...) result = 0 local arg={...} for i,v in ipairs(arg) do result = result + v end print("总共传入 " .. select("#",...) .. " 个数") return result/select("#",...)end
print("平均值为",average(10,5,3,4,5,6))

输出：

总共传入 6 个数平均值为 5.5

有时候我们可能需要几个固定参数加上可变参数，固定参数必须放在变长参数之前:

function fwrite(fmt, ...) ---> 固定的参数fmt return io.write(string.format(fmt, ...)) end
fwrite("runoob\n") --->fmt = "runoob", 没有变长参数。fwrite("%d%d\n", 1, 2) --->fmt = "%d%d", 变长参数为 1 和 2

输出：

runoob12

通常在遍历变长参数的时候只需要使用 {…}，然而变长参数可能会包含一些 nil，那么就可以用 select 函数来访问变长参数了：select('#', …) 或者 select(n, …)

select('#', …) 返回可变参数的长度。
select(n, …) 用于返回从起点 n 开始到结束位置的所有参数列表。

调用 select 时，必须传入一个固定实参 selector(选择开关) 和一系列变长参数。如果 selector 为数字 n，那么 select 返回参数列表中从索引 n 开始到结束位置的所有参数列表，否则只能为字符串 #，这样 select 返回变长参数的总数。

function f(...) a = select(3,...) -->从第三个位置开始，变量 a 对应右边变量列表的第一个参数 print (a) print (select(3,...)) -->打印所有列表参数end
f(0,1,2,3,4,5)

输出：

22 3 4 5

do  function foo(...)  for i = 1, select('#', ...) do -->获取参数总数 local arg = select(i, ...); -->读取参数，arg 对应的是右边变量列表的第一个参数 print("arg", arg);  end  end 
 foo(1, 2, 3, 4); end

输出：

arg 1arg 2arg 3arg 4

七.Lua运算符

运算符是一个特殊的符号，用于告诉解释器执行特定的数学或逻辑运算。Lua提供了以下几种运算符类型：

算术运算符
关系运算符
逻辑运算符
其他运算符

1.算术运算符

下表列出了Lua语言中的常用算术运算符，设定A的值为10，B的值为20：

Lua脚本语言——基础语法

2.关系运算符

下表列出了 Lua 语言中的常用关系运算符，设定 A 的值为10，B 的值为 20：

Lua脚本语言——基础语法

3.逻辑运算符

下表列出了Lua语言中的常用逻辑运算符，设定A的值为true，B的值为 false：

实例：

a = trueb = true
if ( a and b )then print("a and b - 条件为 true" )end
if ( a or b )then print("a or b - 条件为 true" )end
print("---------分割线---------" )
-- 修改 a 和 b 的值a = falseb = true
if ( a and b )then print("a and b - 条件为 true" )else print("a and b - 条件为 false" )end
if ( not( a and b) )then print("not( a and b) - 条件为 true" )else print("not( a and b) - 条件为 false" )end

程序运行结果：

a and b - 条件为 truea or b - 条件为 true---------分割线---------a and b - 条件为 falsenot( a and b) - 条件为 true

4.其他运算符

下表列出了 Lua 语言中的连接运算符与计算表或字符串长度的运算符：

实例：

a = "Hello "b = "World"
print("连接字符串 a 和 b ", a..b )
print("b 字符串长度 ",#b )
print("字符串 Test 长度 ",#"Test" )
print("菜鸟教程网址长度 ",#"www.runoob.com" )

程序运行结果：

连接字符串 a 和 b Hello Worldb 字符串长度 5字符串 Test 长度 4菜鸟教程网址长度 14

运算符的优先级：

从高到低的顺序

^not - (unary)* / %+ -..< > <= >= ~= ==andor

除了 ^ 和 .. 外所有的二元运算符都是左连接的。

a+i < b/2+1 <--> (a+i) < ((b/2)+1)5+x^2*8 <--> 5+((x^2)*8)a < y and y <= z <--> (a < y) and (y <= z)-x^2 <--> -(x^2)x^y^z <--> x^(y^z)

八.Lua字符串

字符串或串(String)是由数字、字母、下划线组成的一串字符。

Lua 语言中字符串可以使用以下三种方式来表示：

单引号间的一串字符。
双引号间的一串字符。
[[ 与 ]] 间的一串字符。

以上三种方式的字符串实例如下：

string1 = "Lua"print("\"字符串 1 是\"",string1)string2 = 'runoob.com'print("字符串 2 是",string2)
string3 = [["Lua 教程"]]print("字符串 3 是",string3)

运行结果：

"字符串 1 是" Lua字符串 2 是 runoob.com字符串 3 是 "Lua 教程"

Lua字符串操作提供了很多函数，具体使用可以查询，这里就不赘述了！

九.Lua数组

数组，就是相同数据类型的元素按一定顺序排列的集合，可以是一维数组和多维数组。

Lua 数组的索引键值可以使用整数表示，数组的大小不是固定的。

1.一维数组

array = {"Lua", "Tutorial"}
for i= 0, 2 do print(array[i])end

运行结果：

nilLuaTutorial

正如你所看到的，我们可以使用整数索引来访问数组元素，如果知道的索引没有值则返回nil。

在 Lua 索引值是以 1 为起始，但你也可以指定 0 开始。

除此外我们还可以以负数为数组索引值：

array = {}
for i= -2, 2 do array[i] = i *2end
for i = -2,2 do print(array[i])end

运行结果：

-4-2024

2.多维数组

多维数组即数组中包含数组或一维数组的索引键对应一个数组。

以下是一个三行三列的阵列多维数组：

-- 初始化数组array = {}for i=1,3 do array[i] = {} for j=1,3 do array[i][j] = i*j endend
-- 访问数组for i=1,3 do for j=1,3 do print(array[i][j]) endend

运行结果：

123246369

-- 初始化数组array = {}maxRows = 3maxColumns = 3for row=1,maxRows do for col=1,maxColumns do array[row*maxColumns +col] = row*col endend
-- 访问数组for row=1,maxRows do for col=1,maxColumns do print(array[row*maxColumns +col]) endend

运行结果：

123246369

十.Lua迭代器

在 Lua 中迭代器是一种支持指针类型的结构，它可以遍历集合的每一个元素。

1.泛型for迭代器

泛型 for 在自己内部保存迭代函数，实际上它保存三个值：迭代函数、状态常量、控制变量。

泛型 for 迭代器提供了集合的 key/value 对，语法格式如下：

for k, v in pairs(t) do print(k, v)end

2.无状态的迭代器

无状态的迭代器是指不保留任何状态的迭代器，因此在循环中我们可以利用无状态迭代器避免创建闭包花费额外的代价。

每一次迭代，迭代函数都是用两个变量（状态常量和控制变量）的值作为参数被调用，一个无状态的迭代器只利用这两个值可以获取下一个元素。

这种无状态迭代器的典型的简单的例子是 ipairs，它遍历数组的每一个元素，元素的索引需要是数值。

以下实例我们使用了一个简单的函数来实现迭代器，实现数字 n 的平方：

function square(iteratorMaxCount,currentNumber) if currentNumber<iteratorMaxCount then currentNumber = currentNumber+1 return currentNumber, currentNumber*currentNumber endend
for i,n in square,3,0do print(i,n)end

输出结果：

1 12 43 9

3.多状态的迭代器

很多情况下，迭代器需要保存多个状态信息而不是简单的状态常量和控制变量，最简单的方法是使用闭包，还有一种方法就是将所有的状态信息封装到 table 内，将 table 作为迭代器的状态常量，因为这种情况下可以将所有的信息存放在 table 内，所以迭代函数通常不需要第二个参数。

以下实例我们创建了自己的迭代器：

array = {"Google", "Runoob"}
function elementIterator (collection) local index = 0 local count = #collection -- 闭包函数 return function () index = index + 1 if index <= count then -- 返回迭代器的当前元素 return collection[index] end endend
for element in elementIterator(array)do print(element)end

输出结果：

GoogleRunoob

十一.Lua table（表）

table 是 Lua 的一种数据结构用来帮助我们创建不同的数据类型，如：数组、字典等。

Lua table 使用关联型数组，你可以用任意类型的值来作数组的索引，但这个值不能是 nil。

Lua table 是不固定大小的，你可以根据自己需要进行扩容。

Lua也是通过table来解决模块（module）、包（package）和对象（Object）的。例如string.format表示使用"format"来索引table string。

1.table(表)的构造

构造器是创建和初始化表的表达式。表是Lua特有的功能强大的东西。最简单的构造函数是{}，用来创建一个空表。可以直接初始化数组:

-- 初始化表mytable = {}
-- 指定值mytable[1]= "Lua"
-- 移除引用mytable = nil-- lua 垃圾回收会释放内存

当我们为 table a 并设置元素，然后将 a 赋值给 b，则 a 与 b 都指向同一个内存。如果 a 设置为 nil ，则 b 同样能访问 table 的元素。如果没有指定的变量指向a，Lua的垃圾回收机制会清理相对应的内存。

以下实例演示了以上的描述情况：

-- 简单的 tablemytable = {}print("mytable 的类型是 ",type(mytable))
mytable[1]= "Lua"mytable["wow"] = "修改前"print("mytable 索引为 1 的元素是 ", mytable[1])print("mytable 索引为 wow 的元素是 ", mytable["wow"])
-- alternatetable和mytable的是指同一个 tablealternatetable = mytable
print("alternatetable 索引为 1 的元素是 ", alternatetable[1])print("mytable 索引为 wow 的元素是 ", alternatetable["wow"])
alternatetable["wow"] = "修改后"
print("mytable 索引为 wow 的元素是 ", mytable["wow"])
-- 释放变量alternatetable = nilprint("alternatetable 是 ", alternatetable)
-- mytable 仍然可以访问print("mytable 索引为 wow 的元素是 ", mytable["wow"])
mytable = nilprint("mytable 是 ", mytable)

输出结果：

mytable 的类型是 tablemytable 索引为 1 的元素是 Luamytable 索引为 wow 的元素是 修改前alternatetable 索引为 1 的元素是 Luamytable 索引为 wow 的元素是 修改前mytable 索引为 wow 的元素是 修改后alternatetable 是 nilmytable 索引为 wow 的元素是 修改后mytable 是 nil

2.table函数

（1）table连接

fruits = {"banana","orange","apple"}-- 返回 table 连接后的字符串print("连接后的字符串 ",table.concat(fruits))
-- 指定连接字符print("连接后的字符串 ",table.concat(fruits,", "))
-- 指定索引来连接 tableprint("连接后的字符串 ",table.concat(fruits,", ", 2,3))

输出函数：

连接后的字符串 bananaorangeapple连接后的字符串 banana, orange, apple连接后的字符串 orange, apple

（2）插入和移除

以下实例演示了 table 的插入和移除操作:

fruits = {"banana","orange","apple"}
-- 在末尾插入table.insert(fruits,"mango")print("索引为 4 的元素为 ",fruits[4])
-- 在索引为 2 的键处插入table.insert(fruits,2,"grapes")print("索引为 2 的元素为 ",fruits[2])
print("最后一个元素为 ",fruits[5])table.remove(fruits)print("移除后最后一个元素为 ",fruits[5])

输出结果：

索引为 4 的元素为 mango索引为 2 的元素为 grapes最后一个元素为 mango移除后最后一个元素为 nil

（3）Table 排序

以下实例演示了 sort() 方法的使用，用于对 Table 进行排序：

fruits = {"banana","orange","apple","grapes"}print("排序前")for k,v in ipairs(fruits) do print(k,v)end
table.sort(fruits)print("排序后")for k,v in ipairs(fruits) do print(k,v)end

输出结果：

排序前1 banana2 orange3 apple4 grapes排序后1 apple2 banana3 grapes4 orange

（4）最大值

table.maxn 在 Lua5.2 之后该方法已经不存在了，我们定义了 table_maxn 方法来实现。以下实例演示了如何获取 table 中的最大值：

function table_maxn(t) local mn=nil; for k, v in pairs(t) do if(mn==nil) then mn=v end if mn < v then mn = v end end return mnendtbl = {[1] = 2, [2] = 6, [3] = 34, [26] =5}print("tbl 最大值：", table_maxn(tbl))print("tbl 长度 ", #tbl)

输出结果：

tbl 最大值： 34tbl 长度 3

注意：当我们获取 table 的长度的时候无论是使用 # 还是 table.getn 其都会在索引中断的地方停止计数，而导致无法正确取得 table 的长度。

可以使用以下方法来代替：

function table_leng(t) local leng=0 for k, v in pairs(t) do leng=leng+1 end return leng;end

以上是关于Lua脚本语言——基础语法的主要内容，如果未能解决你的问题，请参考以下文章