[TOC]

Lua学习笔记(整理的runoob加自己的见解)

注意事项

1- Lua中变量没有预定义类型，每个变量可以包含任意类型的值，要用就直接赋值一种数据类型的值
2- nil类型就nil一个值，表示变量是否被赋值，变量赋值成nil也表示删除变量
3- 使用Type(xxx变量) 可以获取该变量的数据类型
4- number 所有数字，int float double 类型等都为number类型了
5- 字符串一旦赋值不能被修改，可以通过方法string.gsub()来修改，可以写成’xxas’单引号，但是建议用双引号””
6- number类型可以和全是数字的字符串进行计算，字符串会进行类型转换
7- .. 连接符号 ，可以连接字符串类型，也可以连接整形的变量，但是如果直接使用真实的数字要在后面加个空格，因为系统会把 数字.. 看出2个浮点 如 1..2 （错误写法） 1 ..2 (正确写法)
8- 类型不同，比较判断也不会相等,如number类型的123不等于string类型的123
9- 计算运算符中取余可以和浮点数计算，可以精确到小数级别
10- 关系运算符中~= 表示不等于，类似其他语言如c的 !=
11- 逻辑运算符 and ，or ，not 对应 && ，|| , ！
12- 表达式：a and b a为假则返回a 否则返回b， a or b a为真返回a否则返回b ,简单理解and就是先判断a a正确就继续判断b，如果b也正确返回btrue，则if(a and b) 为true ，这实际上也是&&的使用原理一样 ，如果a为假就是false直接返回a if(a and b) 就是false了 。 or 同理 ||
13- 赋值方式一：多个变量同时赋值，多的变量(变量个数多于值个数)默认为nil，少的变量(变量个数少于值个数)不做处理，可以类型混搭
14- 局部变量 用local修饰声明 ，内存在栈上，在一个函数，代码块{ }内 函数，代码块结束，内存自动释放
15- 全局变量在堆上，可以随时创建，程序结束，内存自动释放
16- 控制语句上，有if for where 没有switch结构
17- 控制语句上，不需要写 () {} {指代 ：then } 指代 ： end
18- 循环结构 while do end ,里面不能写() 以及 ++ – += 类似的运算符
19- 循环结构 for 也不需要写() 也不在赋值除了对第一个赋值，其他都可以省略写默认写为 <= +xx 或 >= -xx
20- 函数的返回值和其他语言一样可以返回个值，变量。但是不同的是可以同时返回多个变量，进行多个赋值
21- table可以有数组的形式，字典的形式，数组字典同时混合的形式
22- print()打印会默认换行
23- #号数组是计算数组容器table的下标个数，lua的数组容器下标从1开始计算递增，字典不包括key元素
24- 有两种遍历结构pairs ，ipairs ，第一个遍历所有元素，第二个只遍历没有key类型的元素（不遍历字典），不能返回nil
25
26--------------------- 
27作者：liaoshengg 
28来源：CSDN 
29原文：https://blog.csdn.net/liaoshengg/article/details/81299018 
30版权声明：本文为博主原创文章，转载请附上博文链接！

安装

• Mac下安装

Mac下安装好brew之后,直接用brew安装即可

brew install lua

或者使用编译安装的方式

1curl -R -O http://www.lua.org/ftp/lua-5.3.0.tar.gz
2tar zxf lua-5.3.0.tar.gz
3cd lua-5.3.0
4make macosx test
5make install # 权限不足的时候需要用root执行

• linux下安装

  curl -R -O http://www.lua.org/ftp/lua-5.3.0.tar.gz tar zxf lua-5.3.0.tar.gz cd lua-5.3.0 make linux test make install # 权限不足的时候需要用root执行

开启交互式命令行模式

Lua 交互式编程模式可以通过命令 lua -i 或 lua 来启用

脚本式编程

lua脚本的后缀名为.lua

1#!/usr/local/bin/lua
2
3print("Hello World！")

和shell脚本一样, 如果文件头指定lua解释器的路径后可以直接./文件名运行

否则就要用lua ./文件名 运行.

注释

• 单行注释为--
• 多行注释为--[[ 注释内容 --]]

标识符和变量

标识符

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

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

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

变量

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

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

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

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

变量在使用前，必须在代码中进行声明,变量的默认值均为 nil。

全局变量不需要单独声明，给一个变量赋值后即创建了这个全局变量

访问一个没有初始化的全局变量也不会出错，只不过得到的结果是：nil。

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

局部变量 用local修饰声明 ，内存在栈上，在一个函数，代码块{ }内 函数，代码块结束，内存自动释放

全局变量在堆上，可以随时创建，程序结束，内存自动释放

1testA = 1 --全局变量
2local testB = 2 --局部变量
3
4print(testA)    --输出1
5print(testB)    --输出2
6print(testNone) --输出nil(不存在的变量不会报错)
7

• 变量赋值

遇到赋值语句Lua会先计算右边所有的值然后再执行赋值操作

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

1a, b = 10, 2*x --效果和下面的一样
2a=10; b=2*x -- 效果和上面的一样, 注意一行声明两个变量时需要用;分割
3

多个变量同时赋值时,当变量个数和值的个数不一致时，Lua会一直以变量个数为基础将没有值的变量设置为nil

1a,b,c = 0,1
2print(a)
3print(b)
4print(c)

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

1x, y = y, x                     -- swap 'x' for 'y'
2a[i], a[j] = a[j], a[i]         -- swap 'a[i]' for 'a[j]'
3
4a, b = f()  --f()返回两个值，第一个赋给a，第二个赋给b。
5

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

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

索引

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

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

例如:

