LUA程序设计【第一篇】.doc

Lua程序设计
版权声明
译序
第一篇 语言
第0章 序言
0.1 序言
0.2 Lua的使用者
0.3 Lua的相关资源
0.4 本书的体例
0.5 关于本书
0.6 感谢
第1章 起点
1.1 Chunks
1.2 全局变量
1.3 词法约定
1.4 命令行方式
第2章 类型和值
2.1 Nil
2.2 Booleans
2.3 Numbers
2.4 Strings
2.5 Functions
2.6 Userdata and Threads
第3章 表达式
3.1 算术运算符
3.2 关系运算符
3.3 逻辑运算符
3.4 连接运算符
3.5 优先级
3.6 表的构造
第4章 基本语法
4.1 赋值语句
4.2 局部变量与代码块（block）
4.3 控制结构语句
4.4 break和return语句
第5章 函数
5.1 多返回值
5.2 可变参数
5.3 命名参数
第6章 再论函数
6.1 闭包
6.2 非全局函数
6.3 正确的尾调用（Proper Tail Calls）
第7章 迭代器与泛型for
7.1 迭代器与闭包
7.2 范性for的语义
7.3 无状态的迭代器
7.4 多状态的迭代器
7.5 真正的迭代器
第8章 编译·运行·错误信息
8.1 require函数
8.2 C Packages
8.3 错误
8.4 异常和错误处理
8.5 错误信息和回跟踪（Tracebacks）
第9章 协同程序
9.1 协同的基础
9.2 管道和过滤器
9.3 用作迭代器的协同
9.4 非抢占式多线程
第10章 完整示例
10.1 Lua作为数据描述语言使用
10.2 马尔可夫链算法
第二篇 tables与objects
第11章 数据结构
11.1 数组
11.2 矩阵和多维数组
11.3 链表
11.4 队列和双向队列
11.5 集合和包
11.6 字符串缓冲
第12章 数据文件与持久化
12.1 序列化
12.1.1 保存不带循环的table
12.1.2 保存带有循环的table
第13章 Metatables and Metamethods
13.1 算术运算的Metamethods
13.2 关系运算的Metamethods
13.3 库定义的Metamethods
13.4 表相关的Metamethods
13.4.1 The __index Metamethod
13.4.2 The __newindex Metamethod
13.4.3 有默认值的表
13.4.4 监控表
13.4.5 只读表
第14章 环境
14.1 使用动态名字访问全局变量
14.2 声明全局变量
14.3 非全局的环境
第15章 Packages
15.1 基本方法
15.2 私有成员（Privacy）
15.3 包与文件
15.4 使用全局表
15.5 其他一些技巧（Other Facilities）
第16章 面向对象程序设计
16.1 类
16.2 继承
16.3 多重继承
16.4 私有性（privacy）
16.5 Single-Method的对象实现方法
第17章 Weak表
17.1 记忆函数
17.2 关联对象属性
17.3 重述带有默认值的表
第三篇 标准库
第18章 数学库
第19章 Table库
19.1 数组大小
19.2 插入/删除
19.3 排序
第20章 String库
20.1 模式匹配函数
20.2 模式
20.3 捕获（Captures）
20.4 转换的技巧（Tricks of the Trade）
第21章 IO库
21.1 简单I/O模式
21.2 完全I/O 模式
21.2.1 I/O优化的一个小技巧
21.2.2 二进制文件
21.3 关于文件的其它操作
第22章 操作系统库
22.1 Date和Time
22.2 其它的系统调用
第23章 Debug库
23.1 自省（Introspective）
23.1.1 访问局部变量
23.1.2 访问Upvalues
23.2 Hooks
23.3 Profiles
第四篇 C API
第24章 C API纵览
24.1 第一个示例程序
24.2 堆栈
24.2.1 压入元素
24.2.2 查询元素
24.2.3 其他堆栈操作
24.3 C API的错误处理
24.3.1 应用程序中的错误处理
24.3.2 类库中的错误处理
第25章 扩展你的程序
25.1 表操作
25.2 调用Lua函数
25.3 通用的函数调用
第26章 调用C函数
26.1 C 函数
26.2 C 函数库
第27章 撰写C函数的技巧
27.1 数组操作
27.2 字符串处理
27.3 在C函数中保存状态
27.3.1 The Registry
27.3.2 References
27.3.3 Upvalues
第28章 User-Defined Types in C
28.1 Userdata
28.2 Metatables
28.3 访问面向对象的数据
28.4 访问数组
28.5 Light Userdata
第29章 资源管理
29.1 目录迭代器
29.2 XML解析
第四篇 附录
A. 终端机控制符

