1.可扩展性，可通过Lua代码或者C代码扩展
& 简单：简单
& 高效率：平均效率最高
& &与平台无关：不是通过使用条件编译实现平台无关，而是完全使用ANSI C。所以只要有ANSI C编译器就可以编译并使用Lua。
2.Lua大部分强大的功能来自于它的类库。可通过新类型和函数来扩展其功能。动态类型检查最大限度允许多台出现，并自动简化调用内存管理的额接口，因为
& 这样不需要关心谁来分配内存谁来释放内存， 也不必担心数据溢出。高级函数和匿名函数均可以接受高级参数，使函数更为通用。
3.Lua的使用者
& a.嵌入在应用程序，比如CGILua(搭建动态网页），LuaOrb（访问COBRA对象）。这些类型用Lua-API注册新函数，创建新类型。通过配置 Lua就可以
& & 改变应用宿主语言的行为。
& b.作为一种独立运行的语言，Lua 也是很有用的，主要用于文本处理或者只运
& & 行一次的小程序。这种应用 Lua 主要使用它的标准库来实现，标准库提供模式匹配和其
& & 它一些字串处理的功能。我们可以这样认为：Lua 是文本处理领域的嵌入式语言。
& c.还有一些使用者使用其他语言开发，把 Lua 当作库使用。这些人大多使用 C语言开发，但使用 Lua建立简单灵活易于使用的接口。
如果你真得想学一门语言，参考手册是必备的。本书和 Lua 参考手册互为补充，手
册仅仅描述语言本身，因此他既不会告诉你语言的数据结构也不会举例说明，但手册是
Lua 的权威性文档，http://www.lua.org可以得到手册的内容。&
-- Lua 用户社区，提供了一些第三方包和文档&
http://lua-users.org
-- 本书的更新勘误表，代码和例子&
http://www.inf.puc-rio.br/~roberto/book/
另外本书仅针对 Lua 5.0，如果你的版本不同，请查阅 Lua 手册或者比较版本间的差
Chunk 是一系列语句，Lua 执行的每一块语句，比如一个文件或者交互模式下的每一行都是一个 Chunk。&
每个语句结尾的分号（;）是可选的，但如果同一行有多个语句最好用；分开&
一个 Chunk 可以是一个语句，也可以是一系列语句的组合，还可以是函数，Chunk
可以很大，在 Lua 中几个 MByte的Chunk 是很常见的。
你还可以以交互模式运行 Lua，不带参数运行 Lua:&
你键入的每个命令（比如：&Hello World&）在你键入回车之后立即被执行，键入文
件结束符可以退出交互模式（Ctrl-D in Unix, Ctrl-Z in DOS/Windows），或者调用 OS库
的 os.exit()函数也可以退出。
在交互模式下，Lua 通常把每一个行当作一个 Chunk，但如果 Lua 一行不是一个完
整的 Chunk时，他会等待继续输入直到得到一个完整的 Chunk.在 Lua 等待续行时，显示
不同的提示符（一般是&&）.&
可以通过指定参数让 Lua 执行一系列 Chunk。例如：假定一个文件 a 内有单个语句
x=1；另一个文件 b 有语句 print(x)&
prompt& lua -la -lb&
命令首先在一个 Chunk内先运行 a然后运行 b。（注意：-l 选项会调用 require，将会
在指定的目录下搜索文件，如果环境变量没有设好，上面的命令可能不能正确运行。
-i 选项要求 Lua 运行指定Chunk 后进入交互模式.&
prompt& lua -i -la -lb&
将在一个 Chunk 内先运行 a 然后运行 b，最后直接进入交互模式。
另一个连接外部 Chunk 的方式是使用 dofile 函数，dofile 函数加载文件并执行它.假
设有一个文件: &
-- file 'lib1.lua'&
function norm (x, y)&
& local n2 = x^2 + y^2&
& return math.sqrt(n2)&
function twice (x)&
& return 2*x&
在交互模式下：&
& dofile(&lib1.lua&) & -- load your library&
& n = norm(3.4, 1.0)&
& print(twice(n)) & & --& 7.7&
-i 和 dofile 在调试或者测试 Lua 代码时是很方便的。&
1.2全局变量
全局变量不需要声明，给一个变量赋值后即创建了这个全局变量，访问一个没有初
始化的全局变量也不会出错，只不过得到的结果是：nil.&
如果你想删除一个全局变量，只需要将变量负值为 nil&
print(b) & --& nil&
这样变量 b 就好像从没被使用过一样.换句话说, &当且仅当一个变量不等于 nil 时，
这个变量存在。&
1.3 & &词法约定 &&
标示符：字母(letter)或者下划线开头的字母、下划线、数字序列.最好不要使用下划
线加大写字母的标示符，因为 Lua的保留字也是这样的。Lua 中，letter的含义是依赖于
本地环境的。&
保留字：以下字符为 Lua 的保留字，不能当作标识符。&
and & & break & do & &else & elseif&
end & & false & for & & function &if&
in & &local & nil & & not & & or&
repeat & return & then & true & until&
注意：Lua 是大小写敏感的.&
注释：单行注释:--&
多行注释：--[[ & &--]]&
print(10) & -- no action (comment)&
1.4 & &命令行方式 &&
-e：直接将命令传入 Lua&
prompt& lua -e &print(math.sin(12))& &--& -0.43&
-l：加载一个文件.&
-i：进入交互模式.&
_PROMPT 内置变量作为交互模式的提示符&
prompt& lua -i -e &_PROMPT=' lua& '&&
Lua 的运行过程，在运行参数之前，Lua 会查找环境变量 LUA_INIT 的值，如果变
量存在并且值为@filename，Lua 将加载指定文件。如果变量存在但不是以@开头，Lua
假定 filename 为 Lua 代码文件并且运行他。利用这个特性，我们可以通过配置，灵活的
设置交互模式的环境。可以加载包，修改提示符和路径，定义自己的函数，修改或者重
名名函数等。&
全局变量 arg存放 Lua 的命令行参数。&
prompt& lua script a b c&
在运行以前，Lua 使用所有参数构造 arg 表。脚本名索引为 0，脚本的参数从 1 开始
增加。脚本前面的参数从-1 开始减少。&
prompt& lua -e &sin=math.sin& script a b&
arg 表如下：&
arg[-3] = &lua&&
arg[-2] = &-e&&
arg[-1] = &sin=math.sin&&
arg[0] = &script&&
arg[1] = &a&&
arg[2] = &b&&
第二章 类型和值
Lua是动态类型语言，变量不要类型定义。 Lua中有8个基本类型分别为： nil、 boolean、
number、string、userdata、function、thread和 table。函数 type 可以测试给定变量或者值
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&
变量没有预定义的类型，每一个变量都可能包含任一种类型的值。&
print(type(a)) &--& nil & ('a' is not initialized)&
print(type(a)) &--& number&
a = &a string!!&&
print(type(a)) &--& string&
a = print & &-- yes, this is valid!&
a(type(a)) & & --& function&
注意上面最后两行，我们可以使用 function 像使用其他值一样使用（更多的介绍参
考第六章）。一般情况下同一变量代表不同类型的值会造成混乱，最好不要用，但是特殊
情况下可以带来便利，比如 nil。&
Lua 中特殊的类型，他只有一个值：nil；一个全局变量没有被赋值以前默认值为 nil；
给全局变量负 nil 可以删除该变量。&
2.2 & Booleans &&
两个取值 false 和 true。但要注意 Lua中所有的值都可以作为条件。在控制结构的条
件中除了 false 和 nil 为假，其他值都为真。所以 Lua 认为0 和空串都是真。&
2.3 &Numbbers
表示实数，Lua 中没有整数。一般有个错误的看法 CPU运算浮点数比整数慢。事实
不是如此，用实数代替整数不会有什么误差（除非数字大于 100,000,000,000,000）。Lua
的 numbers 可以处理任何长整数不用担心误差。你也可以在编译 Lua的时候使用长整型
或者单精度浮点型代替 numbers，在一些平台硬件不支持浮点数的情况下这个特性是非
常有用的，具体的情况请参考 Lua发布版所附的详细说明。和其他语言类似，数字常量
的小数部分和指数部分都是可选的，数字常量的例子：&
4 &0.4 & 4.57e-3 &0.3e12 &5e+20&
2 2.4 & Strings&
指字符的序列。lua是 8位字节，所以字符串可以包含任何数值字符，包括嵌入的 0。
这意味着你可以存储任意的二进制数据在一个字符串里。 Lua 中字符串是不可以修改的，
你可以创建一个新的变量存放你要的字符串，如下：&
a = &one string&&
b = string.gsub(a, &one&, &another&) &-- change string parts&
print(a) & &--& one string&
print(b) & &--& another string&
string 和其他对象一样，Lua 自动进行内存分配和释放，一个 string 可以只包含一个
字母也可以包含一本书，Lua 可以高效的处理长字符串，1M的 string 在 Lua 中是很常见
的。可以使用单引号或者双引号表示字符串&
a = &a line&&
b = 'another line'&
为了风格统一，最好使用一种，除非两种引号嵌套情况。对于字符串中含有引号的
情况还可以使用转义符\来表示。Lua中的转义序列有：&
Copyright ? 2005, Translation Team, www.luac
\b back space & & & &-- 后退&
\f form feed & & &-- 换页&
\n newline & & & &-- 换行&
\r carriage return & &-- 回车&
\t horizontal tab & & &-- 制表&
\v vertical tab&
\\ backslash & & & -- &\&&
\& double quote & & -- 双引号&
\' single quote & & -- 单引号&
\[ left square bracket & &-- 左中括号&
\] right square bracket & &-- 右中括号&
& print(&one line\nnext line\n\&in quotes\&, 'in quotes'&)&
next line&
&in quotes&, 'in quotes'&
& print('a backslash inside quotes: \'\\\'')&
a backslash inside quotes: '\'&
& print(&a simpler way: '\\'&)&
a simpler way: '\'&
还可以在字符串中使用\ddd（ddd 为三位十进制数字）方式表示字母。&
&alo\n123\&&和'\97lo\10\04923&'是相同的。&
还可以使用[[...]]表示字符串。这种形式的字符串可以包含多行也，可以嵌套且不会
解释转义序列，如果第一个字符是换行符会被自动忽略掉。这种形式的字符串用来包含
一段代码是非常方便的。&
page = [[&
&TITLE&An HTML Page&/TITLE&&
[[a text between double brackets]]&
io.write(page)&
运行时，Lua 会自动在 string 和 numbers 之间自动进行类型转换，当一个字符串使
用算术操作符时，string 就会被转成数字。&
print(&10& + 1) & & --& 11&
print(&10 + 1&) & & --& 10 + 1&
print(&-5.3e - 10& * &2&) &--& -1.06e-09&
print(&hello& + 1) & &-- ERROR (cannot convert &hello&)&
反过来，当 Lua 期望一个 string 而碰到数字时，会将数字转成 string。&
print(10 .. 20) &--& 1020&
..在 Lua 中是字符串连接符，当在一个数字后面写..时，必须加上空格以防止被解释
尽管字符串和数字可以自动转换，但两者是不同的，像 10 == &10&这样的比较永远
都是错的。如果需要显式将 string 转成数字可以使用函数 tonumber()，如果 string 不是正
确的数字该函数将返回 nil。&
line = io.read() & &-- read a line&
n = tonumber(line) & -- try to convert it to a number&
if n == nil then&
&error(line .. & is not a valid number&)&
&print(n*2)&
反之,可以调用 tostring()将数字转成字符串，这种转换一直有效：&
print(tostring(10) == &10&) & --& true&
print(10 .. && == &10&) & &--& true&
2.5 & Functions &&
函数是第一类值（和其他变量相同），意味着函数可以存储在变量中，可以作为函数
的参数，也可以作为函数的返回值。这个特性给了语言很大的灵活性：一个程序可以重
新定义函数增加新的功能或者为了避免运行不可靠代码创建安全运行环境而隐藏函数，
此外这特性在 Lua 实现面向对象中也起了重要作用（在第 16 章详细讲述）。&
Lua 可以调用 lua 或者 C 实现的函数，Lua 所有标准库都是用 C 实现的。标准库包
括 string 库、table 库、I/O库、OS库、算术库、debug 库。&
2.6 & Userdata and Threads
userdata 可以将 C 数据存放在 Lua 变量中， userdata 在 Lua 中除了赋值和相等比较外
没有预定义的操作。userdata 用来描述应用程序或者使用 C 实现的库创建的新类型。例
如：用标准 I/O库来描述文件。下面在 C API章节中我们将详细讨论。&
在第九章讨论协同操作的时候，我们介绍线程。&
第 3 章 &表达式
Lua 中的表达式包括数字常量、字符串常量、变量、一元和二元运算符、函数调用。
还可以是非传统的函数定义和表构造。&
3.1 算数运算符 &
二元运算符：+ - * / ^ &(加减乘除幂)
一元运算符：- &(负值)&
这些运算符的操作数都是实数。&
3.2 关系运算符
& && &&= &&= &== &~=&
这些操作符返回结果为 false 或者true；==和~=比较两个值，如果两个值类型不同，
Lua 认为两者不同；nil 只和自己相等。Lua 通过引用比较 tables、userdata、functions。
也就是说当且仅当两者表示同一个对象时相等。&
a = {}; a.x = 1; a.y = 0&
b = {}; b.x = 1; b.y = 0&
a==c but a~=b&
Lua 比较数字按传统的数字大小进行，比较字符串按字母的顺序进行，但是字母顺
序依赖于本地环境。&
当比较不同类型的值的时候要特别注意：&
&0& == 0 & -- false&
2 & 15 & &-- true&
&2& & &15& & -- false (alphabetical order!)&
为了避免不一致的结果，混合比较数字和字符串，Lua 会报错，比如：2 & &15&&
3.3逻辑运算符
and & or &not&
逻辑运算符认为 false 和nil 是假（false），其他为真，0 也是 true.&
and 和 or的运算结果不是 true和 false，而是和它的两个操作数相关。&
a and b & -- 如果 a为false，则返回 a，否则返回 b&
a or &b & & -- 如果 a为true，则返回 a，否则返回 b&
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&
一个很实用的技巧：如果 x 为 false或者 nil 则给x 赋初始值v&
x = x or v&
if not x then&
and 的优先级比 or高。&
C 语言中的三元运算符&
a ? b : c&
在 Lua 中可以这样实现：&
(a and b) or c&
not 的结果一直返回 false或者 true&
print(not nil) & &--& true&
print(not false) & &--& true&
print(not 0) & & --& false&
print(not not nil) & --& false&
3.4连接运算符
.. & &--两个点&
字符串连接，如果操作数为数字，Lua 将数字转成字符串。&
print(&Hello & .. &World&) & --& Hello World&
print(0 .. 1) & & & --& 01&
从高到低的顺序：&
not & - (unary)&
& && &&= &&= &~= &==&
除了^和..外所有的二元运算符都是左连接的。&
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)&
3.6表的构造
构造器是创建和初始化表的表达式。表是 Lua特有的功能强大的东西。最简单的构
造函数是{}，用来创建一个空表。可以直接初始化数组:&
days = {&Sunday&, &Monday&, &Tuesday&, &Wednesday&,&
& & &&Thursday&, &Friday&, &Saturday&}&
Lua 将&Sunday&初始化 days[1]（第一个元素索引为 1） ，用&Monday&初始化 days[2].
print(days[4]) & --& Wednesday&
构造函数可以使用任何表达式初始化：&
tab = {sin(1), sin(2), sin(3), sin(4),&
& &sin(5),sin(6), sin(7), sin(8)}&
如果想初始化一个表作为 record 使用可以这样：&
a = {x=0, y=0} &&--& &a = {}; a.x=0; a.y=0 &
不管用何种方式创建 table，我们都可以向表中添加或者删除任何类型的域，构造函
数仅仅影响表的初始化。&
w = {x=0, y=0, label=&console&}&
x = {sin(0), sin(1), sin(2)}&
w[1] = &another field&&
print(w[&x&]) & --& 0&
print(w[1]) & --& another field&
print(x.f[1]) & --& another field&
w.x = nil & &-- remove field &x&&
每次调用构造函数，Lua都会创建一个新的 table，可以使用 table 构造一个 list：&
list = nil&
for line in io.lines() do&
&list = {next=list, value=line}&
这段代码从标准输入读进每行，然后反序形成链表。下面的代码打印链表的内容：
while l do
print (l.value)
l = l.next
在同一个构造函数中可以混合列表风格和 record 风格进行初始化，如：&
polyline = {color=&blue&, thickness=2, npoints=4,
& & {x=0, & y=0},&
& & {x=-10, y=0},&
& & {x=-10, y=1},&
& & {x=0, & y=1}&
这个例子也表明我们可以嵌套构造函数来表示复杂的数据结构
print(polyline[2].x) & --& -10&
上面两种构造函数的初始化方式还有限制，比如你不能使用负索引初始化一个表中
元素，字符串索引也不能被恰当的表示。下面介绍一种更一般的初始化方式，我们用
[expression]显示的表示将被初始化的索引：&
opnames = {[&+&] = &add&, [&-&] = &sub&, [&*&] = &mul&, [&/&] = &div&}
i = 20; s = &-&
a = {[i+0] = s, [i+1] = s .. s, [i+2] = s .. s .. s}
print(opnames[s]) --&sub
print(a[22]) --&
list 风格初始化和 record风格初始化是这种一般初始化的特例:&
{x=0, y=0} & &&--& &{[&x&]=0, [&y&]=0}&
{&red&, &green&, &blue&} & &&--&&
& & &{[1]=&red&, [2]=&green&, [3]=&blue&}&
如果真的想要数组下标从 0 开始：&
days = {[0]=&Sunday&, &Monday&, &Tuesday&, &Wednesday&,&
& & &Thursday&, &Friday&, &Saturday&}&
注意：不推荐数组下标从 0 开始，否则很多标准库不能使用。&
在构造函数的最后的&,&是可选的，可以方便以后的扩展。&
a = {[1]=&red&, [2]=&green&, [3]=&blue&,}&
在构造函数中域分隔符逗号（&,&）可以用分号（&;&）替代，通常我们使用分号用来
分割不同类型的表元素。&
{x=10, y=45; &one&, &two&, &three&}&
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：106479次
积分：1689
积分：1689
排名：第16263名
原创：67篇
转载：18篇
评论：20条
(2)(3)(8)(3)(4)(2)(17)(9)(4)(5)(7)(1)(3)(1)(5)(4)(5)(3)环境：lua for windows (lfW)主页：lua for windows其实是一整套Lua的开发环境，它包括：Lua Interpreter（Lua解释器）Lua Reference Manual（Lua参考手册）&Quick Lua Tour （Lua快速入门）Examples （Lua范例）Libraries with documentation （一些Lua库和文档）SciTE （一个很棒的多用途编辑器，已经对Lua做了特殊设置）
Lua脚本语法说明（修订）&Lua脚本语法说明（增加5.1部份特性）Lua 的语法比较简单，学习起来也比较省力，但功能却并不弱。所以，我只简单的归纳一下Lua的一些语法规则，使用起来方便好查就可以了。估计看完了，就懂得怎么写Lua程序了。在Lua中，一切都是变量，除了关键字。I.&&首先是注释写一个程序，总是少不了注释的。在Lua中，你可以使用单行注释和多行注释。单行注释中，连续两个减号"--"表示注释的开始，一直延续到行末为止。相当于C++语言中的"//"。多行注释中，由"--[["表示注释开始，并且一直延续到"]]"为止。这种注释相当于C语言中的"/*...*/"。在注释当中，"[["和"]]"是可以嵌套的（在lua5.1中，中括号中间是可以加若干个"="号的，如 [==[ ... ]==]），见下面的字符串表示说明。II.&&Lua编程经典的"Hello world"的程序总是被用来开始介绍一种语言。在Lua中，写一个这样的程序很简单：print("Hello world")在Lua中，语句之间可以用分号"；"隔开，也可以用空白隔开。一般来说，如果多个语句写在同一行的话，建议总是用分号隔开。Lua 有好几种程序控制语句，如：控制语句& && &&&格式& && &&&示例If& && &&&if 条件 then ... elseif 条件 then ... else ... end& && &&&if 1+1=2 then print("true")elseif 1+2~=3 then print("true")else print("false") endWhile& && &&&while 条件 do ... end& && &&&while 1+1~=2 do print("true") endRepeat& && &&&repeat ... until 条件& && &&&repeat print("Hello") until 1+1~=2For& && &&&for 变量=初值, 终点值, 步进 do ... end& && &&&for i = 1, 10, 2 do print(i) endFor& && &&&for 变量1, 变量2, ... 变量n in 表或枚举函数&do ... end& && &&&for a,b in mylist do print(a, b) end注意一下，for的循环变量总是只作用于for的局部变量；当省略步进值时，for循环会使用1作为步进值。使用break可以用来中止一个循环。相对C语言来说，Lua有几个地方是明显不同的，所以面要特别注意一下：．语句块语句块在C中是用"{"和"}"括起来的，在Lua中，它是用do 和 end 括起来的。比如：do print("Hello") end可以在 函数 中和 语句块 中定局部变量。．赋值语句赋值语句在Lua被强化了。它可以同时给多个变量赋值。例如：a,b,c,d=1,2,3,4甚至是：a,b=b,a&&-- 多么方便的交换变量功能啊。在默认情况下，变量总是认为是全局的。假如需要定义局部变量，则在第一次赋值的时候，需要用local说明。比如：local a,b,c = 1,2,3&&-- a,b,c都是局部变量．数值运算和C语言一样，支持 +, -, *, /。但Lua还多了一个"^"。这表示指数乘方运算。比如2^3 结果为8, 2^4结果为16。连接两个字符串，可以用".."运处符。如："This a " .. "string." -- 等于 "this a string"．比较运算比较符号& && &&&&& && &&&&& && &&&&=& && &&&&=& && &&&==& && &&&~=含义& && &&&小于& && &&&大于& && &&&小于或等于& && &&&大于或等于& && &&&相等& && &&&不相等所有这些操作符总是返回true或false。对于Table，Function和Userdata类型的数据，只有 == 和 ~=可以用。相等表示两个变量引用的是同一个数据。比如：a={1,2}b=aprint(a==b, a~=b)&&--输出 true, falsea={1,2}b={1,2}print(a==b, a~=b)&&--输出 false, true．逻辑运算and, or, not其中，and 和 or 与C语言区别特别大。在这里，请先记住，在Lua中，只有false和nil才计算为false，其它任何数据都计算为true，0也是true！and 和 or的运算结果不是true和false，而是和它的两个操作数相关。a and b：如果a为false，则返回a；否则返回ba or b：如果 a 为true，则返回a；否则返回b举几个例子：print(4 and 5) --输出 5print(nil and 13) --输出 nilprint(false and 13) --输出 falseprint(4 or 5) --输出 4print(false or 5) --输出 5在Lua中这是很有用的特性，也是比较令人混洧的特性。我们可以模拟C语言中的语句：x = a? b : c，在Lua中，可以写成：x = a and b or c。最有用的语句是： x = x or v，它相当于：if not x then x = v end 。．运算符优先级，从低到高顺序如下：& &&&or& &&&and& &&&&& &&&&& &&&&=& & &=& & ~=& & ==& &&&.. (字符串连接)& &&&+& &&&-& &&&*& &&&/& &&&%& &&&not& &#(lua5.1 取长度运算)& &&&- (一元运算)& &&&^和C语言一样，括号可以改变优先级。III.&&关键字关键字是不能做为变量的。Lua的关键字不多，就以下几个：& &&&and& && &&&break& && &&&do& && &&&else& && &&&elseif& && &&&end& && &&&false& && &&&for& && &&&function& && &&&if& && &&&in& && &&&local& && &&&nil& && &&&not& && &&&or& && &&&repeat& && &&&return& && &&&then& && &&&true& && &&&until& && &&&whileIV.&&变量类型　　怎么确定一个变量是什么类型的呢？大家可以用type()函数来检查。Lua支持的类型有以下几种：Nil& && &&&空值，所有没有使用过的变量，都是nil。nil既是值，又是类型。Boolean& && &&&布尔值，只有两个有效值：true和falseNumber& && &&&数值，在Lua里，数值相当于C语言的doubleString& && &&&字符串，如果你愿意的话，字符串是可以包含"\0"字符的（这和C语言总是以"\0"结尾是不一样的）Table& && &&&关系表类型，这个类型功能比较强大，请参考后面的内容。Function& && &&&函数类型，不要怀疑，函数也是一种类型，也就是说，所有的函数，它本身就是一个变量。Userdata& && &&&嗯，这个类型专门用来和Lua的宿主打交道的。宿主通常是用C和C++来编写的，在这种情况下，Userdata可以是宿主的任意数据类型，常用的有Struct和指针。Thread& && &&&线程类型，在Lua中没有真正的线程。Lua中可以将一个函数分成几部份运行。如果感兴趣的话，可以去看看Lua的文档。现在回过头来看看，倒觉得不是线程类型。反而象是用来做遍历的，象是Iterator函数。如：function range(n)&&local i = 0&&while(i & n) do&& & coroutine.yield( i )& & i = i + 1&&endend可惜的是要继续运行，需要coroutine.resume函数，有点鸡肋。请指教。V.&&变量的定义　　所有的语言，都要用到变量。在Lua中，不管在什么地方使用变量，都不需要声明，并且所有的这些变量总是全局变量，除非我们在前面加上"local"。这一点要特别注意，因为我们可能想在函数里使用局部变量，却忘了用local来说明。至于变量名字，它是大小写相关的。也就是说，A和a是两个不同的变量。定义一个变量的方法就是赋值。"＝"操作就是用来赋值的我们一起来定义几种常用类型的变量吧。A.&&Nil　　　　正如前面所说的，没有使用过的变量的值，都是Nil。有时候我们也需要将一个变量清除，这时候，我们可以直接给变量赋以nil值。如：var1=nil&&-- 请注意 nil 一定要小写B.&&Boolean　　　　布尔值通常是用在进行条件判断的时候。布尔值有两种：true 和 false。在Lua中，只有false和nil才被计算为false，而所有任何其它类型的值，都是true。比如0，空串等等，都是true。不要被 C语言的习惯所误导，0在Lua中的的确确是true。你也可以直接给一个变量赋以Boolean类型的值，如：theBoolean = trueC.&&Number　　　　在Lua中，是没有整数类型的，也不需要。一般情况下，只要数值不是很大（比如不超过100,000,000,000,000），是不会产生舍入误差的。在WindowsXP能跑的当今主流PC上，实数的运算并不比整数慢。实数的表示方法，同C语言类似，如：4 0.4 4.57e-3 0.3e12 5e+20D.&&String字符串，总是一种非常常用的高级类型。在Lua中，我们可以非常方便的定义很长很长的字符串。字符串在Lua中有几种方法来表示，最通用的方法，是用双引号或单引号来括起一个字符串的，如："That's go!"或'Hello world!'和C语言相同的，它支持一些转义字符，列表如下：\a&&bell\b&&back space\f&&form feed\n&&newline\r&&carriage return\t&&horizontal tab\v&&vertical tab\\&&backslash\"&&double quote\"&&single quote\[&&left square bracket\]&&right square bracket由于这种字符串只能写在一行中，因此，不可避免的要用到转义字符。加入了转义字符的串，看起来实在是不敢恭维，比如："one line\nnext line\n\"in quotes\", "in quotes""一大堆的"\"符号让人看起来很倒胃口。如果你与我有同感，那么，我们在Lua中，可以用另一种表示方法：用"[["和"]]"将多行的字符串括起来。（lua5.1: 中括号中间可以加入若干个"="号，如 [==[ ... ]==]，详见下面示例）示例：下面的语句所表示的是完全相同的字符串：a = 'alo\n123"'a = "alo\n123\""a = '\97lo\10\04923"'a = [[alo123"]]a = [==[alo123"]==]值得注意的是，在这种字符串中，如果含有单独使用的"[["或"]]"就仍然得用"\["或"\]"来避免歧义。当然，这种情况是极少会发生的。　E.&&Table　　　　关系表类型，这是一个很强大的类型。我们可以把这个类型看 作是一个数组。只是C语言的数组，只能用正整数来作索引；在Lua中，你可以用任意类型来作数组的索引，除了nil。同样，在C语言中，数组的内容只允许 一种类型；在Lua中，你也可以用任意类型的值来作数组的内容，除了nil。Table的定义很简单，它的主要特征是用"{"和"}"来括起一系列数据元素的。比如：T1 = {}&&-- 定义一个空表T1[1]=10&&-- 然后我们就可以象C语言一样来使用它了。&T1["John"]={Age=27, Gender="Male"}这一句相当于：T1["John"]={}&&-- 必须先定义成一个表，还记得未定义的变量是nil类型吗T1["John"]["Age"]=27T1["John"]["Gender"]="Male"当表的索引是字符串的时候，我们可以简写成：T1.John={}T1.John.Age=27T1.John.Gender="Male"或T1.John{Age=27, Gender="Male"}这是一个很强的特性。在定义表的时候，我们可以把所有的数据内容一起写在"{"和"}"之间，这样子是非常方便，而且很好看。比如，前面的T1的定义，我们可以这么写：T1={10,&&-- 相当于 [1] = 10[100] = 40,John=&&-- 如果你原意，你还可以写成：["John"] ={Age=27,& &-- 如果你原意，你还可以写成：["Age"] =27Gender=Male& &-- 如果你原意，你还可以写成：["Gender"] =Male},20&&-- 相当于 [2] = 20}看起来很漂亮，不是吗？我们在写的时候，需要注意三点：第一，所有元素之间，总是用逗号"，"隔开；第二，所有索引值都需要用"["和"]"括起来；如果是字符串，还可以去掉引号和中括号；第三，如果不写索引，则索引就会被认为是数字，并按顺序自动从1往后编；表类型的构造是如此的方便，以致于常常被人用来代替配置文件。是的，不用怀疑，它比ini文件要漂亮，并且强大的多。　　F.&&Function函数，在Lua中，函数的定义也很简单。典型的定义如下：function add(a,b)&&-- add 是函数名字，a和b是参数名字return a+b&&-- return 用来返回函数的运行结果end&请注意，return语言一定要写在end之前。假如我们非要在中间放上一句return，那么就应该要写成：do return end。还记得前面说过，函数也是变量类型吗？上面的函数定义，其实相当于：add = function (a,b) return a+b end当重新给add赋值时，它就不再表示这个函数了。我们甚至可以赋给add任意数据，包括nil （这样，赋值为nil，将会把该变量清除）。Function是不是很象C语言的函数指针呢？和C语言一样，Lua的函数可以接受可变参数个数，它同样是用"..."来定义的，比如：function sum (a,b, )如果想取得...所代表的参数，可以在函数中访问arg局部变量（表类型）得到 (lua5.1: 取消arg，并直接用"..."来代表可变参数了，本质还是arg)。如 sum(1,2,3,4)则，在函数中，a = 1, b = 2, arg = {3, 4}&&(lua5.1:&&a = 1, b = 2, ... = {3, 4})更可贵的是，它可以同时返回多个结果，比如：function s()return 1,2,3,4enda,b,c,d = s()&&-- 此时，a = 1, b = 2, c = 3, d = 4&前面说过，表类型可以拥有任意类型的值，包括函数！因此，有一个很强大的特性是，拥有函数的表，哦，我想更恰当的应该说是对象吧。Lua可以使用面向对象编程了。不信？举例如下：t ={Age = 27add = function(self, n) self.Age = self.Age+n end}print(t.Age)&&-- 27t.add(t, 10)print(t.Age)&&-- 37不过，t.add(t,10) 这一句实在是有点土对吧？没关系，在Lua中，我们可以简写成：t:add(10)& & -- 相当于 t.add(t,10)G.&&Userdata 和 Thread这两个类型的话题，超出了本文的内容，就不打算细说了。
A.闭包示例一
function newCounter()
local i = 0
return function()
-- anonymous function
c1 = newCounter()
print(c1())
print(c1())
function myPower(x)
return function(y) return y^x end
power2 = myPower(2)
power3 = myPower(3)
print(power2(4)) --4的2次方
print(power3(5)) --5的3次方
我们可以直接使用require(&model_name&)来载入别的lua文件，文件的后缀是.lua。载入的时候就直接执行那个文件了。比如：我们有一个hello.lua的文件：
print("Hello, World!")
如果我们：require(&hello&)，那么就直接输出Hello, World！了。注意：1）require函数，载入同样的lua文件时，只有第一次的时候会去执行，后面的相同的都不执行了。2）如果你要让每一次文件都会执行的话，你可以使用dofile(&hello&)函数3）如果你要玩载入后不执行，等你需要的时候执行时，你可以使用 loadfile()函数，如下所示：
local hello = loadfile("hello")
loadfile(&hello&)后，文件并不执行，我们把文件赋给一个变量hello，当hello()时，才真的执行。（我们多希望JavaScript也有这样的功能当然，更为标准的玩法如下所示。假设我们有一个文件叫mymod.lua，内容如下：文件名：mymod.lua
local HaosModel = {}
local function getname()
return "Hao Chen"
function HaosModel.Greeting()
print("Hello, My name is "..getname())
return HaosModel
于是我们可以这样使用：
local hao_model = require("mymod")
hao_model.Greeting()
其实，require干的事就如下：（所以你知道为什么我们的模块文件要写成那样了）
local hao_model = (function ()
--mymod.lua文件的内容--
VI.&&结束语　　就这么结束了吗？当然不是，接下来，我们需要用Lua解释器，来帮助理解和实践了。相信这样会更快的对Lua上手了。就象C语言一样，Lua提供了相当多的标准函数来增强语言的功能。使用这些标准函数，可以很方便的操作各种数据类型，并处理输入输出。有关这方面的信息，我们可以参考《》一书，也可以在网络上直接观看电子版，网址为：　　备注：本文的部份内容摘、译自lua随机文档。相关链接：1. Lua 官方网站：&&2. Lua Wiki网站，你可以在这里找到很多相关的资料，如文档、教程、扩展，以及C/C++的包装等：&
阅读(...) 评论()}