1.定义
Lua 是一种轻量小巧的脚本语言，用标准C语言编写并以源代码形式开放， 其设计目的是为了嵌入应用程序中，从而为应用程序提供灵活的扩展和定制功能。
轻量级
: 它用标准C语言编写并以源代码形式开放，编译后仅仅一百余K，可以很方便的嵌入别的程序里。
可扩展
: Lua提供了非常易于使用的扩展接口和机制：由宿主语言(通常是C或C++)提供这些功能，Lua可以使用它们，就像是本来就内置的功能一样。
2.安装 Lua
window下你可以使用一个叫"SciTE"的IDE环境来执行lua程序，下载地址为：
本站下载地址：
LuaForWindows_v5.1.4-46.exe
Google Code下载地址 :
https://code.google.com/p/luaforwindows/downloads/list
双击安装后即可在该环境下编写 Lua 程序并运行。
你也可以使用 Lua 官方推荐的方法使用 LuaDist：
http://luadist.org/
|
helloword
|
print("hello word")
|
|
注释
|
单行注释
--
多行注释
--[[
多行注释
多行注释
--]]
|
|
全局变量
|
在默认情况下，变量总是认为是全局的。
全局变量不需要声明，给一个变量赋值后即创建了这个全局变量，访问一个没有初始化的全局变量也不会出错，只不过得到的结果是：nil。
删除全局变量
b=10;
print(b);
b=nil;
print(b);
|
3.Lua 数据类型
Lua 是动态类型语言，变量不要类型定义,只需要为变量赋值。 值可以存储在变量中，作为参数传递或结果返回。
Lua 中有 8 个基本类型分别为：nil、boolean、number、string、userdata、function、thread 和 table。
|
数据类型
|
描述
|
|
nil
|
这个最简单，只有值nil属于该类，表示一个无效值（在条件表达式中相当于false）。
nil 类型表示一种没有任何有效值，它只有一个值 -- nil，例如打印一个没有赋值的变量，便会输出一个 nil 值：
对于全局变量和 table，nil 还有一个"删除"作用，给全局变量或者 table 表里的变量赋一个 nil 值，等同于把它们删掉，执行下面代码就知：
|
|
boolean
|
包含两个值：false和true。
boolean 类型只有两个可选值：true（真） 和 false（假），Lua 把 false 和 nil 看作是 false，其他的都为 true，数字 0 也是 true:
|
|
number
|
表示双精度类型的实浮点数
Lua 默认只有一种 number 类型 -- double（双精度）类型（默认类型可以修改 luaconf.h 里的定义），以下几种写法都被看作是 number 类型：
|
|
string
|
字符串由一对双引号或单引号来表示
1.在对一个数字字符串上进行算术操作时，Lua 会尝试将这个数字字符串转成一个数字:
print("2"+10);
结果12
2.两个字符串相加..
ocal x="aaaa".."bbbbb";
print(x);
两个字符串相加，结果aaabbbb
eg:
--字符串和数字相加，尝试转化为数字相
local sn="2"+10;
print(sn);
--字符串相加
local x="aaaa".."bbbb";
print(x);
--字符串长度
local len=#x;
print(len);
|
|
function
|
由 C 或 Lua 编写的函数
|
|
userdata
|
表示任意存储在变量中的C数据结构
|
|
thread
|
表示执行的独立线路，用于执行协同程序
|
|
table
|
Lua 中的表（table）其实是一个"关联数组"（associative arrays），数组的索引可以是数字、字符串或表类型。在 Lua 里，table 的创建是通过"构造表达式"来完成，最简单构造表达式是{}，用来创建一个空表。
|
|
eg
|
print(type("Hello world")) --> string
print(type(10.4*3)) --> number
print(type(print)) --> function
print(type(type)) --> function
print(type(true)) --> boolean
print(type(nil)) --> nil
print(type(type(X))) --> string
|
table（表）详解
| 定义 |
在 Lua 里，table 的创建是通过"构造表达式"来完成，最简单构造表达式是{}，用来创建一个空表。也可以在表里添加一些数据，直接初始化表，table的定义接近javascript:
|
|
eg1
|
-- 创建一个空的 table
local tbl1 = {}
-- 直接初始表
local tbl2 = {"apple", "pear", "orange", "grape"}
for k, v in pairs(tbl2) do
print(k .. " : " .. v)
end
|
|
eg2
|
Lua 中的表（table）其实是一个"关联数组"（associative arrays），数组的索引可以是数字或者是字符串。
eg：
local a={};
a["k1"]=20;
a[10]=100;
a[10]=a[10]+1;
for k,v in pairs(a) do
print(k .. ":" .. v)
end
结果
|
|
eg3
|
不同于其他语言的数组把 0 作为数组的初始索引，在 Lua 里表的默认初始索引一般以 1 开始。
-- table_test2.lua 脚本文件
local
tbl
=
{
"apple"
,
"pear"
,
"orange"
,
"grape"
}
for
key
,
val
in
pairs
(
tbl
)
do
print
(
"Key"
,
key
)
end
结果
|
|
eg4
|
table 不会固定长度大小，有新数据添加时 table 长度会自动增长，没初始的 table 都是 nil。
local a={};
for i=1,10 do
a[i]=i;
end
a["dg"]="dage";
print(a["dg"]);
print(a[12]);
结果：
|
function（函数）简介
|
定图
|
在 Lua 中，函数是被看作是"第一类值（First-Class Value）"，函数可以存在变量里:
|
|
eg1
|
function xx(a)
return 10*a;
end
print (xx(5))
--函数可以赋予另外一个变量
factorial2 = xx;
print(factorial2(5))
|
|
eg2
|
function 可以以匿名函数（anonymous function）的方式通过参数传递:
|
|
|
function testFun(tab,fun)
for k ,v in pairs(tab) do
print(fun(k,v));
end
end
tab={key1="val1",key2="val2"};
testFun(tab,
function(key,val)--匿名函数
return key.."="..val;
end
);
|
|
|
|
4.Lua 变量
|
定义
|
变量在使用前，必须在代码中进行声明，即创建该变量。
编译程序执行代码之前编译器需要知道如何给语句变量开辟存储区，用于存储变量的值。
Lua 变量有三种类型：全局变量、局部变量、表中的域。
Lua 中的变量全是全局变量，那怕是语句块或是函数里，除非用 local 显式声明为局部变量。
局部变量的作用域为从声明位置开始到所在语句块结束。
变量的默认值均为 nil。
|
|
eg1
|
-- 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 6
end
print
(
a
,
b
)
--> 5 6
|
|
变量赋值
|
1.赋值是改变一个变量的值和改变表域的最基本的方法。
a
=
"hello"
..
"world"
t
.
n
=
t
.
n
+
1
2. Lua 可以对多个变量同时赋值，变量列表和值列表的各个元素用逗号分开，赋值语句右边的值会依次赋给左边的变量。
a
,
b
=
10
,
2
*
x
<-->
a
=
10
;
b
=
2
*
x
当变量个数和值的个数不一致时，Lua会一直以变量个数为基础采取以下策略：
a
.
变量个数
>
值的个数
按变量个数补足
nil
b
.
变量个数
<
值的个数
多余的值会被忽略
a
,
b
,
c
=
0
,
1
print
(
a
,
b
,
c
)
--> 0 1 nil
a
,
b
=
a
+
1
,
b
+
1
,
b
+
2
-- value of b+2 is ignored
print
(
a
,
b
)
--> 1 2
a
,
b
,
c
=
0
print
(
a
,
b
,
c
)
--> 0 nil nil
|
|
|
|
5.Lua 循环
|
循环类型
|
描述
|
|
在条件为 true 时，让程序重复地执行某些语句。执行语句前会先检查条件是否为 true。
| |
|
重复执行指定语句，重复次数可在 for 语句中控制。
| |
|
重复执行循环，直到 指定的条件为真时为止
| |
|
可以在循环内嵌套一个或多个循环语句（while do ... end;for ... do ... end;repeat ... until;）
|
循环语法详解
|
while
|
while
(
condition
)
do
statements
end
|
|
while eg:
|
local i=10
while (i<20) do
i=i+1;
print(i);
end
|
|
for
|
for
var
=
exp1
,
exp2
,
exp3
do
<执行体>
end
ar 从 exp1 变化到 exp2，每次变化以 exp3 为步长递增 var，并执行一次
"执行体"
。exp3 是可选的，如果不指定，默认为1。
|
|
for eg:
|
for i=10,1,-1 do
print(i)
end
|
泛型for循环 |
泛型 for 循环通过一个迭代器函数来遍历所有值，类似 java 中的 foreach 语句。
Lua 编程语言中泛型 for 循环语法格式:
|
|
|
a = {"one", "two", "three"}
for i, v in
ipairs
(a) do
print(i, v)
end
days = {"Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"}
for i,v in
ipairs
(days) do
print(v)
end
|
|
repeat
|
repeat
statements
until
(
condition
)
我们注意到循环条件判断语句（condition）在循环体末尾部分，所以在条件进行判断前循环体都会执行一次。
如果条件判断语句（condition）为 false，循环会重新开始执行，直到条件判断语句（condition）为 true 才会停止执行。
Lua repeat...until 循环流程图如下：
|
|
eg
|
--[ 变量定义 --]
a
=
10
--[ 执行循环 --]
repeat
print
(
"a的值为:"
,
a
)
a
=
a
+
1
until
(
a
>
15
)
|
循环控制
| beak |
退出循环
|
|
eg
|
for i=1,10 do
if i>5 then
break
end
print(i);
end
|
|
|
|
6.条件控制
Lua 提供了以下控制结构语句：
|
语句
|
描述
|
|
if 语句
由一个布尔表达式作为条件判断，其后紧跟其他语句组成。
| |
|
if 语句
可以与
else 语句
搭配使用, 在 if 条件表达式为 false 时执行 else 语句代码。
| |
|
你可以在
if
或
else if
中使用一个或多个
if
或
else if
语句 。
|
注意的是Lua中 0 为 true：
实例
--[ 0 为 true ]
if
(
0
)
then
print
(
"0 为 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 的值" )
end
print("a 的真实值为: ", a )
|
|
--[ 定义变量 --]
a
=
100
;
b
=
200
;
--[ 检查条件 --]
if
(
a
==
100
)
then
--[ if 条件为 true 时执行以下 if 条件判断 --]
if
(
b
==
200
)
then
--[ if 条件为 true 时执行该语句块 --]
print
(
"a 的值为 100 b 的值为 200"
)
;
end
end
print
(
"a 的值为 :"
,
a
)
;
print
(
"b 的值为 :"
,
b
)
;
|
7.函数详解
在Lua中，函数是对语句和表达式进行抽象的主要方法。既可以用来处理一些特殊的工作，也可以用来计算一些值。
Lua 提供了许多的内建函数，你可以很方便的在程序中调用它们，如print()函数可以将传入的参数打印在控制台上。
Lua 函数主要有两种用途：
1.完成指定的任务，这种情况下函数作为调用语句使用；
2.计算并返回值，这种情况下函数作为赋值语句的表达式使用。
函数定义
Lua 编程语言函数定义格式如下：
optional_function_scope
function
function_name
(
argument1
,
argument2
,
argument3
...,
argumentn
)
function_body
return
result_params_comma_separated
end
解析：
optional_function_scope:
该参数是可选的制定函数是全局函数还是局部函数，未设置该参数默认为全局函数，如果你需要设置函数为局部函数需要使用关键字
local
。
function_name:
指定函数名称。
argument1, argument2, argument3..., argumentn:
函数参数，多个参数以逗号隔开，函数也可以不带参数。
function_body:
函数体，函数中需要执行的代码语句块。
result_params_comma_separated:
函数返回值，Lua语言函数可以返回多个值，每个值以逗号隔开。
|
eg1
|
--[[ 函数返回两个值的最大值 --]]
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))
|
|
函数传递
|
Lua 中我们可以将函数作为参数传递给函数，如下实例
|
|
eg2
|
myprint = function(param)
print("这是打印函数 - ##",param,"##")
end
function add(num1,num2,functionPrint)
result = num1 + num2
-- 调用传递的函数参数
functionPrint(result)
end
myprint(10)
-- myprint 函数作为参数传递
add(2,5,myprint)
|
多返回值 |
Lua函数可以返回多个结果值，比如string.find，其返回匹配串"开始和结束的下标"（如果不存在匹配串返回nil）。
|
|
eg2
|
print(s,e)
//打印 5，10
|
|
|
--找出最大值和和期索引
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, mi
end
max,max_index=
maximum
({8,10,23,12,5})
print(max,max_index)
|
可变参数 |
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/#arg
end
print("平均值为",average(10,5,3,4,5,6))
|
8.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 输出结果 -10
|
关系运算符
下表列出了 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
|
逻辑运算符
下表列出了 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。
|
其他运算符
下表列出了 Lua 语言中的连接运算符与计算表或字符串长度的运算符：
|
操作符
|
描述
|
实例
|
|
..
|
连接两个字符串
|
a..b ，其中 a 为 "Hello " ， b 为 "World", 输出结果为 "Hello World"。
|
|
#
|
一元运算符，返回字符串或表的长度。
|
#"Hello" 返回 5
|
9.字符串
字符串或串(String)是由数字、字母、下划线组成的一串字符。
Lua 语言中字符串可以使用以下三种方式来表示：
单引号间的一串字符。
双引号间的一串字符。
[[和]]间的一串字符。
以上三种方式的字符串实例如下：
实例
string1
=
"Lua"
print
(
"
\"
字符串 1 是
\"
"
,
string1
)
print
(
"字符串 2 是"
,
string2
)
string3
=
[["Lua 教程"]]
print
(
"字符串 3 是"
,
string3
)
以上代码执行输出结果为：
"字符串 1 是"
Lua
字符串
2
是
runoob
.
com
字符串
3
是
"Lua 教程"
转义字符用于表示不能直接显示的字符，比如后退键，回车键，等。如在字符串转换双引号可以使用 "\""。
所有的转义字符和所对应的意义：
|
转义字符
|
意义
|
ASCII码值（十进制）
|
|
\a
|
响铃(BEL)
|
007
|
|
\b
|
退格(BS) ，将当前位置移到前一列
|
008
|
|
\f
|
换页(FF)，将当前位置移到下页开头
|
012
|
|
\n
|
换行(LF) ，将当前位置移到下一行开头
|
010
|
|
\r
|
回车(CR) ，将当前位置移到本行开头
|
013
|
|
\t
|
水平制表(HT) （跳到下一个TAB位置）
|
009
|
|
\v
|
垂直制表(VT)
|
011
|
|
\\
|
代表一个反斜线字符''\'
|
092
|
|
\'
|
代表一个单引号（撇号）字符
|
039
|
|
\"
|
代表一个双引号字符
|
034
|
|
\0
|
空字符(NULL)
|
000
|
|
\ddd
|
1到3位八进制数所代表的任意字符
|
三位八进制
|
|
\xhh
|
1到2位十六进制所代表的任意字符
|
二位十六进制
|
字符串操作
Lua 提供了很多的方法来支持字符串的操作：
|
序号
|
方法 & 用途
|
|
1
|
string.upper(argument):
字符串全部转为大写字母。
|
|
2
|
string.lower(argument):
字符串全部转为小写字母。
|
|
3
|
string.gsub(mainString,findString,replaceString,num)
在字符串中替换。
mainString 为要操作的字符串， findString 为被替换的字符，replaceString 要替换的字符，num 替换次数（可以忽略，则全部替换），如：
>
string
.
gsub
(
"aaaa"
,
"a"
,
"z"
,
3
);
zzza
3
|
|
4
|
string.find (str, substr, [init, [end]])
在一个指定的目标字符串中搜索指定的内容(第三个参数为索引),返回其具体位置。不存在则返回 nil。
>
string
.
find
(
"Hello Lua user"
,
"Lua"
,
1
)
7
9
|
|
5
|
string.reverse(arg)
字符串反转
>
string
.
reverse
(
"Lua"
)
auL
|
|
6
|
string.format(...)
返回一个类似printf的格式化字符串
>
string
.
format
(
"the value is:%d"
,
4
)
the value
is
:
4
|
|
7
|
string.char(arg) 和 string.byte(arg[,int])
char 将整型数字转成字符并连接， byte 转换字符为整数值(可以指定某个字符，默认第一个字符)。
>
string
.
char
(
97
,
98
,
99
,
100
)
abcd
>
string
.
byte
(
"ABCD"
,
4
)
68
>
string
.
byte
(
"ABCD"
)
65
>
|
|
8
|
string.len(arg)
计算字符串长度。
string
.
len
(
"abc"
)
3
|
|
9
|
string.rep(string, n)
返回字符串string的n个拷贝
>
string
.
rep
(
"abcd"
,
2
)
abcdabcd
|
|
10
|
..
链接两个字符串
www
.
runoob
.
com
|
|
11
|
string.gmatch(str, pattern)
回一个迭代器函数，每一次调用这个函数，返回一个在字符串 str 找到的下一个符合 pattern 描述的子串。如果参数 pattern 描述的字符串没有找到，迭代函数返回nil。
>
for
word
in
string
.
gmatch
(
"Hello Lua user"
,
"%a+"
)
do
print
(
word
)
end
Hello
Lua
user
|
|
12
|
string.match(str, pattern, init)
string.match()只寻找源字串str中的第一个配对. 参数init可选, 指定搜寻过程的起点, 默认为1。
在成功配对时, 函数将返回配对表达式中的所有捕获结果; 如果没有设置捕获标记, 则返回整个配对字符串. 当没有成功的配对时, 返回nil。
>
=
string
.
match
(
"I have 2 questions for you."
,
"%d+ %a+"
)
2
questions
>
=
string
.
format
(
"%d, %q"
,
string
.
match
(
"I have 2 questions for you."
,
"(%d+) (%a+)"
))
2
,
"questions"
|
|
|
|
字符串大小写转换
以下实例演示了如何对字符串大小写进行转换：
实例
string1
=
"Lua"
;
print
(
string.upper
(
string1
)
)
print
(
string.lower
(
string1
)
)
以上代码执行结果为：
LUA
lua
字符串查找与反转
以下实例演示了如何对字符串进行查找与反转操作：
实例
string
=
"Lua Tutorial"
-- 查找字符串
print
(
string.find
(
string
,
"Tutorial"
)
)
reversedString
=
string
.
reverse
(
string
)
print
(
"新字符串为"
,
reversedString
)
以上代码执行结果为：
5
12
新字符串为
lairotuT auL
字符串格式化
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位.
实例
string1
=
"Lua"
string2
=
"Tutorial"
number1
=
10
number2
=
20
-- 基本字符串格式化
print
(
string.format
(
"基本格式化 %s %s"
,
string1
,
string2
)
)
-- 日期格式化
date
=
2
;
month
=
1
;
year
=
2014
print
(
string.format
(
"日期格式化 %02d/%02d/%03d"
,
date
,
month
,
year
)
)
-- 十进制格式化
print
(
string.format
(
"%.4f"
,
1
/
3
)
)
以上代码执行结果为：
基本格式化
Lua
Tutorial
日期格式化
02
/
01
/
2014
0.3333
其他例子：
实例
string.format
(
"%c"
,
83
)
-- 输出S
string.format
(
"%+d"
,
17.0
)
-- 输出+17
string.format
(
"%05d"
,
17
)
-- 输出00017
string.format
(
"%o"
,
17
)
-- 输出21
string.format
(
"%u"
,
3.14
)
-- 输出3
string.format
(
"%x"
,
13
)
-- 输出d
string.format
(
"%X"
,
13
)
-- 输出D
string.format
(
"%e"
,
1000
)
-- 输出1.000000e+03
string.format
(
"%E"
,
1000
)
-- 输出1.000000E+03
string.format
(
"%6.3f"
,
13
)
-- 输出13.000
string.format
(
"%q"
,
"One
\n
Two"
)
-- 输出"One\
-- Two"
string.format
(
"%s"
,
"monkey"
)
-- 输出monkey
string.format
(
"%10s"
,
"monkey"
)
-- 输出 monkey
string.format
(
"%5.3s"
,
"monkey"
)
-- 输出 mon
字符与整数相互转换
以下实例演示了字符与整数相互转换：
实例
-- 字符转换
-- 转换第一个字符
print
(
string.byte
(
"Lua"
)
)
-- 转换第三个字符
print
(
string.byte
(
"Lua"
,
3
)
)
-- 转换末尾第一个字符
print
(
string.byte
(
"Lua"
,-
1
)
)
-- 第二个字符
print
(
string.byte
(
"Lua"
,
2
)
)
-- 转换末尾第二个字符
print
(
string.byte
(
"Lua"
,-
2
)
)
-- 整数 ASCII 码转换为字符
print
(
string.char
(
97
)
)
以上代码执行结果为：
76
97
97
117
117
a
其他常用函数
以下实例演示了其他字符串操作，如计算字符串长度，字符串连接，字符串复制等：
实例
string1
=
"www."
string2
=
"runoob"
string3
=
".com"
-- 使用 .. 进行字符串连接
print
(
"连接字符串"
,
string1
..
string2
..
string3
)
-- 字符串长度
print
(
"字符串长度 "
,
string.len
(
string2
)
)
-- 字符串复制 2 次
repeatedString
=
string.rep
(
string2
,
2
)
print
(
repeatedString
)
以上代码执行结果为：
连接字符串
www
.
runoob
.
com
字符串长度
6
runoobrunoob
匹配模式
Lua 中的匹配模式直接用常规的字符串来描述。 它用于模式匹配函数
string.find, string.gmatch, string.gsub, string.match
。
你还可以在模式串中使用字符类。
字符类指可以匹配一个特定字符集合内任何字符的模式项。比如，字符类
%d
匹配任意数字。所以你可以使用模式串
%d%d/%d%d/%d%d%d%d
搜索
dd/mm/yyyy
格式的日期：
实例
s
=
"Deadline is 30/05/1999, firm"
date
=
"%d%d/%d%d/%d%d%d%d"
print
(
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'非字母的字符:
>
print
(
string
.
gsub
(
"hello, up-down!"
,
"%A"
,
"."
))
hello
..
up
.
down
.
4
数字4不是字符串结果的一部分，他是gsub返回的第二个结果，代表发生替换的次数。
在模式匹配中有一些特殊字符，他们有特殊的意义，Lua中的特殊字符如下：
(
)
.
%
+
-
*
?
[
^
$
'%' 用作特殊字符的转义字符，因此 '%.' 匹配点；'%%' 匹配字符 '%'。转义字符 '%'不仅可以用来转义特殊字符，还可以用于所有的非字母的字符。
模式条目可以是：
单个字符类匹配该类别中任意单个字符；
单个字符类跟一个 '*'， 将匹配零或多个该类的字符。 这个条目总是匹配尽可能长的串；
单个字符类跟一个 '+'， 将匹配一或更多个该类的字符。 这个条目总是匹配尽可能长的串；
单个字符类跟一个 '-'， 将匹配零或更多个该类的字符。 和 '*' 不同， 这个条目总是匹配尽可能短的串；
单个字符类跟一个 '?'， 将匹配零或一个该类的字符。 只要有可能，它会匹配一个；
%
n， 这里的
n 可以从 1 到 9； 这个条目匹配一个等于
n 号捕获物（后面有描述）的子串。
%b
xy， 这里的
x 和
y 是两个明确的字符； 这个条目匹配以
x 开始
y 结束， 且其中
x 和
y 保持
平衡 的字符串。 意思是，如果从左到右读这个字符串，对每次读到一个
x 就
+1 ，读到一个
y 就
-1， 最终结束处的那个
y 是第一个记数到 0 的
y。 举个例子，条目 %b() 可以匹配到括号平衡的表达式。
%f[
set]， 指
边境模式； 这个条目会匹配到一个位于
set 内某个字符之前的一个空串， 且这个位置的前一个字符不属于
set 。 集合
set 的含义如前面所述。 匹配出的那个空串之开始和结束点的计算就看成该处有个字符 '\0' 一样。
模式：
模式
指一个模式条目的序列。 在模式最前面加上符号 '
^
' 将锚定从字符串的开始处做匹配。 在模式最后面加上符号 '
$
' 将使匹配过程锚定到字符串的结尾。 如果 '
^
' 和 '
$
' 出现在其它位置，它们均没有特殊含义，只表示自身。
捕获：
模式可以在内部用小括号括起一个子模式； 这些子模式被称为
捕获物
。 当匹配成功时，由
捕获物
匹配到的字符串中的子串被保存起来用于未来的用途。 捕获物以它们左括号的次序来编号。 例如，对于模式
"(a*(.)%w(%s*))"
， 字符串中匹配到
"a*(.)%w(%s*)"
的部分保存在第一个捕获物中 （因此是编号 1 ）； 由 "
.
" 匹配到的字符是 2 号捕获物， 匹配到 "
%s*
" 的那部分是 3 号。
作为一个特例，空的捕获
()
将捕获到当前字符串的位置（它是一个数字）。 例如，如果将模式
"()aa()"
作用到字符串
"flaaap"
上，将产生两个捕获物： 3 和 5 。
10.Lua 数组
数组，就是相同数据类型的元素按一定顺序排列的集合，可以是一维数组和多维数组。
Lua 数组的索引键值可以使用整数表示，数组的大小不是固定的。
一维数组
|
array
=
{
"Lua"
,
"Tutorial"
}
for
i
=
0
,
2
do
print
(
array
[
i
]
)
end
以上代码执行输出结果为：
nil
Lua
Tutorial
|
多维数组
|
-- 初始化数组
array
=
{
}
for
i
=
1
,
3
do
array
[
i
]
=
{
}
for
j
=
1
,
3
do
array
[
i
]
[
j
]
=
i
*
j
end
end
-- 访问数组
for
i
=
1
,
3
do
for
j
=
1
,
3
do
print
(
array
[
i
]
[
j
]
)
end
end
|
11.Lua table(表)
able 是 Lua 的一种数据结构用来帮助我们创建不同的数据类型，如：数组、字典等。
Lua table 使用关联型数组，你可以用任意类型的值来作数组的索引，但这个值不能是 nil。
Lua table 是不固定大小的，你可以根据自己需要进行扩容。
Lua也是通过table来解决模块（module）、包（package）和对象（Object）的。 例如string.format表示使用"format"来索引table string。
|
-- 初始化表
mytable
=
{
}
-- 指定值
mytable
[
1
]
=
"Lua"
-- 移除引用
mytable
=
nil
-- lua 垃圾回收会释放内存
|
当我们为 table a 并设置元素，然后将 a 赋值给 b，则 a 与 b 都指向同一个内存。如果 a 设置为 nil ，则 b 同样能访问 table 的元素。如果没有指定的变量指向a，Lua的垃圾回收机制会清理相对应的内存。
以下实例演示了以上的描述情况：
|
-- 简单的 table
mytable
=
{
}
print
(
"mytable 的类型是 "
,
type
(
mytable
)
)
mytable
[
1
]
=
"Lua"
mytable
[
"wow"
]
=
"修改前"
print
(
"mytable 索引为 1 的元素是 "
,
mytable
[
1
]
)
print
(
"mytable 索引为 wow 的元素是 "
,
mytable
[
"wow"
]
)
-- alternatetable和mytable的是指同一个 table
alternatetable
=
mytable
print
(
"alternatetable 索引为 1 的元素是 "
,
alternatetable
[
1
]
)
print
(
"mytable 索引为 wow 的元素是 "
,
alternatetable
[
"wow"
]
)
alternatetable
[
"wow"
]
=
"修改后"
print
(
"mytable 索引为 wow 的元素是 "
,
mytable
[
"wow"
]
)
-- 释放变量
alternatetable
=
nil
print
(
"alternatetable 是 "
,
alternatetable
)
-- mytable 仍然可以访问
print
(
"mytable 索引为 wow 的元素是 "
,
mytable
[
"wow"
]
)
mytable
=
nil
print
(
"mytable 是 "
,
mytable
)
|
|
执行结果：
mytable
的类型是
table
mytable
索引为
1
的元素是
Lua
mytable
索引为
wow
的元素是
修改前
alternatetable
索引为
1
的元素是
Lua
mytable
索引为
wow
的元素是
修改前
mytable
索引为
wow
的元素是
修改后
alternatetable
是
nil
mytable
索引为
wow
的元素是
修改后
mytable
是
nil
|
Table 操作
以下列出了 Table 操作常用的方法：
|
序号
|
方法 & 用途
|
|
1
|
table.concat (table [, sep [, start [, end]]]):
concat是concatenate(连锁, 连接)的缩写. table.concat()函数列出参数中指定table的数组部分从start位置到end位置的所有元素, 元素间以指定的分隔符(sep)隔开。
|
|
2
|
table.insert (table, [pos,] value):
在table的数组部分指定位置(pos)插入值为value的一个元素. pos参数可选, 默认为数组部分末尾.
|
|
3
|
table.maxn (table)
指定table中所有正数key值中最大的key值. 如果不存在key值为正数的元素, 则返回0。(
Lua5.2之后该方法已经不存在了,本文使用了自定义函数实现
)
|
|
4
|
table.remove (table [, pos])
返回table数组部分位于pos位置的元素. 其后的元素会被前移. pos参数可选, 默认为table长度, 即从最后一个元素删起。
|
|
5
|
table.sort (table [, comp])
对给定的table进行升序排序。
|
接下来我们来看下这几个方法的实例。
Table 连接
我们可以使用 concat() 输出一个列表中元素连接成的字符串:
实例
fruits
=
{
"banana"
,
"orange"
,
"apple"
}
-- 返回 table 连接后的字符串
print
(
"连接后的字符串 "
,
table.concat
(
fruits
)
)
-- 指定连接字符
print
(
"连接后的字符串 "
,
table.concat
(
fruits
,
", "
)
)
-- 指定索引来连接 table
print
(
"连接后的字符串 "
,
table.concat
(
fruits
,
", "
,
2
,
3
)
)
执行以上代码输出结果为：
连接后的字符串
bananaorangeapple
连接后的字符串
banana
,
orange
,
apple
连接后的字符串
orange
,
apple
插入和移除
以下实例演示了 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
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
banana
2
orange
3
apple
4
grapes
排序后
1
apple
2
banana
3
grapes
4
orange
Table 最大值
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
mn
end
tbl
=
{
[
1
]
=
2
,
[
2
]
=
6
,
[
3
]
=
34
,
[
26
]
=
5
}
print
(
"tbl 最大值："
,
table_maxn
(
tbl
)
)
print
(
"tbl 长度 "
,
#
tbl
)
执行以上代码输出结果为：
tbl
最大值：
34
tbl
长度
3
注意：当我们获取 table 的长度的时候无论是使用 # 还是 table.getn 其都会在索引中断的地方停止计数，而导致无法正确取得 table 的长度。可以使用以下方法来代替：function table_leng ( t )local leng = 0for k , v in pairs ( t ) doleng = leng + 1endreturn leng ; end
扫一扫
1685
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