第一篇 语言
第0章 序言
本章包括作者的序言、文章的体例（convention）以及其它一些“每本书开头都会的内容”。
0.1 序言
目前很多程序语言都专注于帮你编写成千上万行的代码，所以此类型的语言所提供的包、命名空间、复杂的类型系统及无数的结构，有上千页的文档需要操作者学习。
而Lua并不帮你编写大量的代码的程序，相反的，Lua仅让你用少量的代码解决关键问题。为实现这个目标，像其他语言一样Lua依赖于其可扩展性。但是与其他语言不同的是，不仅用Lua编写的软件易于扩展，而且用其他语言比如C/C++编写的软件也很容易使用Lua扩展其功能。
一开始，Lua就被设计成很容易和传统的C/C++整合的语言。这种语言的二元性带来了极大的好处。Lua是一个小巧而简单的语言，因为Lua不致力于做C语言已经做得很好的领域，比如：性能、底层操作以及与第三方软件的接口。Lua依赖于C去做完成这些任务。Lua所提供的机制是C不善于的：高级语言、动态结构、简洁、易于测试和调试等。正因为如此，Lua具有良好的安全保证，自动内存管理，简便的字符串处理功能及其他动态数据的改变。
Lua不仅是一种易于扩展的语言，也是一种易整合语言（glue language）；Lua支持基于组件的，我们可以将一些已经存在的高级组件整合在一起实现一个应用软件。一般情况下，组件使用像C/C++等静态的语言编写。但Lua是我们整合各个组件的粘合剂。又通常情况下，组件（或对象）表现为具体在程序开发过程中很少变化的、占用大量CPU时间的决定性的程序，例如窗口部件和数据结构。对那种在产品的生命周期内变化比较多的应用方向使用Lua可以更方便的适应变化。除了作为整合语言外，Lua自身也是一个功能强大的语言。Lua不仅可以整合组件，还可以编辑组件甚至完全使用Lua创建组件。
除了Lua外，还有很多类似的脚本语言，例如：Perl、Tcl、Ruby、Forth、Python。虽然其他语言在某些方面与Lua有着共同的特色，但下面这些特征是Lua特有的：
① 可扩展性。Lua的扩展性非常卓越，以至于很多人把Lua用作搭建领域语言的工具（注：比如游戏脚本）。Lua被设计为易于扩展的，可以通过Lua代码或者C代码扩展，Lua的很多功能都是通过外部库来扩展的。Lua很容易与C/C++、java、fortran、Smalltalk、Ada，以及其他语言接口。
② 简单。Lua本身简单，小巧；内容少但功能强大，这使得Lua易于学习，很容易实现一些小的应用。他的完全发布版（代码、手册以及某些平台的二进制文件）仅用一张软盘就可以装得下。
③ 高效率。Lua有很高的执行效率，统计表明Lua是目前平均效率最高的脚本语言。
④ 与平台无关。Lua几乎可以运行在所有我们听说过的系统上，如NextStep、OS/2、PlayStation II (Sony)、Mac OS-9、OS X、BeOS、MS-DOS、IBM mainframes、EPOC、PalmOS、MCF5206eLITE Evaluation Board、RISC OS，及所有的Windows和Unix。Lua不是通过使用条件编译实现平台无关，而是完全使用ANSI (ISO) C，这意味着只要你有ANSI C编译器你就可以编译并使用Lua。
Lua大部分强大的功能来自于他的类库，这并非偶然。Lua的长处之一就是可以通过新类型和函数来扩展其功能。动态类型检查最大限度允许多态出现，并自动简化调用内存管理的接口，因为这样不需要关心谁来分配内存谁来释放内存，也不必担心数据溢出。高级函数和匿名函数均可以接受高级参数，使函数更为通用。
Lua自带一个小规模的类库。在受限系统中使用Lua，如嵌入式系统，我们可以有选择地安装这些类库。若运行环境十分严格，我们甚至可以直接修改类库源代码，仅保留需要的函数。记住：Lua是很小的（即使加上全部的标准库）并且在大部分系统下你仍可以不用担心的使用全部的功能。
0.2 Lua的使用者
Lua使用者分为三大类：使用Lua嵌入到其他应用中的、独立使用Lua的、将Lua和C混合使用的。
第一：很多人使用Lua嵌入在应用程序，比如CGILua（搭建动态网页）、LuaOrb（访问CORBA对象。这些类型用Lua-API注册新函数，创建新类型，通过配置Lua就可以改变应用宿主语言的行为。通常，这种应用的使用者并不知道Lua是一种独立的语言。例如：CGILua用户一般会认为Lua是一种用于Web的语言。
第二：作为一种独立运行的语言，Lua也是很有用的，主要用于文本处理或者只运行一次的小程序。这种应用Lua主要使用它的标准库来实现，标准库提供模式匹配和其它一些字串处理的功能。我们可以这样认为：Lua是文本处理领域的嵌入式语言。
第三：还有一些使用者使用其他语言开发，把Lua当作库使用。这些人大多使用C语言开发，但使用Lua建立简单灵活易于使用的接口。
本书面向以上三类读者。书的第一部分阐述了语言的本身，展示语言的潜在功能。我们讲述了不同的语言结构，并用一些例子展示如何解决实际问题。这部分既包括基本的语言的控制结构，也包括高级的迭代子和协同。
第二部分重点放在Lua特有的数据结构——tables上,讨论了数据结构、持久性、包及面向对象编程，这里我们将看到Lua的真正强大之处。
第三部分介绍标准库。每个标准库一章：数学库、table库、string库、I/O库、OS库、Debug库。
最后一部分介绍了Lua和C接口的API，这部分介绍在C语言中开发应用而不是Lua中，应用对于那些打算将Lua嵌入到C/C++中的读者可能会对此部分更感兴趣。
0.3 Lua的相关资源
如果你真得想学一门语言，参考手册是必备的。本书和Lua参考手册互为补充，手册仅仅描述语言本身，因此他既不会告诉你语言的数据结构也不会举例说明，但手册是Lua的权威性文档，http://www.lua.org可以得到手册的内容。
-- Lua用户社区，提供了一些第三方包和文档
http://lua-users.org

