lua教程

--------------------------------------
----------------------------------------
-----------------------------------------

第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 数据的准备。

谢谢他们所有人。

 (LUA教程)第1章 起点收藏

新一篇: (LUA教程)第2章 类型和值 | 旧一篇: (LUA教程)第0章 序言

写一个最最简单的程序—— 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.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

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"

    

(LUA教程)第2章 类型和值收藏

新一篇: (LUA教程)第3章 表达式 | 旧一篇: (LUA教程)第1章 起点

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 章节中我们将详细讨论。

在第九章讨论协同操作的时候，我们介绍线程。

---------------------------------------------------

(LUA教程)第3章 表达式收藏

新一篇: (LUA教程)第4章 基本语法 | 旧一篇: (LUA教程)第2章 类型和值

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]...

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"

x.f = w

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}

end

这段代码从标准输入读进每行，然后反序形成链表。下面的代码打印链表的内容：

l = list

while l do

    print(l.value)

    l = l.next

end

在同一个构造函数中可以混合列表风格和 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"}