1> site = {}
2> site["key"] = "www.w3cschool.cc"
3> print(site["key"]) --使用[]来获取索引下的值
4www.w3cschool.cc
5> print(site.key)   --使用.来获取索引下的值
6www.w3cschool.cc

lua 数据类型

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

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

数据类型

描述

nil

这个最简单，只有值nil属于该类，表示一个无效值（在条件表达式中相当于false）。

boolean

包含两个值：false和true。

number

表示双精度类型的实浮点数

string

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

function

由 C 或 Lua 编写的函数

userdata

表示任意存储在变量中的C数据结构

thread

表示执行的独立线路，用于执行协同程序

table

Lua 中的表（table）其实是一个"关联数组"（associative arrays），<br/>数组的索引可以是数字或者是字符串。<br/>在 Lua 里，table 的创建是通过"构造表达式"来完成，<br/>最简单构造表达式是{}，用来创建一个空表。

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

1print(type("Hello world"))      --> string
2print(type(10.4*3))             --> number
3print(type(print))              --> function
4print(type(type))               --> function
5print(type(true))               --> boolean
6print(type(nil))                --> nil
7print(type(type(X)))            --> string

nil（无效值）

nil 类型表示一种没有任何有效值，它只有一个值 -- nil，例如打印一个没有赋值的变量，便会输出一个 nil 值：

print(a)    --结果为nil

对于全局变量和 table，nil 还有一个"删除"作用，给全局变量或者 table 表里的变量赋一个 nil 值，等同于把它们删掉，执行下面代码就知：

1tab1 = { key1 = "val1", key2 = "val2", "val3" }
2for k, v in pairs(tab1) do
3    print(k .. " - " .. v)
4end
5 
6tab1.key1 = nil
7for k, v in pairs(tab1) do
8    print(k .. " - " .. v)
9end

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

type(X)==nil 结果为 false 的原因是因为 type(type(X))==string。

1> type(X)
2nil
3> type(X)==nil
4false
5> type(X)=="nil"
6true
7>

boolean（布尔）

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

1> print(type(true))
2boolean
3> print(type(false))
4boolean
5> print(type(nil))
6nil
7>
8
9if false or nil then
10    print("至少有一个是 true")
11else
12    print("false 和 nil 都为 false!")
13end

number（数字）

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

1> print(type(2))
2number
3> print(type(2.2))
4number
5> print(type(0.2))
6number
7> print(type(2e+1))
8number
9> print(type(0.2e-1))
10number
11> print(type(7.8263692594256e-06))
12number
13>

string（字符串）

lua字符串说明

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

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

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

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

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

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

1string1 = "this is string1"
2string2 = 'this is string2'

多行字符使用[[]]来做标识

1> html = [[
2>> <html>
3>> <head></head>
4>> <body>
5>>     <a href="http://www.runoob.com/">菜鸟教程</a>
6>> </body>
7>> </html>
8>> ]]
9> print(html)
10<html>
11<head></head>
12<body>
13    <a href="http://www.runoob.com/">菜鸟教程</a>
14</body>
15</html>
16>

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

1> print("2" + 6)
28.0
3> print("2" + "6")
48.0
5> print("2 + 6")
62 + 6
7> print("-2e2" * "6")
8-1200.0
9> print("error" + 1)
10stdin:1: attempt to perform arithmetic on a string value
11stack traceback:
12	stdin:1: in main chunk
13	[C]: in ?
14>

以上代码中"error" + 1执行报错了，字符串连接使用的是 .. ，如：

1> print("a" .. 'b')
2ab
3> print(157 .. 428)
4157428
5>

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