-- 本书的更新勘误表，代码和例子
http://www.inf.puc-rio.br/~roberto/book/
另外本书仅针对Lua 5.0，如果你的版本不同，请查阅Lua手册或者比较版本间的差异。
0.4 本书的体例
<1> 字符串使用双引号，比如"literal strings"；单字符使用单引号，比如'a'；模式串也是用单引号，比如'[%w_]*'。
<2> 符号-->表示语句的输出或者表达式的结果:
print(10)     --> 10
13 + 3        --> 16
<3> 符号<-->表示等价，即对于Lua来说，用this与that没有区别。
this       <-->       that
0.5 关于本书
开始打算写这本书是1998年冬天(南半球)，那时候Lua版本是3.1；2000年v4.0；2003年v5.0。
很明显的是，这些变化给本书带来很大的冲击，有些内容失去了它存在理由，比如关于超值（upvalues）的复杂的解释。一些章节被重写，比如C API，另外一些章节被增加进来，比如协同处理。
不太明显的是，Lua语言本身的发展对本书的完成也产生了很大的影响。一些语言的变化在本书中并没有被涵盖进来，这并非偶然的。在本书的创作过程中，有的时候在某个章节我会突然感觉很困惑，因为我不知道该从何开始或者怎样去讲问题阐述清楚。当你想尽力去解释清楚如何使用的前提是你应该觉得使用这个东西很容易，这表明Lua某些地方需要被改进。还有的时候，我顺利的写完某个章节，结果却是没有人能看得懂我写的或者没有人对我在这个章节内表达的观点达成一致。大部分情况下，这是我的过错因为我是个作家，偶尔我也会因此发现语言本身的一些需要改进的缺陷（举例来说，从upvalues到lexical scoping的转变是由无意义的尝试所带来的抱怨所引发的，在此书的先前的草稿里，把upvalues形容成是lexical scoping的一种）。
本书的完成必须服从语言的变化，本书在这个时候完成的原因：
<1> Lua 5.0是一个成熟的版本
<2> 语言变得越来越大，超出了最初本书的目标。此外一个原因是我迫切的想将Lua介绍给大家让更多的人了解Lua。
0.6 感谢
在完成本书的过程中，很多人给了我极大的帮助：
Luiz Henrique de Figueiredo和Waldemar Celes给了我很大的帮助，使得本书能够更好完成，Luiz Henrique也帮助设计了本书的内部。
Noemi Rodriguez, André Carregal, Diego Nehab, 以及 Gavin Wraith阅读了本书的草稿提出了很多有价值的建议。
Renato Cerqueira, Carlos Cassino, Tomás Guisasola, Joe Myers和Ed Ferguson也提出了很多重要的建议。
Alexandre Nakonechnyj负责本书的封面和内部设计。
Rosane Teles负责CIP数据的准备。
谢谢他们所有人。
第1章 起点
写一个最最简单的程序——Hello World。
print("Hello World")
假定你把上面这句保存在hello.lua文件中，你在命令行只需要：
prompt> lua hello.lua
看到结果了吗?
让我们来看一个稍微复杂点的例子：
-- defines a factorial function
function fact (n)
    if n == 0 then
       return 1
    else
       return n * fact(n-1)
    end
end

print("enter a number:")
a = io.read("*number")      -- read a number
print(fact(a))
这个例子定义了一个函数，计算输入参数n的阶乘；本例要求用户输入一个数字n，然后打印n的阶乘。
1.1 Chunks
Chunk是一系列语句，Lua执行的每一块语句，比如一个文件或者交互模式下的每一行都是一个Chunk。
每个语句结尾的分号（;）是可选的，但如果同一行有多个语句最好用；分开
a = 1   b = a*2    -- ugly, but valid
一个Chunk可以是一个语句，也可以是一系列语句的组合，还可以是函数，Chunk可以很大，在Lua中几个MByte的Chunk是很常见的。
你还可以以交互模式运行Lua，不带参数运行Lua:
Lua 5.0  Copyright © 1994-2003 Tecgraf, PUC-Rio
> 
你键入的每个命令（比如："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，将会在指定的目录下搜索文件，如果环境变量没有设好，上面的命令可能不能正确运行。我们将在8.1节详细更详细的讨论the require function）
-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)
end

function twice (x)
    return 2*x
end
在交互模式下：
> dofile("lib1.lua")     -- load your library
> n = norm(3.4, 1.0)
> print(twice(n))        --> 7.0880180586677
-i和dofile在调试或者测试Lua代码时是很方便的。
1.2 全局变量
全局变量不需要声明，给一个变量赋值后即创建了这个全局变量，访问一个没有初始化的全局变量也不会出错，只不过得到的结果是：nil.
print(b)      --> nil
b = 10
print(b)      --> 10
如果你想删除一个全局变量，只需要将变量负值为nil
b = nil
print(b)      --> nil
这样变量b就好像从没被使用过一样.换句话说, 当且仅当一个变量不等于nil时，这个变量存在。
1.2 词法约定
标示符：字母(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
while
注意：Lua是大小写敏感的.
注释：单行注释:--
多行注释：--[[    --]]
--[[
print(10)         -- no action (comment)
--]]
1.4 命令行方式
lua [options] [script [args]]
-e：直接将命令传入Lua
prompt> lua -e "print(math.sin(12))"   --> -0.53657291800043
-l：加载一个文件.
-i：进入交互模式.
_PROMPT内置变量作为交互模式的提示符
prompt> lua -i -e "_PROMPT=' lua> '"
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"
 第2章 类型和值
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)
a = 10
print(type(a))    --> number
a = "a string!!"
print(type(a))    --> string
a = print         -- yes, this is valid!
a(type(a))        --> function
注意上面最后两行，我们可以使用function像使用其他值一样使用（更多的介绍参考第六章）。一般情况下同一变量代表不同类型的值会造成混乱，最好不要用，但是特殊情况下可以带来便利，比如nil。
 2.1 Nil
Lua中特殊的类型，他只有一个值：nil；一个全局变量没有被赋值以前默认值为nil；给全局变量赋nil可以删除该变量。
2.2 Booleans
两个取值false和true。但要注意Lua中所有的值都可以作为条件。在控制结构的条件中除了false和nil为假，其他值都为真。所以Lua认为0和空串都是真。
2.3 Numbers
表示实数，Lua中没有整数。一般有个错误的看法CPU运算浮点数比整数慢。事实不是如此，用实数代替整数不会有什么误差（除非数字大于100,000,000,000,000）。Lua的numbers可以处理任何长整数不用担心误差。你也可以在编译Lua的时候使用长整型或者单精度浮点型代替numbers，在一些平台硬件不支持浮点数的情况下这个特性是非常有用的，具体的情况请参考Lua发布版所附的详细说明。和其他语言类似，数字常量的小数部分和指数部分都是可选的，数字常量的例子：
4      0.4    4.57e-3       0.3e12     5e+20
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中的转义序列有：
\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     -- 右中括号
例子：
> print("one line\nnext line\n\"in quotes\", 'in quotes'")
one line
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 = [[
<HTML>
<HEAD>
<TITLE>An HTML Page</TITLE>
</HEAD>
<BODY>
Lua
[[a text between double brackets]]
</BODY>
</HTML>
]]

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")
else
    print(n*2)
end
反之,可以调用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
c = a
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
    x = v
end
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
3.5 优先级
从高到低的顺序：
^
not    - (unary)
*      /
+      -
..
<      >      <=     >=     ~=     ==
and
or
除了^和..外所有的二元运算符都是左连接的。
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]...
p