1> len = "www.runoob.com"
2> print(#len)
314
4> print(#"www.runoob.com")
514
6>

字符串操作

Lua 提供了很多的方法来支持字符串的操作：

序号

方法 & 用途

1

string.upper(argument): </br> 字符串全部转为大写字母。

2

string.lower(argument): </br> 字符串全部转为小写字母。

3

string.gsub(mainString,findString,replaceString,num)</br>在字符串中替换,mainString为要替换的字符串， findString 为被替换的字符，replaceString 要替换的字符，num 替换次数（可以忽略，则全部替换），如：</br>> string.gsub("aaaa","a","z",3);</br>zzza 3

4

string.find (str, substr, [init, [end]])</br>在一个指定的目标字符串中搜索指定的内容(第三个参数为索引),返回其具体位置。不存在则返回 nil。</br>> string.find("Hello Lua user", "Lua", 1)</br>7 9

5

string.reverse(arg)</br>字符串反转</br>> string.reverse("Lua")</br>auL

6

string.format(...)</br>返回一个类似printf的格式化字符串</br>> string.format("the value is:%d",4)</br>the value is:4

7

string.char(arg) 和 string.byte(arg[,int])</br>char 将整型数字转成字符并连接， byte 转换字符为整数值(可以指定某个字符，默认第一个字符)。</br>> string.char(97,98,99,100)</br>abcd</br>> string.byte("ABCD",4)</br>68</br>> string.byte("ABCD")</br>65</br>>

8

string.len(arg)</br>计算字符串长度。</br>string.len("abc")</br>3

9

string.rep(string, n)</br>返回字符串string的n个拷贝</br>>string.rep("abcd",2)</br>abcdabcd

10

..</br>链接两个字符串</br>> print("www.runoob.".."com")</br>www.runoob.com

11

string.gmatch(str, pattern)</br>回一个迭代器函数，每一次调用这个函数，返回一个在字符串 str 找到的下一个符合 pattern 描述的子串。如果参数 pattern 描述的字符串没有找到，迭代函数返回nil。</br>> for word in string.gmatch("Hello Lua user", "%a+") do print(word) end </br> Hello </br> Lua </br> user

12

string.match(str, pattern, init) </br> string.match()只寻找源字串str中的第一个配对. 参数init可选, 指定搜寻过程的起点, 默认为1。 </br> 在成功配对时, 函数将返回配对表达式中的所有捕获结果; 如果没有设置捕获标记, 则返回整个配对字符串. 当没有成功的配对时, 返回nil。</br> > string.match("I have 2 questions for you.", "%d+ %a+") </br> 2 questions </br> > string.format("%d, %q", string.match("I have 2 questions for you.", "(%d+) (%a+)")) </br> 2, "questions"

字符串格式化

Lua 提供了 string.format() 函数来生成具有特定格式的字符串, 函数的第一个参数是格式 , 之后是对应格式中每个代号的各种数据。

由于格式字符串的存在, 使得产生的长字符串可读性大大提高了。这个函数的格式很像 C 语言中的 printf()。

以下实例演示了如何对字符串进行格式化操作：

格式字符串可能包含以下的转义码:

• %c - 接受一个数字, 并将其转化为ASCII码表中对应的字符
• %d, %i - 接受一个数字并将其转化为有符号的整数格式
• %o - 接受一个数字并将其转化为八进制数格式
• %u - 接受一个数字并将其转化为无符号整数格式
• %x - 接受一个数字并将其转化为十六进制数格式, 使用小写字母
• %X - 接受一个数字并将其转化为十六进制数格式, 使用大写字母
• %e - 接受一个数字并将其转化为科学记数法格式, 使用小写字母e
• %E - 接受一个数字并将其转化为科学记数法格式, 使用大写字母E
• %f - 接受一个数字并将其转化为浮点数格式
• %g(%G) - 接受一个数字并将其转化为%e(%E, 对应%G)及%f中较短的一种格式
• %q - 接受一个字符串并将其转化为可安全被Lua编译器读入的格式
• %s - 接受一个字符串并按照给定的参数格式化该字符串

为进一步细化格式, 可以在%号后添加参数. 参数将以如下的顺序读入:

• (1) 符号: 一个+号表示其后的数字转义符将让正数显示正号. - 默认情况下只有负数显示符号.
• (2) 占位符: 一个0, 在后面指定了字串宽度时占位用. 不填时的默认占位符是空格.
• (3) 对齐标识: 在指定了字串宽度时, 默认为右对齐, 增加-号可以改为左对齐.
• (4) 宽度数值
• (5) 小数位数/字串裁切: 在宽度数值后增加的小数部分n, 若后接f(浮点数转义符, 如%6.3f)则设定该浮点数的小数只保留n位, 若后接s(字符串转义符, 如%5.3s)则设定该字符串只显示前n位.

格式化案例:

1string.format("%c", 83)                 输出S
2string.format("%+d", 17.0)              输出+17
3string.format("%05d", 17)               输出00017
4string.format("%o", 17)                 输出21
5string.format("%u", 3.14)               输出3
6string.format("%x", 13)                 输出d
7string.format("%X", 13)                 输出D
8string.format("%e", 1000)               输出1.000000e+03
9string.format("%E", 1000)               输出1.000000E+03
10string.format("%6.3f", 13)              输出13.000
11string.format("%q", "One\nTwo")         输出"One\
12                                        　　Two"
13string.format("%s", "monkey")           输出monkey
14string.format("%10s", "monkey")         输出    monkey
15string.format("%5.3s", "monkey")        输出  mon

字符与整数相互转换

以下实例演示了字符与整数相互转换：

1-- 字符转换
2-- 转换第一个字符
3print(string.byte("Lua"))
4-- 转换第三个字符
5print(string.byte("Lua",3))
6-- 转换末尾第一个字符
7print(string.byte("Lua",-1))
8-- 第二个字符
9print(string.byte("Lua",2))
10-- 转换末尾第二个字符
11print(string.byte("Lua",-2))
12
13-- 整数 ASCII 码转换为字符
14print(string.char(97))

以上代码执行结果为：

176
297
397
4117
5117
6a

其他常用函数

以下实例演示了其他字符串操作，如计算字符串长度，字符串连接，字符串复制等：

1string1 = "www."
2string2 = "runoob"
3string3 = ".com"
4-- 使用 .. 进行字符串连接
5print("连接字符串",string1..string2..string3)
6
7-- 字符串长度
8print("字符串长度 ",string.len(string2))
9
10-- 字符串复制 2 次
11repeatedString = string.rep(string2,2)
12print(repeatedString)

以上代码执行结果为：

1连接字符串    www.runoob.com
2字符串长度     6
3runoobrunoob

匹配模式

Lua 中的匹配模式直接用常规的字符串来描述。 它用于模式匹配函数 string.find, string.gmatch, string.gsub, string.match。

你还可以在模式串中使用字符类。

字符类指可以匹配一个特定字符集合内任何字符的模式项。比如，字符类%d匹配任意数字。所以你可以使用模式串 '%d%d/%d%d/%d%d%d%d' 搜索 dd/mm/yyyy 格式的日期：

1s = "Deadline is 30/05/1999, firm"
2date = "%d%d/%d%d/%d%d%d%d"
3print(string.sub(s, string.find(s, date)))    --> 30/05/1999

下面的表列出了Lua支持的所有字符类：

单个字符(除 ^$()%.[]*+-? 外): 与该字符自身配对

• .(点): 与任何字符配对
• %a: 与任何字母配对
• %c: 与任何控制符配对(例如\n)
• %d: 与任何数字配对
• %l: 与任何小写字母配对
• %p: 与任何标点(punctuation)配对
• %s: 与空白字符配对
• %u: 与任何大写字母配对
• %w: 与任何字母/数字配对
• %x: 与任何十六进制数配对
• %z: 与任何代表0的字符配对
• %x(此处x是非字母非数字字符): 与字符x配对. 主要用来处理表达式中有功能的字符(^$()%.[]*+-?)的配对问题, 例如%%与%配对
• [数个字符类]: 与任何[]中包含的字符类配对. 例如[%w_]与任何字母/数字, 或下划线符号(_)配对
• [^数个字符类]: 与任何不包含在[]中的字符类配对.例如[^%s]与任何非空白字符配对

当上述的字符类用大写书写时, 表示与非此字符类的任何字符配对. 例如, %S表示与任何非空白字符配对.例如，'%A'非字母的字符:

1> print(string.gsub("hello, up-down!", "%A", "."))
2hello..up.down.    4

数字4不是字符串结果的一部分，他是gsub返回的第二个结果，代表发生替换的次数。

在模式匹配中有一些特殊字符，他们有特殊的意义，Lua中的特殊字符如下：

( ) . % + - * ? [ ^ $

'%' 用作特殊字符的转义字符，因此 '%.' 匹配点；'%%' 匹配字符 '%'。转义字符 '%'不仅可以用来转义特殊字符，还可以用于所有的非字母的字符。

模式条目可以是：

• 单个字符类匹配该类别中任意单个字符；
• 单个字符类跟一个 '*'， 将匹配零或多个该类的字符。这个条目总是匹配尽可能长的串；
• 单个字符类跟一个 '+'， 将匹配一或更多个该类的字符。这个条目总是匹配尽可能长的串；
• 单个字符类跟一个 '-'， 将匹配零或更多个该类的字符。 和 '*' 不同，这个条目总是匹配尽可能短的串；
• 单个字符类跟一个 '?'， 将匹配零或一个该类的字符。只要有可能，它会匹配一个；
• %n， 这里的 n 可以从 1 到 9； 这个条目匹配一个等于 n 号捕获物（后面有描述）的子串。
• %bxy， 这里的 x 和 y 是两个明确的字符； 这个条目匹配以 x 开始 y 结束， 且其中 x 和 y 保持 平衡 的字符串。 意思是，如果从左到右读这个字符串，对每次读到一个 x 就 +1 ，读到一个 y 就 -1， 最终结束处的那个 y 是第一个记数到 0 的 y。 举个例子，条目 %b() 可以匹配到括号平衡的表达式。
• %f[set]， 指 边境模式； 这个条目会匹配到一个位于 set 内某个字符之前的一个空串， 且这个位置的前一个字符不属于 set 。 集合 set 的含义如前面所述。 匹配出的那个空串之开始和结束点的计算就看成该处有个字符 '\0' 一样。

模式：

1模式 指一个模式条目的序列。 在模式最前面加上符号 '^'
2
3将锚定从字符串的开始处做匹配。 在模式最后面加上符号 '$'
4
5将使匹配过程锚定到字符串的结尾。 如果 '^' 和 '$'
6
7出现在其它位置，它们均没有特殊含义，只表示自身。

捕获：

1模式可以在内部用小括号括起一个子模式； 这些子模式被称为 捕获物。 
2
3当匹配成功时，由 捕获物 匹配到的字符串中的子串被保存起来用于未来的用途。
4
5捕获物以它们左括号的次序来编号。 例如，对于模式 "(a*(.)%w(%s*))" ， 字符串中匹配到 "a*(.)%w(%s*)" 的部分保存在第一个捕获物中 （因此是编号 1 ）； 由 "." 匹配到的字符是 2 号捕获物， 匹配到 "%s*" 的那部分是 3 号。
6
7作为一个特例，空的捕获 () 将捕获到当前字符串的位置（它是一个数字）。
8
9例如，如果将模式 "()aa()" 作用到字符串 "flaaap" 上，将产生两个捕获物： 3 和 5 。

table（表）

table说明和用法

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

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

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

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

table(表)的构造

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

可以直接初始化数组:

1-- 初始化表
2mytable = {}
3
4-- 指定值
5mytable[1]= "Lua"
6
7--指定值,(下标为字符串时可以使用.来访问和设置)
8mytable.name="liuhao"
9
10-- 移除引用
11mytable = nil
12-- lua 垃圾回收会释放内存

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

1-- 创建一个空的 table
2local tbl1 = {}
3 
4-- 直接初始表
5local tbl2 = {"apple", "pear", "orange", "grape"}

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

1a = {}
2a["key"] = "value"
3key = 10
4a[key] = 22
5a[key] = a[key] + 11
6for k, v in pairs(a) do
7    print(k .. " : " .. v)
8end

脚本执行结果为：

1key : value
210 : 33

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

1local tbl = {"apple", "pear", "orange", "grape"}
2for key, val in pairs(tbl) do
3    print("Key", key)
4end

脚本执行结果为：

1Key    1
2Key    2
3Key    3
4Key    4

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

1a3 = {}
2for i = 1, 10 do
3    a3[i] = i
4end
5a3["key"] = "val"
6print(a3["key"])
7print(a3["none"])

脚本执行结果为：

1val
2nil

当我们为 table a 并设置元素，然后将 a 赋值给 b，则 a 与 b 都指向同一个内存。如果 a 设置为 nil ，则 b 同样能访问 table 的元素。

如果没有指定的变量指向a，Lua的垃圾回收机制会清理相对应的内存。

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

1-- 简单的 table
2mytable = {}
3print("mytable 的类型是 ",type(mytable))
4
5mytable[1]= "Lua"
6mytable["wow"] = "修改前"
7print("mytable 索引为 1 的元素是 ", mytable[1])
8print("mytable 索引为 wow 的元素是 ", mytable["wow"])
9-- talbe的访问,如果下标是字符串的也可以用.来表是
10print("mytable 索引为 wow 的元素是 ", mytable.wow)
11
12-- alternatetable和mytable的是指同一个 table
13alternatetable = mytable
14
15print("alternatetable 索引为 1 的元素是 ", alternatetable[1])
16print("mytable 索引为 wow 的元素是 ", alternatetable["wow"])
17
18alternatetable["wow"] = "修改后"
19
20print("mytable 索引为 wow 的元素是 ", mytable["wow"])
21
22-- 释放变量
23alternatetable = nil
24print("alternatetable 是 ", alternatetable)
25
26-- mytable 仍然可以访问
27print("mytable 索引为 wow 的元素是 ", mytable["wow"])
28
29mytable = nil
30print("mytable 是 ", mytable)

以上代码执行结果为：

1mytable 的类型是     table
2mytable 索引为 1 的元素是     Lua
3mytable 索引为 wow 的元素是     修改前
4alternatetable 索引为 1 的元素是     Lua
5mytable 索引为 wow 的元素是     修改前
6mytable 索引为 wow 的元素是     修改后
7alternatetable 是     nil
8mytable 索引为 wow 的元素是     修改后
9mytable 是     nil

Table 操作

以下列出了 Table 操作常用的方法：

序号

方法 & 用途

1

table.concat (table [, sep [, start [, end]]]): </br> concat是concatenate(连锁, 连接)的缩写. table.concat()函数列出参数中指定table的数组部分从start位置到end位置的所有元素, 元素间以指定的分隔符(sep)隔开。

2

table.insert (table, [pos,] value): </br> 在table的数组部分指定位置(pos)插入值为value的一个元素. pos参数可选, 默认为数组部分末尾.

3

table.maxn (table) </br> 指定table中所有正数key值中最大的key值. 如果不存在key值为正数的元素, 则返回0。(Lua5.2之后该方法已经不存在了)

4

table.remove (table [, pos]) </br> 返回table数组部分位于pos位置的元素. 其后的元素会被前移. pos参数可选, 默认为table长度, 即从最后一个元素删起。

5

table.sort (table [, comp]) </br> 对给定的table进行升序排序。

table操作的方法的实例:

Table 连接

我们可以使用 concat() 方法来连接两个 table:

1fruits = {"banana","orange","apple"}
2-- 返回 table 连接后的字符串
3print("连接后的字符串 ",table.concat(fruits))
4
5-- 指定连接字符
6print("连接后的字符串 ",table.concat(fruits,", "))
7
8-- 指定索引来连接 table
9print("连接后的字符串 ",table.concat(fruits,", ", 2,3))
10
11
12执行以上代码输出结果为：
13
14连接后的字符串     bananaorangeapple
15连接后的字符串     banana, orange, apple
16连接后的字符串     orange, apple

插入和移除

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

1fruits = {"banana","orange","apple"}
2
3-- 在末尾插入
4table.insert(fruits,"mango")
5print("索引为 4 的元素为 ",fruits[4])
6
7-- 在索引为 2 的键处插入
8table.insert(fruits,2,"grapes")
9print("索引为 2 的元素为 ",fruits[2])
10
11print("最后一个元素为 ",fruits[5])
12table.remove(fruits)
13print("移除后最后一个元素为 ",fruits[5])
14
15执行以上代码输出结果为：
16
17索引为 4 的元素为     mango
18索引为 2 的元素为     grapes
19最后一个元素为     mango
20移除后最后一个元素为     nil

Table 排序

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

1fruits = {"banana","orange","apple","grapes"}
2print("排序前")
3for k,v in ipairs(fruits) do
4    print(k,v)
5end
6
7table.sort(fruits)
8print("排序后")
9for k,v in ipairs(fruits) do
10    print(k,v)
11end
12
13执行以上代码输出结果为：
14
15排序前
161    banana
172    orange
183    apple
194    grapes
20排序后
211    apple
222    banana
233    grapes
244    orange

Table 最大值

table.maxn 在 Lua5.2 之后该方法已经不存在了，我们定义了 table_maxn 方法来实现。

以下实例演示了如何获取 table 中的最大值：

1function table_maxn(t)
2  local mn=nil;
3  for k, v in pairs(t) do
4    if(mn==nil) then
5      mn=v
6    end
7    if mn < v then
8      mn = v
9    end
10  end
11  return mn
12end
13tbl = {[1] = 2, [2] = 6, [3] = 34, [26] =5}
14print("tbl 最大值：", table_maxn(tbl))
15print("tbl 长度 ", #tbl)
16
17执行以上代码输出结果为：
18
19tbl 最大值：    34
20tbl 长度     3

注意：

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

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

1function table_leng(t)
2  local leng=0
3  for k, v in pairs(t) do
4    leng=leng+1
5  end
6  return leng;
7end

lua数组

lua数组下表默认从1开始

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

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

一维数组

一维数组是最简单的数组，其逻辑结构是线性表。一维数组可以用for循环出数组中的元素，如下实例：

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

以上代码执行输出结果为：

1nil
2Lua
3Tutorial

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

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

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

1array = {}
2
3for i= -2, 2 do
4   array[i] = i *2
5end
6
7for i = -2,2 do
8   print(array[i])
9end

以上代码执行输出结果为：

1-4
2-2
30
42
54

多维数组

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

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

1-- 初始化数组
2array = {}
3for i=1,3 do
4   array[i] = {}
5      for j=1,3 do
6         array[i][j] = i*j
7      end
8end
9
10-- 访问数组
11for i=1,3 do
12   for j=1,3 do
13      print(array[i][j])
14   end
15end

以上代码执行输出结果为：

11
22
33
42
54
66
73
86
99

不同索引键的三行三列阵列多维数组：

1-- 初始化数组
2array = {}
3maxRows = 3
4maxColumns = 3
5for row=1,maxRows do
6   for col=1,maxColumns do
7      array[row*maxColumns +col] = row*col
8   end
9end
10
11-- 访问数组
12for row=1,maxRows do
13   for col=1,maxColumns do
14      print(array[row*maxColumns +col])
15   end
16end

以上代码执行输出结果为：

11
22
33
42
54
66
73
86
99

以上的实例中，数组设定了指定的索引值，这样可以避免出现 nil 值，有利于节省内存空间。

function（函数）

Lua 函数主要有两种用途：

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

lua 函数特点:

• 多返回值即:可以return多个值
• 可以接受可变数目的参数，和 C 语言类似
• 作为参数传递给函数
• 固定参数和可变参数可以混编,但是固定参数需要再前面

Lua 编程语言函数定义格式如下：

1optional_function_scope function function_name( argument1, argument2, argument3..., argumentn)
2    function_body
3    return result_params_comma_separated
4end

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

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

1function factorial1(n)
2    if n == 0 then
3        return 1
4    else
5        return n * factorial1(n - 1)
6    end
7end
8print(factorial1(5))
9factorial2 = factorial1
10print(factorial2(5))

脚本执行结果为：

1120
2120

匿名函数

function 可以以匿名函数（anonymous function）的方式通过参数传递:

1--创建函数
2function testFun(tab,fun)
3    for k ,v in pairs(tab) do
4        print(fun(k,v));
5    end
6end
7
8--创建一个table
9tab={key1="val1",key2="val2"};
10
11--将table和匿名函数当做参数传入到testFun()函数当中
12testFun(tab,
13function(key,val)--匿名函数
14    return key.."="..val;
15end
16);

脚本执行结果为：

1key1 = val1
2key2 = val2

多返回值

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

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

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

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

以上代码执行结果为：

23    3

可变参数

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

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

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

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

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

以上代码执行结果为：

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

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

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

以上代码执行结果为：

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

几个固定参数加上可变参数，固定参数必须放在变长参数之前:

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

输出结果为：

1runoob
212

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

• select('#', …) 返回可变参数的长度
• select(n, …) 用于访问 n 到 select('#',…) 的参数

调用select时，必须传入一个固定实参selector(选择开关)和一系列变长参数。

如果selector为数字n,那么select返回它的第n个可变实参，否则只能为字符串"#",这样select会返回变长参数的总数。例子代码：

1do  
2    function foo(...)  
3        for i = 1, select('#', ...) do  -->获取参数总数
4            local arg = select(i, ...); -->读取参数
5            print("arg", arg);  
6        end  
7    end  
8  
9    foo(1, 2, 3, 4);  
10end

输出结果为：

1arg    1
2arg    2
3arg    3
4arg    4

thread（线程）

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

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

userdata（自定义类型）

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

lua循环

Lua 语言提供了以下几种循环处理方式：

循环类型

描述

while

在条件为 true 时，让程序重复地执行某些语句。<br/>执行语句前会先检查条件是否为 true。

for

重复执行指定语句，重复次数可在 for 语句中控制。

repeat...until

重复执行循环，直到 指定的条件为真时为止

嵌套循环

可以在循环内嵌套一个或多个循环语句,如:<br/>（while do ... end;for ... do ... end;repeat ... until;）

while循环

1a=10
2while( a < 20 )
3do
4   print("a 的值为:", a)
5   a = a+1
6end

执行以上代码，输出结果如下：

1a 的值为:    10
2a 的值为:    11
3a 的值为:    12
4a 的值为:    13
5a 的值为:    14
6a 的值为:    15
7a 的值为:    16
8a 的值为:    17
9a 的值为:    18
10a 的值为:    19

for循环

Lua语言中 for语句有两大类:

• 数值for循环
• 泛型for循环

数值for循环语句:

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

1-- var 从 exp1 变化到 exp2，每次变化以 exp3 为步长递增 var，并执行一次 "执行体"。exp3 是可选的，如果不指定，默认为1。
2for var=exp1,exp2,exp3 do
3    <执行体>
4end

实例

1for i=1,f(x) do
2    print(i)
3end
4 
5for i=10,1,-1 do
6    print(i)
7end

or的三个表达式在循环开始前一次性求值，以后不再进行求值。比如上面的f(x)只会在循环开始前执行一次，其结果用在后面的循环中。

验证如下:

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

以上实例输出结果为：

1function
21
32
43
54
65
76
87
98
109
1110

可以看到 函数f(x)只在循环开始前执行一次。

泛型for循环(类似PHP中的foreach,可以用来遍历table等类型)

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

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

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

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

循环数组 days：

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

以上实例输出结果为：

1Sunday
2Monday
3Tuesday
4Wednesday
5Thursday
6Friday
7Saturday

repeat...until 循环

Lua 编程语言中 repeat...until 循环语法格式:

1repeat
2   statements
3until( condition )

实例

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

执行以上代码，程序输出结果为：

1a的值为:    10
2a的值为:    11
3a的值为:    12
4a的值为:    13
5a的值为:    14
6a的值为:    15

嵌套循环

Lua 编程语言中 for 循环嵌套语法格式:

1for init,max/min value, increment
2do
3   for init,max/min value, increment
4   do
5      statements
6   end
7   statements
8end

Lua 编程语言中 while 循环嵌套语法格式:

1while(condition)
2do
3   while(condition)
4   do
5      statements
6   end
7   statements
8end

Lua 编程语言中 repeat...until 循环嵌套语法格式:

1repeat
2   statements
3   repeat
4      statements
5   until( condition )
6until( condition )

除了以上同类型循环嵌套外，我们还可以使用不同的循环类型来嵌套，如 for 循环体中嵌套 while 循环。

1j =2
2for i=2,10 do
3   for j=2,(i/j) , 2 do
4      if(not(i%j)) 
5      then
6         break 
7      end
8      if(j > (i/j))then
9         print("i 的值为：",i)
10      end
11   end
12end

以上代码执行结果为：

1i 的值为：    8
2i 的值为：    9
3i 的值为：    10

循环控制语句

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

Lua 支持break语句用以退出当前循环或语句，并开始脚本执行紧接着的语句。

1---以下实例执行 while 循环，在变量 a 小于 20 时输出 a 的值，并在 a 大于 15 时终止执行循环：
2
3--[ 定义变量 --]
4a = 10
5
6--[ while 循环 --]
7while( a < 20 )
8do
9   print("a 的值为:", a)
10   a=a+1
11   if( a > 15)
12   then
13      --[ 使用 break 语句终止循环 --]
14      break
15   end
16end

以上代码执行结果如下：

1a 的值为:    10
2a 的值为:    11
3a 的值为:    12
4a 的值为:    13
5a 的值为:    14
6a 的值为:    15

无限循环

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

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

lua流程控制

控制结构的条件表达式结果可以是任何值，Lua认为false和nil为假，true和非nil为真。

要注意的是Lua中 0 为 true：

1--[ 0 为 true ]
2if(0)
3then
4    print("0 为 true")
5end

以上代码输出结果为：

0 为 true

Lua 提供了以下控制结构语句：

语句

描述

if 语句

if 语句 由一个布尔表达式作为条件判断，其后紧跟其他语句组成。

if...else 语句

if 语句 可以与 else 语句搭配使用, 在 if 条件表达式为 false 时执行 else 语句代码。

if 嵌套语句

你可以在if 或 else if中使用一个或多个 if 或 else if 语句 。

if 语句

在布尔表达式为 true 时会if中的代码块会被执行，在布尔表达式为 false 时，紧跟在 if 语句 end 之后的代码会被执行。

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

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

以下实例用于判断变量 a 的值是否小于 20：

1--[ 定义变量 --]
2a = 10;
3
4--[ 使用 if 语句 --]
5if( a < 20 )
6then
7   --[ if 条件为 true 时打印以下信息 --]
8   print("a 小于 20" );
9end
10print("a 的值为:", a);

以上代码执行结果如下：

1a 小于 20
2a 的值为:    10

if...else 语句

Lua if 语句可以与 else 语句搭配使用, 在 if 条件表达式为 false 时执行 else 语句代码块。

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

在布尔表达式为 true 时会if中的代码块会被执行，在布尔表达式为 false 时，else 的代码块会被执行。

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

以下实例用于判断变量 a 的值：

1--[ 定义变量 --]
2a = 100;
3--[ 检查条件 --]
4if( a < 20 )
5then
6   --[ if 条件为 true 时执行该语句块 --]
7   print("a 小于 20" )
8else
9   --[ if 条件为 false 时执行该语句块 --]
10   print("a 大于 20" )
11end
12print("a 的值为 :", a)

以上代码执行结果如下：

1a 大于 20
2a 的值为 :    100

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

1if( 布尔表达式 1)
2then
3   --[ 在布尔表达式 1 为 true 时执行该语句块 --]
4
5elseif( 布尔表达式 2)
6then
7   --[ 在布尔表达式 2 为 true 时执行该语句块 --]
8
9elseif( 布尔表达式 3)
10then
11   --[ 在布尔表达式 3 为 true 时执行该语句块 --]
12else 
13   --[ 如果以上布尔表达式都不为 true 则执行该语句块 --]
14end

以下实例对变量 a 的值进行判断：

1--[ 定义变量 --]
2a = 100
3
4--[ 检查布尔条件 --]
5if( a == 10 )
6then
7   --[ 如果条件为 true 打印以下信息 --]
8   print("a 的值为 10" )
9elseif( a == 20 )
10then   
11   --[ if else if 条件为 true 时打印以下信息 --]
12   print("a 的值为 20" )
13elseif( a == 30 )
14then
15   --[ if else if condition 条件为 true 时打印以下信息 --]
16   print("a 的值为 30" )
17else
18   --[ 以上条件语句没有一个为 true 时打印以下信息 --]
19   print("没有匹配 a 的值" )
20end
21print("a 的真实值为: ", a )

以上代码执行结果如下：

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

if 嵌套语句

Lua if 语句允许嵌套, 这就意味着你可以在一个 if 或 else if 语句中插入其他的 if 或 else if 语句。

1if( 布尔表达式 1)
2then
3   --[ 布尔表达式 1 为 true 时执行该语句块 --]
4   if(布尔表达式 2)
5   then
6      --[ 布尔表达式 2 为 true 时执行该语句块 --]
7   end
8end

你可以用同样的方式嵌套 else if...else 语句。

以下实例用于判断变量 a 和 b 的值：

1--[ 定义变量 --]
2a = 100;
3b = 200;
4
5--[ 检查条件 --]
6if( a == 100 )
7then
8   --[ if 条件为 true 时执行以下 if 条件判断 --]
9   if( b == 200 )
10   then
11      --[ if 条件为 true 时执行该语句块 --]
12      print("a 的值为 100 b 的值为 200" );
13   end
14end
15print("a 的值为 :", a );
16print("b 的值为 :", b );

以上代码执行结果如下：

1a 的值为 100 b 的值为 200
2a 的值为 :    100
3b 的值为 :    200

lua运算符

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

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

算术运算符

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

操作符

描述

实例

加法

A + B 输出结果 30

-

减法

A - B 输出结果 -10

*

乘法

A * B 输出结果 200

/

除法

B / A w输出结果 2

%

取余

B % A 输出结果 0

^

乘幂

A^2 输出结果 100

-

负号

-A 输出结果v -10

运算符使用案例:

1> a = 21
2> b = 10
3> c = a + b
4> print("Line 1 - c 的值为 ", c )
5Line 1 - c 的值为 	31
6> c = a - b
7> print("Line 2 - c 的值为 ", c )
8Line 2 - c 的值为 	11
9> c = a * b
10> print("Line 3 - c 的值为 ", c )
11Line 3 - c 的值为 	210
12> c = a / b
13> print("Line 4 - c 的值为 ", c )
14Line 4 - c 的值为 	2.1
15> c = a % b
16> print("Line 5 - c 的值为 ", c )
17Line 5 - c 的值为 	1
18> c = a^2
19> print("Line 6 - c 的值为 ", c )
20Line 6 - c 的值为 	441.0
21> c = -a
22> print("Line 7 - c 的值为 ", c )
23Line 7 - c 的值为 	-21
24>

关系运算符

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

操作符

描述

实例

==

等于，检测两个值是否相等，相等返回 true，否则返回 false (A == B) 为 false。

~=

不等于，检测两个值是否相等，相等返回 false，否则返回 true (A ~= B) 为 true。

>

大于，如果左边的值大于右边的值，返回 true，否则返回 false (A > B) 为 false。

<

小于，如果左边的值大于右边的值，返回 false，否则返回 true (A < B) 为 true。

>=

大于等于，如果左边的值大于等于右边的值，返回 true，否则返回 false (A >= B) 返回 false。

<=

小于等于， 如果左边的值小于等于右边的值，返回 true，否则返回 false (A <= B) 返回 true。

关系运算符使用案例:

1a = 21
2b = 10
3
4if( a == b )
5then
6   print("Line 1 - a 等于 b" )
7else
8   print("Line 1 - a 不等于 b" )
9end
10
11if( a ~= b )
12then
13   print("Line 2 - a 不等于 b" )
14else
15   print("Line 2 - a 等于 b" )
16end
17
18if ( a < b )
19then
20   print("Line 3 - a 小于 b" )
21else
22   print("Line 3 - a 大于等于 b" )
23end
24
25if ( a > b ) 
26then
27   print("Line 4 - a 大于 b" )
28else
29   print("Line 5 - a 小于等于 b" )
30end
31
32-- 修改 a 和 b 的值
33a = 5
34b = 20
35if ( a <= b ) 
36then
37   print("Line 5 - a 小于等于  b" )
38end
39
40if ( b >= a ) 
41then
42   print("Line 6 - b 大于等于 a" )
43end

以上程序执行结果为：

1Line 1 - a 不等于 b
2Line 2 - a 不等于 b
3Line 3 - a 大于等于 b
4Line 4 - a 大于 b
5Line 5 - a 小于等于  b
6Line 6 - b 大于等于 a

逻辑运算符

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

操作符

描述

实例

and

逻辑与操作符。 若 A 为 false，则返回 A，否则返回 B。

(A and B) 为 false。

or

逻辑或操作符。 若 A 为 true，则返回 A，否则返回 B。

(A or B) 为 true。

not

逻辑非操作符。与逻辑运算结果相反，如果条件为 true，逻辑非为 false。

not(A and B) 为 true。

逻辑运算符使用案例:

1a = true
2b = true
3
4if ( a and b )
5then
6   print("a and b - 条件为 true" )
7end
8
9if ( a or b )
10then
11   print("a or b - 条件为 true" )
12end
13
14print("---------分割线---------" )
15
16-- 修改 a 和 b 的值
17a = false
18b = true
19
20if ( a and b )
21then
22   print("a and b - 条件为 true" )
23else
24   print("a and b - 条件为 false" )
25end
26
27if ( not( a and b) )
28then
29   print("not( a and b) - 条件为 true" )
30else
31   print("not( a and b) - 条件为 false" )
32end

以上程序执行结果为：

1a and b - 条件为 true
2a or b - 条件为 true
3---------分割线---------
4a and b - 条件为 false
5not( a and b) - 条件为 true

其他运算符

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

操作符

描述

实例

..

连接两个字符串

a..b ，其中 a 为 "Hello " ， b 为 "World", 输出结果为 "Hello World"。

一元运算符，返回字符串或表的长度。

#"Hello" 返回 5

其他运算符使用案例:

1a = "Hello "
2b = "World"
3
4print("连接字符串 a 和 b ", a..b )
5
6print("b 字符串长度 ",#b )
7
8print("字符串 Test 长度 ",#"Test" )
9
10print("菜鸟教程网址长度 ",#"www.runoob.com" )

以上程序执行结果为：

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

运算符优先级

从高到低的顺序：

1^
2not    - (unary)
3*      /
4+      -
5..
6<      >      <=     >=     ~=     ==
7and
8or

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

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

运算符优先级案例:

1a = 20
2b = 10
3c = 15
4d = 5
5
6e = (a + b) * c / d;-- ( 30 * 15 ) / 5
7print("(a + b) * c / d 运算值为  :",e )
8
9e = ((a + b) * c) / d; -- (30 * 15 ) / 5
10print("((a + b) * c) / d 运算值为 :",e )
11
12e = (a + b) * (c / d);-- (30) * (15/5)
13print("(a + b) * (c / d) 运算值为 :",e )
14
15e = a + (b * c) / d;  -- 20 + (150/5)
16print("a + (b * c) / d 运算值为   :",e )