delphi主程序

经测试成功，程序会在label1中根据用户输入的日期来输出是今天，还是n天前或者n天后。

b = {}

setmetatable(a, b)

b.__mode = \”k\” — now `a’ has weak keys

key = {} — creates first key

a[key] = 1

key = {} — creates second key

a[key] = 2

collectgarbage() — forces a garbage collection cycle

for k, v in pairs(a) do print(v) end

–> 2

在这个例子中，第二个赋值语句key={}覆盖了第一个key的值。 当垃圾收集器工作时，在其他地方没有指向第一个key的引用，所以它被收集了，因此相对应的table中的入口也同时被移除了。 可是，第二个key，仍然是占用活动的变量key，所以它不会被收集。
要注意，只有对象才可以从一个weak table中被收集。 比如数字和布尔值类型的值，都是不会被收集的。 例如，如果我们在table中插入了一个数值型的key（在前面那个例子中），它将永远不会被收集器从table中移除。 当然，如果对应于这个数值型key的vaule被收集，那么它的整个入口将会从weak table中被移除。
关于字符串的一些细微差别： 从上面的实现来看，尽管字符串是可以被收集的，他们仍然跟其他可收集对象有所区别。 其他对象，比如tables和函数，他们都是显示的被创建。 比如，不管什么时候当Lua遇到{}时，它建立了一个新的table。 任何时候这个 function（）。。。end建立了一个新的函数（实际上是一个闭包）。 然而，Lua 见到“a”..”b”的时候会创建一个新的字符串？ 如果系统中已经有一个字符串”ab”的话怎么办？ Lua会重新建立一个新的？ 编译器可以在程序运行之前创建字符串么？ 这无关紧要： 这些是实现的细节。 因此，从程序员的角度来看，字符串是值而不是对象。 所以，就像数值或布尔值，一个字符串不会从weak tables中被移除（除非它所关联的vaule被收集）。
17.1记忆函数
一个相当普遍的编程技术是用空间来换取时间。 你可以通过记忆函数结果来进行优化，当你用同样的参数再次调用函数时，它可以自动返回记忆的结果。
想像一下一个通用的服务器，接收包含Lua代码的字符串请求。 每当它收到一个请求，它调用loadstring加载字符串，然后调用函数进行处理。 然而，loadstring是一个“巨大”的函数，一些命令在服务器中会频繁地使用。 不需要反复调用loadstring和后面接着的closeconnection（），服务器可以通过使用一个辅助table来记忆loadstring的结果。 在调用loadstring之前，服务器会在这个table中寻找这个字符串是否已经有了翻译好的结果。 如果没有找到，那么（而且只是这个情况）服务器会调用loadstring并把这次的结果存入辅助table。 我们可以将这个操作包装为一个函数：
local results = {}

function mem_loadstring (s)

if results[s] then — result available?

return results[s] — reuse it

else

local res = loadstring(s) — compute new result

results[s] = res — save for later reuse

return res

end

end

这个方案的存储消耗可能是巨大的。 尽管如此，它仍然可能会导致意料之外的数据冗余。 尽管一些命令一遍遍的重复执行，但有些命令可能只运行一次。 渐渐地，这个table积累了服务器所有命令被调用处理后的结果；早晚有一天，它会挤爆服务器的内存。 一个weak table提供了对于这个问题的简单解决方案。 如果这个结果表中有weak值，每次的垃圾收集循环都会移除当前时间内所有未被使用的结果（通常是差不多全部）：
local results = {}

setmetatable(results, {__mode = \”v\”}) — make values weak

function mem_loadstring (s)

… — as before

setmetatable(results, {__mode = \”kv\”})

事实上，因为table的索引下标经常是字符串式的，如果愿意，我们可以将table全部置weak：
setmetatable(results, {__mode = \”kv\”})

最终结果是完全一样的。
记忆技术在保持一些类型对象的唯一性上同样有用。 例如，假如一个系统将通过tables表达颜色，通过有一定组合方式的红色，绿色，蓝色。 一个自然颜色调色器通过每一次新的请求产生新的颜色：
function createRGB (r, g, b)

return {red = r, green = g, blue = b}

end

使用记忆技术，我们可以将同样的颜色结果存储在同一个table中。 为了建立每一种颜色唯一的key，我们简单的使用一个分隔符连接颜色索引下标：
local results = {}

setmetatable(results, {__mode = \”v\”}) — make values weak

function createRGB (r, g, b)

local key = r .. \”-\” .. g .. \”-\” .. b

if results[key] then return results[key]

else

local newcolor = {red = r, green = g, blue = b}

results[key] = newcolor

return newcolor

end

end

一个有趣的后果就是，用户可以使用这个原始的等号运算符比对操作来辨别颜色，因为两个同时存在的颜色通过同一个的table来表达。 要注意，同样的颜色可能在不同的时间通过不同的tales来表达，因为垃圾收集器一次次的在清理结果table。 然而，只要给定的颜色正在被使用，它就不会从结果中被移除。 所以，任何时候一个颜色在同其他颜色进行比较的时候存活的够久，它的结果镜像也同样存活。
17.2关联对象属性
weak tables的另一个重要的应用就是和对象的属性关联。 在一个对象上加入更多的属性是无时无刻都会发生的： 函数名称，tables的缺省值，数组的大小，等等。
当对象是表的时候，我们可以使用一个合适的唯一key来将属性保存在表中。 就像我们在前面说的那样，一个很简单并且可以防止错误的方法是建立一个新的对象（典型的比如table）然后把它当成key使用。 然而，如果对象不是table，它就不能自己保存自身的属性。 即使是tables，有些时候我们可能也不想把属性保存在原来的对象中去。 例如，我们可能希望将属性作为私有的，或者我们不想在访问table中元素的时候受到这个额外的属性的干扰。 在上述这些情况下，我们需要一个替代的方法来将属性和对象联系起来。 当然，一个外部的table提供了一种理想化的方式来联系属性和对象（tables有时被称作联合数组并不偶然）。 我们把这个对象当作key来使用，他们的属性作为vaule。 一个外部的table可以保存任何类型对象的属性（就像Lua允许我们将任何对象看作key）。 此外，保存在一个外部table的属性不会妨碍到其他的对象，并且可以像这个table本身一样私有化。
然而，这个看起来完美的解决方案有一个巨大的缺点： 一旦我们在一个table中将一个对象使用为key，我们就将这个对象锁定为永久存在。 Lua不能收集一个正在被当作key使用的对象。 如果我们使用一个普通的table来关联函数和名字，那么所有的这些函数将永远不会被收集。 正如你所想的那样，我们可以通过使用weak table来解决这个问题。 这一次，我们需要weak keys。 一旦没有其他地方的引用，weak keys并不会阻止任何的key被收集。 从另一方面说，这个table不会存在weak vaules；否则，活动对象的属性就可能被收集了。
Lua本身使用这种技术来保存数组的大小。 像我们下面即将看到的那样，table库提供了一个函数来设定数组的大小，另一个函数来读取数组的大小。 当你设定了一个数组的大小，Lua 将这个尺寸保存在一个私有的weak table，索引就是数组本身，而value就是它的尺寸。
17.3重述带有默认值的表
在章节13.4.3，我们讨论了怎样使用非nil的默认值来实现表。 我们提到一种特殊的技术并注释说另外两种技术需要使用weak tables，所以我们推迟在这里介绍他们。 现在，介绍她们的时候了。 就像我们说的那样，这两种默认值的技术实际上来源于我们前面提到的两种通用的技术的特殊应用： 对象属性和记忆。
在第一种解决方案中，我们使用weak table来将默认vaules和每一个table相联系：
local defaults = {}

setmetatable(defaults, {__mode = \”k\”})

local mt = {__index = function (t) return defaults[t] end}

function setDefault (t, d)

defaults[t] = d

setmetatable(t, mt)

end

如果默认值没有weak的keys，它就会将所有的带有默认值的tables设定为永久存在。 在第二种方法中，我们使用不同的metatables来保存不同的默认值，但当我们重复使用一个默认值的时候，重用同一个相同的metatable。 这是一个典型的记忆技术的应用：
local metas = {}

setmetatable(metas, {__mode = \”v\”})

function setDefault (t, d)

local mt = metas[d]

if mt == nil then

mt = {__index = function () return d end}

metas[d] = mt — memoize

end

setmetatable(t, mt)

end

这种情况下，我们使用weak vaules，允许将不会被使用的metatables 可以被回收。
把这两种方法放在一起，哪个更好？ 通常，取决于具体情况。 它们都有相似的复杂性和相似的性能。 第一种方法需要在每个默认值的tables中添加一些文字（一个默认的入口）。 第二种方法需要在每个不同的默认值加入一些文字（一个新的表，一个新的闭包，metas中新增入口）。 所以，如果你的程序有数千个tables，而这些表只有很少数带有不同默认值的，第二种方法显然更优秀。 另一方面，如果只有很少的tabels可以共享相同的默认vaules，那么你还是用第一种方法吧。

function Account.withdraw (v)

Account.balance = Account.balance – v

end

这个定义创建了一个新的函数，并且保存在Account对象的withdraw域内，下面我们可以这样调用：
Account.withdraw(100.00)

这种函数就是我们所谓的方法，然而，在一个函数内部使用全局变量名Account是一个不好的习惯。首先，这个函数只能在这个特殊的对象(译者：指Account)中使用；第二，即使对这个特殊的对象而言，这个函数也只有在对象被存储在特殊的变量(译者：指Account)中才可以使用。如果我们改变了这个对象的名字，函数withdraw将不能工作：
a = Account; Account = nil

a.withdraw(100.00) — ERROR!

这种行为违背了前面的对象应该有独立的生命周期的原则。
一个灵活的方法是：定义方法的时候带上一个额外的参数，来表示方法作用的对象。这个参数经常为self或者this：
function Account.withdraw (self, v)

self.balance = self.balance – v

end

现在，当我们调用这个方法的时候不需要指定他操作的对象了：
a1 = Account; Account = nil
…
a1.withdraw(a1, 100.00) — OK

使用self参数定义函数后，我们可以将这个函数用于多个对象上：
a2 = {balance=0, withdraw = Account.withdraw}

…

a2.withdraw(a2, 260.00)

self参数的使用是很多面向对象语言的要点。大多数OO语言将这种机制隐藏起来，这样程序员不必声明这个参数(虽然仍然可以在方法内使用这个参数)。Lua也提供了通过使用冒号操作符来隐藏这个参数的声明。我们可以重写上面的代码：
function Account:withdraw (v)

self.balance = self.balance – v

end

调用方法如下：
a:withdraw(100.00)

冒号的效果相当于在函数定义和函数调用的时候，增加一个额外的隐藏参数。这种方式只是提供了一种方便的语法，实际上并没有什么新的内容。我们可以使用dot语法定义函数而用冒号语法调用函数，反之亦然，只要我们正确的处理好额外的参数：
Account = { balance=0,

withdraw = function (self, v)

self.balance = self.balance – v

end

}

function Account:deposit (v)

self.balance = self.balance + v

end

Account.deposit(Account, 200.00)

Account:withdraw(100.00)

现在我们的对象拥有一个标示符，一个状态和操作这个状态的方法。但他们依然缺少一个class系统，继承和隐藏。先解决第一个问题：我们如何才能创建拥有相似行为的多个对象呢？明确地说，我们怎样才能创建多个accounts?(译者：针对上面的对象Account而言)
16.1类
一些面向对象的语言中提供了类的概念，作为创建对象的模板。在这些语言里，对象是类的实例。Lua不存在类的概念，每个对象定义他自己的行为并拥有自己的形状(shape)。然而，依据基于原型(prototype)的语言比如Self和NewtonScript，在Lua中仿效类的概念并不难。在这些语言中，对象没有类。不过，每一个韵笥幸桓鲈停褪且桓銎胀ǖ亩韵螅ㄒ辶说谝桓龆韵笳也坏匠稍薄Ｔ谡庑┯镅灾形吮硎纠啵颐羌虻ゴ唇ㄒ桓龆韵笞庞美醋魑渌韵蟮脑汀２还苁抢嗷故窃投际嵌ㄒ辶艘恍┖芏喽韵蠊蚕淼男形牡胤健?
在Lua中，使用前面章节我们介绍过的继承的思想，很容易实现prototypes.更明确的来说，如果我们有两个对象a和b，我们想让b作为a的prototype只需要：
setmetatable(a, {__index = b})

这样，对象a调用任何不存在的成员都会到对象b中查找。术语上，可以将b看作类，a看作对象。回到前面银行账号的例子上。为了使得新创建的对象拥有和Account相似的行为，我们使用__index metamethod，使新的对象继承Account。注意一个小的优化：我们不需要创建一个额外的表作为account对象的metatable；我们可以用Account表本身作为metatable：
function Account:new (o)

o = o or {} — create object if user does not provide one

setmetatable(o, self)

self.__index = self

return o

end

(当我们调用Account:new时，self等于Account；因此我们可以直接使用Account取代self。然而，使用self在我们下一节介绍类继承时更合适).有了这段代码之后，当我们创建一个新的账号并且掉用一个方法的时候，有什么发生呢？
a = Account:new{balance = 0}

a:deposit(100.00)

当我们创建这个新的账号a的时候，a将Account作为他的metatable(调用Account:new时，self即Account)。当我们调用a:deposit(100.00)，我们实际上调用的是a.deposit(a,100.00)(冒号仅仅是语法上的便利)。然而，Lua在表a中找不到deposit，因此他回到metatable的__index对应的表中查找，情况大致如下:
getmetatable(a).__index.deposit(a, 100.00)

a的metatable是Account ，Account.__index也是Account (因为new函数中self.__index = self). 所以我们可以重写上面的代码为：
Account.deposit(a, 100.00)

也就是说，Lua传递a作为self参数调用原始的deposit函数。所以，新的账号对象从Account继承了deposit方法。使用同样的机制，可以从Account继承所有的域。继承机制不仅对方法有效，对表中所有的域都有效。所以，一个类不仅提供方法，也提供了他的实例的成员的默认值。记住：在我们第一个Account定义中，我们提供了成员balance默认值为0，所以，如果我们创建一个新的账号而没有提供balance的初始值，他将继承默认值：
b = Account:new()

print(b.balance) –> 0

当我们调用b的deposit方法时，实际等价于：
b.balance = b.balance + v

(因为self就是b). 表达式b.balance 等于0并且初始的存款(b.balance)被赋予b.balance。下一次我们访问这个值的时候，不会在涉及到index metamethod，因为b已经存在他自己的balance域。
16.2继承
通常面向对象语言中，继承使得类可以访问其他类的方法，这在Lua中也很容易现实：
假定我们有一个基类Account:
Account = {balance = 0}

function Account:new (o)

o = o or {}

setmetatable(o, self)

self.__index = self

return o

end

function Account:deposit (v)

self.balance = self.balance + v

end

function Account:withdraw (v)

if v > self.balance then error”insufficient funds” end

self.balance = self.balance – v

end

我们打算从基类派生出一个子类SpecialAccount，这个子类允许客户取款超过它的存款余额限制，我们从一个空类开始，从基类继承所有操作：
SpecialAccount = Account:new()

到现在为止，SpecialAccount仅仅是Account的一个实例。现在奇妙的事情发生了：
s = SpecialAccount:new{limit=1000.00}

SpecialAccount从Account继承了new方法，当new执行的时候，self参数指向SpecialAccount. 所以, s的metatable是SpecialAccount, __index 也是SpecialAccount.这样，s继承了 SpecialAccount, 后者继承了Account. 当我们执行：
s:deposit(100.00)

Lua在s中找不到deposit域，他会到SpecialAccount中查找，在SpecialAccount中找不到，会到Account中查找。使得SpecialAccount特殊之处在于，它可以重定义从父类中继承来的方法：
function SpecialAccount:withdraw (v)

if v – self.balance >= self:getLimit() then

error”insufficient funds”

end

self.balance = self.balance – v

end

function SpecialAccount:getLimit ()

return self.limit or 0

end

现在，当我们调用方法s:withdraw(200.00), Lua不会到Account中查找,因为它第一次救在SpecialAccount中发现了新的withdraw方法，由于s.limit等于1000.00 (记住我们创建s的时候初始化了这个值),程序执行了取款操作，s的balance变成了负值。
在Lua中面向对象有趣的一个方面是你不需要创建一个新类去指定一个新的行为。如果仅仅一个对象需要特殊的行为，你可以直接在对象中实现，例如，如果账号s表示一些特殊的客户：取款限制是他的存款的10%，你只需要修改这个单独的账号：
function s:getLimit ()

return self.balance * 0.10

end

这样声明之后，调用s:withdraw(200.00)将运行SpecialAccount的withdraw 方法,但是当方法调用self:getLimit时,最后的定义被触发。
16.3多重继承
由于Lua中的对象不是元生(primitive)的，所以在Lua中有很多方法可以实现面向对象的程序设计。我们前面所见到的使用index metamethod的方法可能是简洁、性能、灵活各方面综合最好的。然而，针对一些特殊情况也有更适合的实现方式。下面我们在Lua中多重继承的实现。
实现的关键在于：将函数用作__index。记住，当一个表的metatable存在一个__index函数时，如果Lua调用一个原始表中不存在的函数，Lua将调用这个__index指定的函数。这样可以用__index实现在多个父类中查找子类不存在的域。
多重继承意味着一个类拥有多个父类，所以，我们不能用创建一个类的方法去创建子类。取而代之的是，我们定义一个特殊的函数createClass来完成这个功能，将被创建的新类的父类作为这个函数的参数。这个函数创建一个表来表示新类，并且将它的metatable设定为一个可以实现多继承的__index metamethod。尽管是多重继承，每一个实例依然属于一个在其中能找得到它需要的方法的单独的类。所以，这种类和父类之间的关系与传统的类与实例的关系是有区别的。特别是，一个类不能同时是其实例的metatable又是自己的metatable。在下面的实现中，我们将一个类作为他的实例的metatable，创建另一个表作为类的metatable:

– look up for `k’ in list of tables `plist’

local function search (k, plist)

for i=1, table.getn(plist) do

local v = plist[i][k] — try `i’-th superclass

if v then return v end

end

end

function createClass (…)

local c = {} — new class

– class will search for each method in the list of its

– parents (`arg’ is the list of parents)

setmetatable(c, {__index = function (t, k)

return search(k, arg)

end})

– prepare `c’ to be the metatable of its instances

c.__index = c

– define a new constructor for this new class

function c:new (o)

o = o or {}

setmetatable(o, c)

return o

end

– return new class

return c

end

让我们用一个小例子阐明一下createClass的使用，假定我们前面的类Account和另一个类Named，Named只有两个方法setname and getname:
Named = {}

function Named:getname ()

return self.name

end

function Named:setname (n)

self.name = n

end

为了创建一个继承于这两个类的新类，我们调用createClass：
NamedAccount = createClass(Account, Named)

为了创建和使用实例，我们像通常一样：
account = NamedAccount:new{name = “Paul”}

print(account:getname()) –> Paul

现在我们看看上面最后一句发生了什么，Lua在account中找不到getname，因此他查找account的metatable的__index，即NamedAccount。但是，NamedAccount也没有getname，因此Lua查找NamedAccount 的metatable的__index，因为这个域包含一个函数，Lua调用这个函数并首先到Account中查找getname，没有找到，然后到Named中查找，找到并返回最终的结果。当然，由于搜索的复杂性，多重继承的效率比起单继承要低。一个简单的改善性能的方法是将继承方法拷贝到子类。使用这种技术，index方法如下：
…

setmetatable(c, {__index = function (t, k)

local v = search(k, arg)

t[k] = v — save for next access

return v

end})

…

应用这个技巧，访问继承的方法和访问局部方法一样快(特别是第一次访问)。缺点是系统运行之后，很难改变方法的定义，因为这种改变不能影响继承链的下端。
16.4私有性(privacy)
很多人认为私有性是面向对象语言的应有的一部分。每个对象的状态应该是这个对象自己的事情。在一些面向对象的语言中，比如C++和Java你可以控制对象成员变量或者成员方法是否私有。其他一些语言比如Smalltalk中，所有的成员变量都是私有，所有的成员方法都是公有的。第一个面向对象语言Simula不提供任何保护成员机制。
如前面我们所看到的Lua中的主要对象设计不提供私有性访问机制。部分原因因为这是我们使用通用数据结构tables来表示对象的结果。但是这也反映了后来的Lua的设计思想。Lua没有打算被用来进行大型的程序设计，相反，Lua目标定于小型到中型的程序设计，通常是作为大型系统的一部分。典型的，被一个或者很少几个程序员开发，甚至被非程序员使用。所以，Lua避免太冗余和太多的人为限制。如果你不想访问一个对象内的一些东西就不要访问(If you do not want to access something inside an object, just do not do it.)。
然而，Lua的另一个目标是灵活性，提供程序员元机制(meta-mechanisms),通过他你可以实现很多不同的机制。虽然Lua中基本的面向对象设计并不提供私有性访问的机制，我们可以用不同的方式来实现他。虽然这种实现并不常用，但知道他也是有益的，不仅因为它展示了Lua的一些有趣的角落，也因为它可能是某些问题的很好地解决方案。设计的基本思想是，每个对象用两个表来表示：一个描述状态；另一个描述操作(或者叫接口)。对象本身通过第二个表来访问，也就是说，通过接口来访问对象。为了避免未授权的访问，表示状态的表中不涉及到操作；表示操作的表也不涉及到状态，取而代之的是，状态被保存在方法的闭包内。例如，用这种设计表述我们的银行账号，我们使用下面的函数工厂创建新的对象：
function newAccount (initialBalance)

local self = {balance = initialBalance}

local withdraw = function (v)

self.balance = self.balance – v

end

local deposit = function (v)

self.balance = self.balance + v

end

local getBalance = function () return self.balance end

return {

withdraw = withdraw,

deposit = deposit,

getBalance = getBalance

}

end

首先，函数创建一个表用来描述对象的内部状态，并保存在局部变量self内。然后，函数为对象的每一个方法创建闭包(也就是说，嵌套的函数实例)。最后，函数创建并返回外部对象，外部对象中将局部方法名指向最终要实现的方法。这儿的关键点在于：这些方法没有使用额外的参数self，代替的是直接访问self。因为没有这个额外的参数，我们不能使用冒号语法来访问这些对象。函数只能像其他函数一样调用：
acc1 = newAccount(100.00)

acc1.withdraw(40.00)

print(acc1.getBalance()) –> 60

这种设计实现了任何存储在self表中的部分都是私有的，newAccount返回之后，没有什么方法可以直接访问对象，我们只能通过newAccount中定义的函数来访问他。虽然我们的例子中仅仅将一个变量放到私有表中，但是我们可以将对象的任何的部分放到私有表中。我们也可以定义私有方法，他们看起来象公有的，但我们并不将其放到接口中。例如，我们的账号可以给某些用户取款享有额外的10%的存款上限，但是我们不想用户直接访问这种计算的详细信息，我们实现如下：
function newAccount (initialBalance)

local self = {

balance = initialBalance,

LIM = 10000.00,

}

local extra = function ()

if self.balance > self.LIM then

return self.balance*0.10

else

return 0

end

end

local getBalance = function ()

return self.balance + self.extra()

end

…

这样，对于用户而言就没有办法直接访问extra函数了。
16.5Single-Method的对象实现方法
前面的OO程序设计的方法有一种特殊情况：对象只有一个单一的方法。这种情况下，我们不需要创建一个接口表，取而代之的是，我们将这个单一的方法作为对象返回。这听起来有些不可思议，如果需要可以复习一下Section 7.1，那里我们介绍了如何构造迭代子函数来保存闭包的状态。其实，一个保存状态的迭代子函数就是一个single-method对象。
关于single-method的对象一个有趣的情况是：当这个single-method实际是一个基于重要的参数而执行不同的任务的分派(dispatch)方法时。针对这种对象：
function newObject (value)

return function (action, v)

if action == “get” then return value

elseif action == “set” then value = v

else error(“invalid action”)

end

end

end

使用起来很简单：
d = newObject(0)

print(d(“get”)) –> 0

d(“set”, 10)

print(d(“get”)) –> 10

这种非传统的对象实现是非常有效的，语法 d(“set”,10)虽然很罕见，但也只不过比传统的d:set(10)长两个字符而已。每一个对象是用一个单独的闭包，代价比起表来小的多。这种方式没有继承但有私有性：访问对象状态的唯一方式是通过它的内部方法。
Tcl/Tk 的窗口部件(widgets)使用了相似的方法，在Tk中一个窗口部件的名字表示一个在窗口部件上执行各种可能操作的函数(a widget command)。

function complex.new (r, i) return {r=r, i=i} end

– defines a constant `i’

complex.i = complex.new(0, 1)

function complex.add (c1, c2)

return complex.new(c1.r + c2.r, c1.i + c2.i)

end

function complex.sub (c1, c2)

return complex.new(c1.r – c2.r, c1.i – c2.i)

end

function complex.mul (c1, c2)

return complex.new(c1.r*c2.r – c1.i*c2.i,

c1.r*c2.i + c1.i*c2.r)

end

function complex.inv ©

local n = c.r^2 + c.i^2

return complex.new(c.r/n, -c.i/n)

end

return complex

这个库定义了一个全局名：coplex。其他的定义都是放在这个表内。
有了上面的定义，我们就可以使用符合规范的任何复数操作了，如：
c = complex.add(complex.i, complex.new(10, 20))

这种使用表来实现的包和真正的包的功能并不完全相同。首先，我们对每一个函数定义都必须显示的在前面加上包的名称。第二，同一包内的函数相互调用必须在被调用函数前指定包名。我们可以使用固定的局部变量名，来改善这个问题，然后，将这个局部变量赋值给最终的包。依据这个原则，我们重写上面的代码：
local P = {}

complex = P — package name

P.i = {r=0, i=1}

function P.new (r, i) return {r=r, i=i} end

function P.add (c1, c2)

return P.new(c1.r + c2.r, c1.i + c2.i)

end

…

当在同一个包内的一个函数调用另一个函数的时候(或者她调用自身)，他仍然需要加上前缀名。至少，它不再依赖于固定的包名。另外，只有一个地方需要包名。可能你注意到包中最后一个语句：
return complex

这个return语句并非必需的，因为package已经赋值给全局变量complex了。但是，我们认为package打开的时候返回本身是一个很好的习惯。额外的返回语句并不会花费什么代价，并且提供了另一种操作package的可选方式。
私有成员(Privacy)
有时候，一个package公开他的所有内容，也就是说，任何package的客户端都可以访问他。然而，一个package拥有自己的私有部分(也就是只有package本身才能访问)也是很有用的。在Lua中一个传统的方法是将私有部分定义为局部变量来实现。例如，我们修改上面的例子增加私有函数来检查一个值是否为有效的复数：
local P = {}

complex = P

local function checkComplex ©

if not ((type© == “table”) and

tonumber(c.r) and tonumber(c.i)) then

error(“bad complex number”, 3)

end

end

function P.add (c1, c2)

checkComplex(c1);

checkComplex(c2);

return P.new(c1.r + c2.r, c1.i + c2.i)

end

…

return P

这种方式各有什么优点和缺点呢？package中所有的名字都在一个独立的命名空间中。Package中的每一个实体(entity)都清楚地标记为公有还是私有。另外，我们实现一个真正的隐私(privacy):私有实体在package外部是不可访问的。缺点是访问同一个package内的其他公有的实体写法冗余，必须加上前缀P.。还有一个大的问题是，当我们修改函数的状态(公有变成私有或者私有变成公有)我们必须修改函数得调用方式。
有一个有趣的方法可以立刻解决这两个问题。我们可以将package内的所有函数都声明为局部的，最后将他们放在最终的表中。按照这种方法，上面的complex package修改如下：
local function checkComplex ©

if not ((type© == “table”)

and tonumber(c.r) and tonumber(c.i)) then

error(“bad complex number”, 3)

end

end

local function new (r, i) return {r=r, i=i} end

local function add (c1, c2)

checkComplex(c1);

checkComplex(c2);

return new(c1.r + c2.r, c1.i + c2.i)

end

…

complex = {

new = new,

add = add,

sub = sub,

mul = mul,

div = div,

}

现在我们不再需要调用函数的时候在前面加上前缀，公有的和私有的函数调用方法相同。在package的结尾处，有一个简单的列表列出所有公有的函数。可能大多数人觉得这个列表放在package的开始处更自然，但我们不能这样做，因为我们必须首先定义局部函数。
包与文件
我们经常写一个package然后将所有的代码放到一个单独的文件中。然后我们只需要执行这个文件即加载package。例如，如果我们将上面我们的复数的package代码放到一个文件complex.lua中，命令“require complex”将打开这个package。记住require命令不会将相同的package加载多次。
需要注意的问题是，搞清楚保存package的文件名和package名的关系 。当然，将他们联系起来是一个好的想法，因为require命令使用文件而不是packages。一种解决方法是在package的后面加上后缀(比如.lua)来命名文件。Lua并不需要固定的扩展名，而是由你的路径设置决定。例如，如果你的路径包含：”/usr/local/lualibs/?.lua”，那么复数package可能保存在一个complex.lua文件中。
有些人喜欢先命名文件后命名package。也就是说，如果你重命名文件，package也会被重命名。这个解决方法提供了很大的灵活性。例如，如果你有两个有相同名称的package，你不需要修改任何一个，只需要重命名一下文件。在Lua中我们使用_REQUIREDNAME变量来重命名。记住，当require加载一个文件的时候，它定义了一个变量来表示虚拟的文件名。因此，在你的package中可以这样写：

local P = {} — package

if _REQUIREDNAME == nil then

complex = P

else

_G[_REQUIREDNAME] = P

end

代码中的if测试使得我们可以不需要require就可以使用package。如果_REQUIREDNAME没有定义，我们用固定的名字表示package(例子中complex)。另外，package使用虚拟文件名注册他自己。如果以使用者将库放到文件cpx.lua中并且运行require cpx，那么package将本身加载到表cpx中。如果其他的使用者将库改名为cpx_v1.lua并且运行require cpx_v1，那么package将自动将本身加载到表cpx_v1当中。
使用全局表
上面这些创建package的方法的缺点是：他们要求程序员注意很多东西，比如，在声明的时候也很容易忘掉local关键字。全局变量表的Metamethods提供了一些有趣的技术，也可以用来实现package。这些技术中共同之处在于：package使用独占的环境。这很容易实现：如果我们改变了package主chunk的环境，那么由package创建的所有函数都共享这个新的环境。
最简单的技术实现。一旦package有一个独占的环境，不仅所有她的函数共享环境，而且它的所有全局变量也共享这个环境。所以，我们可以将所有的公有函数声明为全局变量，然后他们会自动作为独立的表(表指package的名字)存在，所有package必须要做的是将这个表注册为package的名字。下面这段代码阐述了复数库使用这种技术的结果：

local P = {}

complex = P

setfenv(1, P)

现在，当我们声明函数add,她会自动变成 complex.add:
function add (c1, c2)

return new(c1.r + c2.r, c1.i + c2.i)

end

另外，我们可以在这个package中不需要前缀调用其他的函数。例如，add函数调用new函数，环境会自动转换为complex.new。这种方法提供了对package很好的支持：程序员几乎不需要做什么额外的工作，调用同一个package内的函数不需要前缀，调用公有和私有函数也没什么区别。如果程序员忘记了local关键字，也不会污染全局命名空间，只不过使得私有函数变成公有函数而已。另外，我们可以将这种技术和前一节我们使用的package名的方法组合起来：

local P = {} — package

if _REQUIREDNAME == nil then

complex = P

else

_G[_REQUIREDNAME] = P

end

setfenv(1, P)

这样就不能访问其他的packages了。一旦我们将一个空表P作为我们的环境，我们就失去了访问所有以前的全局变量。下面有好几种方法可以解决这个问题，但都各有利弊。
最简单的解决方法是使用继承，像前面我们看到的一样：
local P = {} — package

setmetatable(P, {__index = _G})

setfenv(1, P)

(你必须在调用setfenv 之前调用setmetatable，你能说出原因么？) 使用这种结构，package就可以直接访问所有的全局标示符，但必须为每一个访问付出一小点代价。理论上来讲，这种解决方法带来一个有趣的结果：你的package现在包含了所有的全局变量。例如，使用你的package人也可以调用标准库的sin函数： complex.math.sin(x). (Perl’s package 系统也有这种特性.)
另外一种快速的访问其他packages的方法是声明一个局部变量来保存老的环境：
local P = {}

pack = P

local _G = _G

setfenv(1, P)

现在，你必须对外部的访问加上前缀_G., 但是访问速度更快，因为这不涉及到metamethod 。与继承不同的是这种方法，使得你可以访问老的环境；这种方法的好与坏是有争议的，但是有时候你可能需要这种灵活性。
一个更加正规的方法是：只把你需要的函数或者packages声明为local：
local P = {}

pack = P

– Import Section:

– declare everything this package needs from outside

local sqrt = math.sqrt

local io = io

– no more external access after this point

setfenv(1, P)

这一技术要求稍多，但他使你的package的独立性比较好。他的速度也比前面那几种方法快。
其他一些技巧(Other Facilities)
正如前面我所说的，用表来实现packages过程中可以使用Lua的所有强大的功能。这里面有无限的可能性。在这里，我只给出一些建议。
我们不需要将package的所有公有成员的定义放在一起，例如，我们可以在一个独立分开的chunk中给我们的复数package增加一个新的函数：
function complex.div (c1, c2)

return complex.mul(c1, complex.inv(c2))

end

(但是注意：私有成员必须限制在一个文件之内，我认为这是一件好事。)反过来，我们可以在同一个文件之内定义多个packages，我们需要做的只是将每一个package放在一个do 代码块内，这样local变量才能被限制在那个代码块中。
在package外部，如果我们需要经常使用某个函数，我们可以给他们定义一个局部变量名：
local add, i = complex.add, complex.i

c1 = add(complex.new(10, 20), i)

如果我们不想一遍又一遍的重写package名，我们用一个短的局部变量表示package：
local C = complex

c1 = C.add(C.new(10, 20), C.i)

写一个函数拆开package也是很容易的，将package中所有的名字放到全局命名空间即可：
function openpackage (ns)

for n,v in pairs(ns) do _G[n] = v end

end

openpackage(complex)

c1 = mul(new(10, 20), i)

如果你担心打开package的时候会有命名冲突，可以在赋值以前检查一下名字是否存在：
function openpackage (ns)

for n,v in pairs(ns) do

if _G[n] ~= nil then

error(“name clash: ” .. n .. ” is already defined”)

end

_G[n] = v

end

end

由于packages本身也是表，我们甚至可以在packages中嵌套packages；也就是说我们在一个package内还可以创建package，然后很少有必要这么做。
另一个有趣之处是自动加载：函数只有被实际使用的时候才会自动加载。当我们加载一个自动加载的package，会自动创建一个新的空表来表示package并且设置表的__index metamethod来完成自动加载。当我们调用任何一个没有被加载的函数的时候，__index metamethod将被触发去加载着个函数。当调用发现函数已经被加载，__index将不会被触发。
下面有一个简单的实现自动加载的方法。每一个函数定义在一个辅助文件中。(也可能一个文件内有多个函数)这些文件中的每一个都以标准的方式定义函数，例如：
function pack1.foo ()

…

end

function pack1.goo ()

…

end

然而，文件并不会创建package,因为当函数被加载的时候package已经存在了。
在主package中我们定义一个辅助表来记录函数存放的位置：
local location = {

foo = “/usr/local/lua/lib/pack1_1.lua”,

goo = “/usr/local/lua/lib/pack1_1.lua”,

foo1 = “/usr/local/lua/lib/pack1_2.lua”,

goo1 = “/usr/local/lua/lib/pack1_3.lua”,

}

下面我们创建package并且定义她的metamethod：
pack1 = {}

setmetatable(pack1, {__index = function (t, funcname)

local file = location[funcname]

if not file then

error(“package pack1 does not define ” .. funcname)

end

assert(loadfile(file))() — load and run definition

return t[funcname] — return the function

end})

return pack1

加载这个package之后，第一次程序执行pack1.foo() 将触发 __index metamethod, 接着发现函数有一个相应的文件，并加载这个文件。微妙之处在于：加载了文件，同时返回函数作为访问的结果。
因为整个系统(译者：这里可能指复数吧？)都使用Lua写的，所以很容易改变系统的行为。例如，函数可以是用C写的，在metamethod中用loadlib加载他。或者我们我们可以在全局表中设定一个metamethod来自动加载整个packages.这里有无限的可能等着你去发掘。

这一章我们将讨论一些如何操纵环境的有用的技术。

14.1使用动态名字访问全局变量
通常，赋值操作对于访问和修改全局变量已经足够。然而，我们经常需要一些原编程（meta-programming）的方式，比如当我们需要操纵一个名字被存储在另一个变量中的全局变量，或者需要在运行时才能知道的全局变量。为了获取这种全局变量的值，有的程序员可能写出下面类似的代码：
loadstring(“value = ” .. varname)()

or
value = loadstring(“return ” .. varname)()

如果varname是 x, 上面连接操作的结果为： “return x” (第一种形式为 “value = x”), 当运行时才会产生最终的结果。然而这段代码涉及到一个新的chunk的创建和编译以及其他很多额外的问题。你可以换种方式更高效更简洁的完成同样的功能，代码如下：
value = _G[varname]

因为环境是一个普通的表，所以你可以使用你需要获取的变量(变量名)索引表即可。
也可以用相似的方式对一个全局变量赋值：_G[varname] = value. 小心:一些程序员对这些函数很兴奋，并且可能写出这样的代码： _G["a"] = _G["var1"], 这只是a = var1的复杂的写法而已。
对前面的问题概括一下，表域可以是型如”io.read” or “a.b.c.d”的动态名字。我们用循环解决这个问题，从_G开始，一个域一个域的遍历：
function getfield (f)

local v = _G — start with the table of globals

for w in string.gfind(f, “[%w_]+”) do

v = v[w]

end

return v

end

我们使用string库的gfind函数来迭代f中的所有单词（单词指一个或多个子母下划线的序列）。 相对应的，设置一个域的函数稍微复杂些。赋值如：

a.b.c.d.e = v

实际等价于：
local temp = a.b.c.d

temp.e = v

也就是说，我们必须记住最后一个名字，必须独立的处理最后一个域。新的setfield函数当其中的域(译者注：中间的域肯定是表)不存在的时候还需要创建中间表。
function setfield (f, v)

local t = _G — start with the table of globals

for w, d in string.gfind(f, “([%w_]+)(.?)”) do

if d == “.” then — not last field?

t[w] = t[w] or {} — create table if absent

t = t[w] — get the table

else — last field

t[w] = v — do the assignment

end

end

end

这个新的模式匹配以变量w加上一个可选的点(保存在变量d中)的域。如果一个域名后面不允许跟上点，表明它是最后一个名字。（我们将在第20章讨论模式匹配问题）。使用上面的函数
setfield(“t.x.y”, 10)

创建一个全局变量表t,另一个表t.x，并且对t.x.y赋值为10：
print(t.x.y) –> 10

print(getfield(“t.x.y”)) –> 10

14.2声明全局变量
全局变量不需要声明，虽然这对一些小程序来说很方便，但程序很大时，一个简单的拼写错误可能引起bug并且很难发现。然而，如果我们喜欢，我们可以改变这种行为。因为Lua所有的全局变量都保存在一个普通的表中，我们可以使用metatables来改变访问全局变量的行为。
第一个方法如下：
setmetatable(_G, {

__newindex = function (_, n)

error(“attempt to write to undeclared variable “..n, 2)

end,

__index = function (_, n)

error(“attempt to read undeclared variable “..n, 2)

end,

})

这样一来，任何企图访问一个不存在的全局变量的操作都会引起错误：
> a = 1

stdin:1: attempt to write to undeclared variable a

但是我们如何声明一个新的变量呢？使用rawset，可以绕过metamethod:
function declare (name, initval)

rawset(_G, name, initval or false)

end

or 带有 false 是为了保证新的全局变量不会为 nil。注意：你应该在安装访问控制以前(before installing the access control)定义这个函数，否则将得到错误信息：毕竟你是在企图创建一个新的全局声明。只要刚才那个函数在正确的地方，你就可以控制你的全局变量了：
> a = 1

stdin:1: attempt to write to undeclared variable a

> declare”a”

> a = 1 — OK

但是现在，为了测试一个变量是否存在，我们不能简单的比较他是否为nil。如果他是nil访问将抛出错误。所以，我们使用rawget绕过metamethod:
if rawget(_G, var) == nil then

– `var’ is undeclared

…

end

改变控制允许全局变量可以为nil也不难，所有我们需要的是创建一个辅助表用来保存所有已经声明的变量的名字。不管什么时候metamethod被调用的时候，他会检查这张辅助表看变量是否已经存在。代码如下：
local declaredNames = {}

function declare (name, initval)

rawset(_G, name, initval)

declaredNames[name] = true

end

setmetatable(_G, {

__newindex = function (t, n, v)

if not declaredNames[n] then

error(“attempt to write to undeclared var. “..n, 2)

else

rawset(t, n, v) — do the actual set

end

end,

__index = function (_, n)

if not declaredNames[n] then

error(“attempt to read undeclared var. “..n, 2)

else

return nil

end

end,

})

两种实现方式，代价都很小可以忽略不计的。第一种解决方法：metamethods在平常操作中不会被调用。第二种解决方法：他们可能被调用，不过当且仅当访问一个值为nil的变量时。
14.3非全局的环境
全局环境的一个问题是，任何修改都会影响你的程序的所有部分。例如，当你安装一个metatable去控制全局访问时，你的整个程序都必须遵循同一个指导方针。如果你想使用标准库，标准库中可能使用到没有声明的全局变量，你将碰到坏运。
Lua 5.0 允许每个函数可以有自己的环境来改善这个问题，听起来这很奇怪；毕竟，全局变量表的目的就是为了全局性使用。然而在Section 15.4我们将看到这个机制带来很多有趣的结构，全局的值依然是随处可以获取的。
可以使用setfenv函数来改变一个函数的环境。Setfenv接受函数和新的环境作为参数。除了使用函数本身，还可以指定一个数字表示栈顶的活动函数。数字1代表当前函数，数字2代表调用当前函数的函数(这对写一个辅助函数来改变他们调用者的环境是很方便的), 依此类推. 下面这段代码是企图应用setfenv失败的例子：
a = 1 — create a global variable

– change current environment to a new empty table

setfenv(1, {})

print(a)

导致：
stdin:5: attempt to call global `print’ (a nil value)

(你必须在单独的chunk内运行这段代码，如果你在交互模式逐行运行他，每一行都是一个不同的函数，调用setfenv只会影响他自己的那一行。)一旦你改变了你的环境，所有全局访问都使用这个新的表，如果她为空，你就丢失所有你的全局变量，甚至_G，所以，你应该首先使用一些有用的值封装(populate)她，比如老的环境：
a = 1 — create a global variable

– change current environment

setfenv(1, {_G = _G})

_G.print(a) –> nil

_G.print(_G.a) –> 1

现在，当你访问 “global” _G, 他的值为旧的环境，其中你可以使用print函数。
你也可以使用继承封装(populate)你的新的环境：
a = 1

local newgt = {} — create new environment

setmetatable(newgt, {__index = _G})

setfenv(1, newgt) — set it

print(a) –> 1

在这段代码新的环境从旧的环境中继承了print和a；然而，任何赋值操作都对新表进行，不用担心误操作修改了全局变量表。另外，你仍然可以通过_G修改全局变量：
– continuing previous code

a = 10

print(a) –> 10

print(_G.a) –> 1

_G.a = 20

print(_G.a) –> 20

当你创建一个新的函数时，他从创建他的函数继承了环境变量。所以，如果一个chunk改变了他自己的环境，这个chunk所有在改变之后定义的函数都共享相同的环境，都会受到影响。这对创建命名空间是非常有用的机制，我们下一章将会看到。

13．1算术运算的Metamethods
这一部分我们通过一个简单的例子介绍如何使用metamethods。假定我们使用table来描述结合，使用函数来描述集合的并操作，交集操作，like操作。我们在一个表内定义这些函数，然后使用构造函数创建一个集合:
Set = {}

function Set.new (t)
local set = {}
for _, l in ipairs(t) do set[l] = true end
return set
end

function Set.union (a,b)
local res = Set.new{}
for k in pairs(a) do res[k] = true end
for k in pairs(b) do res[k] = true end
return res
end

function Set.intersection (a,b)
local res = Set.new{}
for k in pairs(a) do
res[k] = b[k]
end
return res
end
为了帮助理解程序运行结果，我们也定义了打印函数输出结果:
function Set.tostring (set)
local s = “{”
local sep = “”
for e in pairs(set) do
s = s .. sep .. e
sep = “, ”
end
return s .. “}”
end

function Set.print (s)
print(Set.tostring(s))
end
现在我们想加号运算符(+)执行两个集合的并操作，我们将所有集合共享一个metatable，并且为这个metatable添加如何处理相加操作。
第一步，我们定义一个普通的表，用来作为metatable。为避免污染命名空间，我们将其放在set内部。
Set.mt = {} — metatable for sets
第二步，修改set.new函数，增加一行，创建表的时候同时指定对应的metatable.
function Set.new (t) — 2nd version
local set = {}
setmetatable(set, Set.mt)
for _, l in ipairs(t) do set[l] = true end
return set
end
这样一来，set.new创建的所有的集合都有相同的metatable了：
s1 = Set.new{10, 20, 30, 50}
s2 = Set.new{30, 1}
print(getmetatable(s1)) –> table: 00672B60
print(getmetatable(s2)) –> table: 00672B60
第三步，给metatable增加__add函数。
Set.mt.__add = Set.union
当Lua试图对两个集合相加时，将调用这个函数，以两个相加的表作为参数。
通过metamethod，我们可以对两个集合进行相加：
s3 = s1 + s2
Set.print(s3) –> {1, 10, 20, 30, 50}
同样的我们可以使用相乘运算符来定义集合的交集操作
Set.mt.__mul = Set.intersection

Set.print((s1 + s2)*s1) –> {10, 20, 30, 50}
对于每一个算术运算符，metatable都有对应的域名与其对应，除了__add,__mul外，还有__sub(减),__div(除),__unm(负),__pow(幂)，我们也可以定义__concat定义连接行为。
当我们对两个表进行加没有问题，但如果两个操作数有不同的metatable例如：
s = Set.new{1,2,3}
s = s + 8
Lua选择metamethod的原则：如果第一个参数存在带有__add域的metatable，Lua使用它作为metamethod，和第二个参数无关;
否则第二个参数存在带有__add域的metatable，Lua使用它作为metamethod 否则报错。
Lua不关心这种混合类型的，如果我们运行上面的s=s+8的例子在Set.union发生错误:
bad argument #1 to `pairs’ (table expected, got number)
如果我们想得到更加清楚地错误信息，我们需要自己显式的检查操作数的类型：
function Set.union (a,b)
if getmetatable(a) ~= Set.mt or
getmetatable(b) ~= Set.mt then
error(“attempt to `add’ a set with a non-set value”, 2)
end
… — same as before

13．2关系运算的Metamethods
Metatables 也允许我们使用metamethods: __eq (等于), __lt (小于), and __le (小于等于)给关系运算符赋予特殊的含义. 对剩下的三个关系运算符没有专门的metamethod,因为Lua 将a ~= b 转换为 not (a == b), a > b 转换为 b < a, a >= b 转换为 b <= a.
(外层的圆括号: 直到Lua 4.0为止, 所有的比较运算符被转换成一个,a <= b 转为not (b < a). 然而这种转换并不一致正确,当我们遇到偏序(partial order)情况,也就是说,并不是所有的元素都可以正确的被排序情况。例如,在大多数机器上浮点数不能被排序,因为他的值不是一个数字(Not a Number即NaN)。根据IEEE 754 的标准，NaN表示一个未定义的值，比如0/0的结果。该标准指出任何涉及到NaN比较的结果都应为false。也就是说,NaN <= x 总是false,x < NaN 也总是false. 这样一来，在这种情况下a <= b 转换为 not (b < a)就不再正确了。：外层圆括号结束)
在我们关于基和操作的例子中，有类似的问题存在。<=代表集合的包含: a <= b 表示集合a是集合b的子集.这种意义下，可能 a <= b 和b < a 都是false; 因此, 我们需要将__le 和__lt 的实现分开:
Set.mt.__le = function (a,b) — set containment
for k in pairs(a) do
if not b[k] then return false end
end
return true
end

Set.mt.__lt = function (a,b)
return a <= b and not (b <= a)
end
最后，我们通过集合的包含来定义集合相等:
Set.mt.__eq = function (a,b)
return a <= b and b <= a
end
有了上面的定义之后，现在我们就可以来比较集合了:
s1 = Set.new{2, 4}
s2 = Set.new{4, 10, 2}
print(s1 <= s2) –> true
print(s1 < s2) –> true
print(s1 >= s1) –> true
print(s1 > s1) –> false
print(s1 == s2 * s1) –> true
与算术运算的metamethods不同, 关系元算的metamethods不支持混合类型运算.对于混合类型比较运算的处理方法和Lua的公共行为类似。如果你试图比较一个字符串和一个数字，Lua将抛出错误.相似的，如果你试图比较两个带有不同metamethods的对象，Lua也将抛出错误。
但相等比较从来不会抛出错误，如果两个对象有不同的metamethod，比较的结果为false，甚至可能不会调用metamethod。这也是模仿了Lua的公共的行为，因为Lua总是认为字符串和数字是不等的，而不去判断它们的值。仅当两个有共同的metamethod的对象进行相等比较的时候，Lua才会调用对应的metamethod。

13．3库定义的 Metamethods
在一些库中，在自己的metatables中定义自己的域是很普遍的情况。到目前为止，我们看到的所有metamethods都是Lua核心部分的。有虚拟机负责处理运算符涉及到的metatables和为运算符定义操作的metamethods。但是，metatable是一个普通的表，任何人都可以使用。
tostring 是一个典型的例子。如前面我们所见，tostring以简单的格式表示出table:
print({}) –> table: 0x8062ac0
(注意：print函数总是调用tostring 来格式化它的输出).然而当格式化一个对象的时候, tostring会首先检查对象是否存在一个带有__tostring域的metatable。如果存在则以对象作为参数调用对应的函数来完成格式化，返回的结果即为tostring的结果。
在我们集合的例子中我们已经定义了一个函数来将集合转换成字符串打印出来。因此，我们只需要将集合的metatable的__tostring域调用我们定义的打印函数:
Set.mt.__tostring = Set.tostring
这样，不管什么时候我们调用print打印一个集合，print都会自动调用tostring，而tostring则会调用Set.tostring :
s1 = Set.new{10, 4, 5}
print(s1) –> {4, 5, 10}
setmetatable/getmetatable函数也会使用metafield，在这种情况下，可以保护metatables。假定你想保护你的集合使其使用者既看不到也不能修改metatables。如果你对metatable设置了__metatable的值，getmetatable 将返回这个域的值，而调用setmetatable 将会出错:
Set.mt.__metatable = “not your business”

s1 = Set.new{}
print(getmetatable(s1)) –> not your business
setmetatable(s1, {})
stdin:1: cannot change protected metatable

13．4表相关的Metamethods
关于算术运算和关系元算的metamethods都定义了错误状态的行为，他们并不改变语言本身的行为。针对在两种正常状态：表的不存在的域的查询和修改，Lua也提供了改变tables的行为的方法。

13．4．1The __index Metamethod
前面说过，当我们访问一个表的不存在的域，返回结果为nil，这是正确的，但并不一致正确。实际上，这种访问触发lua解释器去查找__index metamethod: 如果不存在，返回结果为nil; 如果存在则由__index metamethod 返回结果.
这个例子的原型是一种继承。假设我们想创建一些表来描述窗口。每一个表必须描述窗口的一些参数，比如：位置，大小，颜色风格等等。所有的这些参数都有默认的值，当我们想要创建窗口的时候只需要给出非默认值的参数即可创建我们需要的窗口。第一种方法是，实现一个表的构造器，对这个表内的每一个缺少域都填上默认值。第二种方法是，创建一个新的窗口去继承一个原型窗口的缺少域。首先，我们实现一个原型和一个构造函数，他们共享一个metatable:
– create a namespace
Window = {}
– create the prototype with default values
Window.prototype = {x=0, y=0, width=100, height=100, }
– create a metatable
Window.mt = {}
– declare the constructor function
function Window.new (o)
setmetatable(o, Window.mt)
return o
end
现在我们定义 __index metamethod:
Window.mt.__index = function (table, key)
return Window.prototype[key]
end
这样一来，我们创建一个新的窗口，然后访问他缺少的域结果如下：
w = Window.new{x=10, y=20}
print(w.width) –> 100
当Lua发现w不存在域width时，但是有一个metatable带有__index域，Lua使用w(the table)和width(缺少的值) 来调用__index metamethod，metamethod则通过访问原型表(prototype)获取缺少的域的结果。
__index metamethod在继承中的使用非常常见，所以Lua提供了一个更简洁的使用方式。__index metamethod不需要非是一个函数，他也可以是一个表。但它是一个函数的时候，Lua将table和缺少的域作为参数调用这个函数；当他是一个表的时候，Lua将在这个表中看是否有缺少的域。所以，上面的那个例子可以使用第二种方式简单的改写为：
Window.mt.__index = Window.prototype
现在，当Lua查找metatable的__index域时，他发现window.prototype的值，它是一个表，所以Lua将访问这个表来获取缺少的值，也就是说它相当于执行：
Window.prototype["width"]
将一个表作为__index metamethod使用，提供了一种廉价而简单的实现单继承的方法。一个函数的代价虽然稍微高点，但提供了更多的灵活性：我们可以实现多继承，隐藏，和其他一些变异的机制。我们将在第16章详细的讨论继承的方式。
当我们想不通过调用__index metamethod来访问一个表，我们可以使用rawget函数。Rawget(t,i)的调用以raw access方式访问表。这种访问方式不会使你的代码变快（the overhead of a function call kills any gain you could have），但有些时候我们需要他，在后面我们将会看到。
13．4．2The __newindex Metamethod
__newindex metamethod用来对表更新，__index则用来对表访问。当你给表的一个缺少的域赋值，解释器就会查找__newindex metamethod:如果存在则调用这个函数而不进行赋值操作。像__index一样，如果metamethod是一个表，解释器对指定的那个表，而不是原始的表进行赋值操作。另外，有一个raw 函数可以绕过metamethod：调用rawset(t,k,v)不掉用任何metamethod对表t的k域赋值为v。 __index 和 __newindex metamethods的混合使用提供了强大的结构：从只读表到面向对象编程的带有继承默认值的表。在这一张的剩余部分我们看一些这些应用的例子，面向对象的编程在另外的章节介绍。
13．4．3有默认值的表
在一个普通的表中任何域的默认值都是nil。很容易通过metatables来改变默认值：　
function setDefault (t, d)
local mt = {__index = function () return d end}
setmetatable(t, mt)
end

tab = {x=10, y=20}
print(tab.x, tab.z) –> 10 nil
setDefault(tab, 0)
print(tab.x, tab.z) –> 10 0
现在，不管什么时候我们访问表的缺少的域，他的__index metamethod被调用并返回0。 setDefault函数为每一个需要默认值的表创建了一个新的metatable。在有很多的表需要默认值的情况下，这可能使得花费的代价变大。然而metatable有一个默认值d和它本身关联，所以函数不能为所有表使用单一的一个metatable。为了避免带有不同默认值的所有的表使用单一的metatable，我们将每个表的默认值，使用一个唯一的域存储在表本身里面。如果我们不担心命名的混乱，我可使用像”___”作为我们的唯一的域：
local mt = {__index = function (t) return t.___ end}
function setDefault (t, d)
t.___ = d
setmetatable(t, mt)
end
如果我们担心命名混乱，也很容易保证这个特殊的键值唯一性。我们要做的只是创建一个新表用作键值：
local key = {} — unique key
local mt = {__index = function (t) return t[key] end}
function setDefault (t, d)
t[key] = d
setmetatable(t, mt)
end
另外一种解决表和默认值关联的方法是使用一个分开的表来处理，在这个特殊的表中索引是表，对应的值为默认值。然而这种方法的正确实现我们需要一种特殊的表：weak table，到目前为止我们还没有介绍这部分内容，将在第17章讨论。
为了带有不同默认值的表可以重用相同的原表，还有一种解决方法是使用memoize metatables， 然而这种方法也需要weak tables，所以我们再次不得不等到第17章。

13．4．4监控表
__index 和__newindex都是只有当表中访问的域不存在时候才起作用。捕获对一个表的所有访问情况的唯一方法就是保持表为空。因此，如果我们想监控一个表的所有访问情况，我们应该为真实的表创建一个代理。这个代理是一个空表，并且带有__index和 __newindex metamethods，由这两个方法负责跟踪表的所有访问情况并将其指向原始的表。假定，t是我们想要跟踪的原始表，我们可以：
t = {} — original table (created somewhere)

– keep a private access to original table
local _t = t

– create proxy
t = {}

– create metatable
local mt = {
__index = function (t,k)
print(“*access to element ” .. tostring(k))
return _t[k] — access the original table
end,

__newindex = function (t,k,v)
print(“*update of element ” .. tostring(k) ..
” to ” .. tostring(v))
_t[k] = v — update original table
end
}
setmetatable(t, mt)
这段代码将跟踪所有对t的访问情况：
> t[2] = ‘hello’
*update of element 2 to hello
> print(t[2])
*access to element 2
hello
(注意：不幸的是，这个设计不允许我们遍历表。Pairs函数将对proxy进行操作，而不是原始的表。) 如果我们想监控多张表，我们不需要为每一张表都建立一个不同的metatable。我们只要将每一个proxy和他原始的表关联，所有的proxy共享一个公用的metatable即可。将表和对应的proxy关联的一个简单的方法是将原始的表作为proxy的域，只要我们保证这个域不用作其他用途。一个简单的保证它不被作他用的方法是创建一个私有的没有他人可以访问的key。将上面的思想汇总，最终的结果如下：
– create private index
local index = {}

– create metatable
local mt = {
__index = function (t,k)
print(“*access to element ” .. tostring(k))
return t[index][k] — access the original table
end,

__newindex = function (t,k,v)
print(“*update of element ” .. tostring(k) ..
” to ” .. tostring(v))
t[index][k] = v — update original table
end
}

function track (t)
local proxy = {}
proxy[index] = t
setmetatable(proxy, mt)
return proxy
end
现在，不管什么时候我们想监控表t，我们要做得只是t=track(t)。

13．4．5只读表
采用代理的思想很容易实现一个只读表。我们需要做得只是当我们监控到企图修改表时候抛出错误。通过 __index metamethod,我们可以不使用函数而是用原始表本身来使用表，因为我们不需要监控查寻。这是比较简单并且高效的重定向所有查询到原始表的方法。但是，这种用法要求每一个只读代理有一个单独的新的metatable，使用__index指向原始表:
function readOnly (t)
local proxy = {}
local mt = { — create metatable
__index = t,
__newindex = function (t,k,v)
error(“attempt to update a read-only table”, 2)
end
}
setmetatable(proxy, mt)
return proxy
end
(记住：error的第二个参数2，将错误信息返回给企图执行update的地方。) 作为一个简单的例子，我们对工作日建立一个只读表：
days = readOnly{“Sunday”, “Monday”, “Tuesday”, “Wednesday”,
“Thursday”, “Friday”, “Saturday”}

print(days[1]) –> Sunday
days[2] = “Noday”
stdin:1: attempt to update a read-only table

Entry{“Jon Bentley”,
“More Programming Pearls”,
“Addison-Wesley”,
1990}
记住Entry{…} 与Entry({…})等价,他是一个以表作为唯一参数的函数调用.所以，前面那段数据在Lua程序中表示如上.如果要读取这个段数据，我们只需要运行我们的Lua代码.例如下面这段代码计算数据文件中记录数:
local count = 0
function Entry (b) count = count + 1 end
dofile(“data”)
print(“number of entries: ” .. count)
下面这段程序收集一个作者名列表中的名字是否在数据文件中出现，如果在文件中出现则打印出来. (作者名字是Entry的第一个域; 所以, 如果b 是一个entry 的值, b[1]则代表作者名.)
local authors = {} — a set to collect authors
function Entry (b) authors[b[1]] = true end
dofile(“data”)
for name in pairs(authors) do print(name) end
注意，在这些程序段中使用事件驱动的方法：Entry函数作为回调函数，dofile处理数据文件中的每一记录都回调用它. 当数据文件的大小不是太大的情况下，我们可以使用name-value对来描述数据：
Entry{
author = “Donald E. Knuth”,
title = “Literate Programming”,
publisher = “CSLI”,
year = 1992
}

Entry{
author = “Jon Bentley”,
title = “More Programming Pearls”,
publisher = “Addison-Wesley”,
year = 1990
}
(如果这种格式让你想起BibTeX,这并不奇怪.Lua中构造器正是根据来自BibTeX的灵感实现的.) 这种格式我们称之为自描述数据格式，因为每一个数据段都根据他的意思简短的描述为一种数据格式.相对CSV和其他紧缩格式，自描述数据格式更容易阅读和理解，当需要修改的时候可以容易的手工编辑，而且不需要改动数据文件.例如，如果我们想增加一个域，只需要对读取程序稍作修改即可，当指定的域不存在时，也可以赋予默认值. 使用name-value对描述的情况下,上面收集作者名的代码可以改写为：
local authors = {} — a set to collect authors
function Entry (b) authors[b.author] = true end
dofile(“data”)
for name in pairs(authors) do print(name) end
现在，记录域的顺序无关紧要了，甚至某些记录即使不存在author这个域，我们也只需要稍微改动一下代码即可:
function Entry (b)
if b.author then authors[b.author] = true end
end
Lua不仅运行速度快，编译速度也快.例如，上面这段搜集作者名的代码处理一个2MB的数据文件时间不会超过1秒.另外，这不是偶然的，数据描述是Lua的主要应用之一，从Lua发明以来，我们花了很多心血使他能够更快的编译和运行大的chunks.
12.1序列化
我们经常需要序列化一些数据，为了将数据转换为字节流或者字符流,这样我们就可以保存到文件或者通过网络发送出去.我们可以在Lua代码中描述序列化的数据，在这种方式下，我们运行读取程序即可从代码中构造出保存的值.
通常，我们使用这样的方式varname = 来保存一个全局变量的值.varname部分比较容易理解，下面我们来看看如何写一个产生值的代码.对于一个数值来说:
function serialize (o)
if type(o) == “number” then
io.write(o)
else …
end
对于字符串值而言，原始的写法应该是:
if type(o) == “string” then
io.write(“‘”, o, “‘”)
然而，如果字符串包含特殊字符(比如引号或者换行符)，产生的代码将不是有效的Lua程序.这时候你可能用下面方法解决特殊字符的问题：
if type(o) == “string” then
io.write(“[[", o, "]]”)
千万不要这样做！双引号是针对手写的字符串的而不是针对自动产生的字符串.如果有人恶意的引导你的程序去使用” ]]..os.execute(‘rm *’)..[[ "这样的方式去保存某些东西(比如它可能提供字符串作为地址)你最终的chunk将是这个样子:
varname = [[ ]]..os.execute(‘rm *’)..[[ ]]
如果你load这个数据，运行结果可想而知的. 为了以安全的方式引用任意的字符串，string标准库提供了格式化函数专门提供”%q”选项.它可以使用双引号表示字符串并且可以正确的处理包含引号和换行等特殊字符的字符串.这样一来，我们的序列化函数可以写为:
function serialize (o)
if type(o) == “number” then
io.write(o)
elseif type(o) == “string” then
io.write(string.format(“%q”, o))
else …
end
12.1.1保存不带循环的table
我们下一个艰巨的任务是保存表.根据表的结构不同，采取的方法也有很多.没有一种单一的算法对所有情况都能很好地解决问题.简单的表不仅需要简单的算法而且结果文件也需要看起来也更美观.
我们第一次尝试如下:
function serialize (o)
if type(o) == “number” then
io.write(o)
elseif type(o) == “string” then
io.write(string.format(“%q”, o))
elseif type(o) == “table” then
io.write(“{\n”)
for k,v in pairs(o) do
io.write(” “, k, ” = “)
serialize(v)
io.write(“,\n”)
end
io.write(“}\n”)
else
error(“cannot serialize a ” .. type(o))
end
end
尽管他很简单，但他的确很好的解决了问题.只要表结构是一个树型结构(也就是说，没有共享的子表并且没有循环),他甚至可以处理嵌套表(表中表).对于所进不整齐的表我们可以少作改进使结果更美观，这可以作为一个练习尝试一下.(提示：增加一个参数表示缩进的字符串，来进行序列化). 前面的函数假定表中出现的所有关键字都是合法的标示符.如果表中有不符合Lua语法的数字关键字或者字符串关键字,上面的代码将碰到麻烦.一个简单的解决这个难题的方法是将：
io.write(” “, k, ” = “)
改为
io.write(” [")
serialize(k)
io.write("] = “)
这样一来，我们改善了我们的函数的健壮性，比较一下两次的结果:
– result of serialize{a=12, b=’Lua’, key=’another “one”‘}
– 第一个版本
{
a = 12,
b = “Lua”,
key = “another \”one\”",
}

– 第二个版本
{
["a"] = 12,
["b"] = “Lua”,
["key"] = “another \”one\”",
}
我们可以通过测试每一种情况，看是否需要方括号，另外，我们将这个问题留作一个练习给大家．
12.1.2保存带有循环的table
针对普通拓扑概念上的带有循环表和共享子表的table，我们需要另外一种不同的方法来处理。构造器不能很好地解决这种情况，我们不使用。为了表示循环我们需要将表名记录下来，下面我们的函数有两个参数：table和对应的名字。另外，我们还必须记录已经保存过的table以防止由于循环而被重复保存。我们使用一个额外的table来记录保存过的表的轨迹，这个表的下表索引为table，而值为对应的表名。
我们做一个限制：要保存的table只有一个字符串或者数字关键字。下面的这个函数序列化基本类型并返回结果。
function basicSerialize (o)
if type(o) == “number” then
return tostring(o)
else — assume it is a string
return string.format(“%q”, o)
end
end
关键内容在接下来的这个函数，saved这个参数是上面提到的记录已经保存的表的踪迹的table。
function save (name, value, saved)
saved = saved or {} — initial value
io.write(name, ” = “)
if type(value) == “number” or type(value) == “string” then
io.write(basicSerialize(value), “\n”)
elseif type(value) == “table” then
if saved[value] then — value already saved?
io.write(saved[value], “\n”) — use its previous name
else
saved[value] = name — save name for next time
io.write(“{}\n”) — create a new table
for k,v in pairs(value) do — save its fields
local fieldname = string.format(“%s[%s]“, name,
basicSerialize(k))
save(fieldname, v, saved)
end
end
else
error(“cannot save a ” .. type(value))
end
end
举个例子：
我们将要保存的table为：
a = {x=1, y=2; {3,4,5}}
a[2] = a — cycle
a.z = a[1] — shared sub-table
调用save(‘a’, a)之后结果为：
a = {}
a[1] = {}
a[1][1] = 3
a[1][2] = 4
a[1][3] = 5

a[2] = a
a["y"] = 2
a["x"] = 1
a["z"] = a[1]
(实际的顺序可能有所变化，它依赖于table遍历的顺序，不过，这个算法保证了一个新的定义中需要的前面的节点都已经被定义过)
如果我们想保存带有共享部分的表，我们可以使用同样table的saved参数调用save函数，例如我们创建下面两个表：
a = {{“one”, “two”}, 3}
b = {k = a[1]}
保存他们：
save(‘a’, a)
save(‘b’, b)
结果将分别包含相同部分：
a = {}
a[1] = {}
a[1][1] = “one”
a[1][2] = “two”
a[2] = 3
b = {}
b["k"] = {}
b["k"][1] = “one”
b["k"][2] = “two”
然而如果我们使用同一个saved表来调用save函数：
local t = {}
save(‘a’, a, t)
save(‘b’, b, t)
结果将共享相同部分：
a = {}
a[1] = {}
a[1][1] = “one”
a[1][2] = “two”
a[2] = 3
b = {}
b["k"] = a[1]
上面这种方法是Lua中常用的方法，当然也有其他一些方法可以解决问题。比如，我们可以不使用全局变量名来保存(chunk构造一个local值然后返回他)；通过构造一张表，每张表名与其对应的函数对应起来等。Lua给予你权力，由你决定如何实现。

function List.pushright (list, value)
local last = list.last + 1
list.last = last
list[last] = value
end

function List.popleft (list)
local first = list.first
if first > list.last then error(“list is empty”) end
local value = list[first]
list[first] = nil — to allow garbage collection
list.first = first + 1
return value
end

function List.popright (list)
local last = list.last
if list.first > last then error(“list is empty”) end
local value = list[last]
list[last] = nil — to allow garbage collection
list.last = last – 1
return value
end
对严格意义上的队列来讲，我们只能调用pushright和 popleft，这样以来，first和last的索引值都随之增加，幸运的是我们使用的是Lua的table实现的，你可以访问数组的元素，通过使用下标从1到20，也可以16,777,216 到 16,777,236。另外，Lua使用双精度表示数字，假定你每秒钟执行100万次插入操作，在数值溢出以前你的程序可以运行200年。
11.5集合和包
假定你想列出在一段源代码中出现的所有标示符，某种程度上，你需要过滤掉那些语言本身的保留字。一些C程序员喜欢用一个字符串数组来表示，将所有的保留字放在数组中，对每一个标示符到这个数组中查找看是否为保留字，有时候为了提高查询效率，对数组存储的时候使用二分查找或者hash算法。
Lua中表示这个集合有一个简单有效的方法，将所有集合中的元素作为下标存放在一个table里，下面不需要查找table，只需要测试看对于给定的元素，表的对应下标的元素值是否为nil。比如：
reserved = {
["while"] = true, ["end"] = true,
["function"] = true, ["local"] = true,
}

for w in allwords() do
if reserved[w] then
– `w’ is a reserved word
…
还可以使用辅助函数更加清晰的构造集合：
function Set (list)
local set = {}
for _, l in ipairs(list) do set[l] = true end
return set
end

reserved = Set{“while”, “end”, “function”, “local”, }
11.6字符串缓冲
假定你要拼接很多个小的字符串为一个大的字符串，比如，从一个文件中逐行读入字符串。你可能写出下面这样的代码：
– WARNING: bad code ahead!!
local buff = “”
for line in io.lines() do
buff = buff .. line .. “\n”
end
尽管这段代码看上去很正常，但在Lua中他的效率极低，在处理大文件的时候，你会明显看到很慢，例如，需要花大概1分钟读取350KB的文件。(这就是为什么Lua专门提供了io.read(*all)选项，她读取同样的文件只需要0.02s)
为什么这样呢？Lua使用真正的垃圾收集算法，但他发现程序使用太多的内存他就会遍历他所有的数据结构去释放垃圾数据，一般情况下，这个算法有很好的性能(Lua的快并非偶然的)，但是上面那段代码loop使得算法的效率极其低下。
为了理解现象的本质，假定我们身在loop中间，buff已经是一个50KB的字符串，每一行的大小为20bytes，当Lua执行buff..line..”\n”时，她创建了一个新的字符串大小为50,020 bytes，并且从buff中将50KB的字符串拷贝到新串中。也就是说，对于每一行，都要移动50KB的内存，并且越来越多。读取100行的时候(仅仅2KB)，Lua已经移动了5MB的内存，使情况变遭的是下面的赋值语句：
buff = buff .. line .. “\n”
老的字符串变成了垃圾数据，两轮循环之后，将有两个老串包含超过100KB的垃圾数据。这个时候Lua会做出正确的决定，进行他的垃圾收集并释放100KB的内存。问题在于每两次循环Lua就要进行一次垃圾收集，读取整个文件需要进行200次垃圾收集。并且它的内存使用是整个文件大小的三倍。
这个问题并不是Lua特有的：其它的采用垃圾收集算法的并且字符串不可变的语言也都存在这个问题。Java是最著名的例子，Java专门提供StringBuffer来改善这种情况。
在继续进行之前，我们应该做个注释的是，在一般情况下，这个问题并不存在。对于小字符串，上面的那个循环没有任何问题。为了读取整个文件我们可以使用io.read(*all)，可以很快的将这个文件读入内存。但是在某些时候，没有解决问题的简单的办法，所以下面我们将介绍更加高效的算法来解决这个问题。
我们最初的算法通过将循环每一行的字符串连接到老串上来解决问题，新的算法避免如此：它连接两个小串成为一个稍微大的串，然后连接稍微大的串成更大的串。。。算法的核心是：用一个栈，在栈的底部用来保存已经生成的大的字符串，而小的串从栈定入栈。栈的状态变化和经典的汉诺塔问题类似：位于栈下面的串肯定比上面的长，只要一个较长的串入栈后比它下面的串长，就将两个串合并成一个新的更大的串，新生成的串继续与相邻的串比较如果长于底部的将继续进行合并，循环进行到没有串可以合并或者到达栈底。
function newStack ()
return {“”} — starts with an empty string
end

function addString (stack, s)
table.insert(stack, s) — push ‘s’ into the the stack
for i=table.getn(stack)-1, 1, -1 do
if string.len(stack[i]) > string.len(stack[i+1]) then
break
end
stack[i] = stack[i] .. table.remove(stack)
end
end
要想获取最终的字符串，我们只需要从上向下一次合并所有的字符串即可。table.concat函数可以将一个列表的所有串合并。
使用这个新的数据结构，我们重写我们的代码：
local s = newStack()
for line in io.lines() do
addString(s, line .. “\n”)
end
s = toString(s)
最终的程序读取350 KB的文件只需要0.5s，当然调用io.read(“*all”)仍然是最快的只需要0.02s。

实际上，我们调用io.read(“*all”)的时候，io.read就是使用我们上面的数据结构，只不过是用C实现的，在Lua标准库中，有些其他函数也是用C实现的，比如table.concat，使用table.concat我们可以很容易的将一个table的中的字符串连接起来，因为它使用C实现的，所以即使字符串很大它处理起来速度还是很快的。
Concat接受第二个可选的参数，代表插入的字符串之间的分隔符。通过使用这个参数，我们不需要在每一行之后插入一个新行：
local t = {}
for line in io.lines() do
table.insert(t, line)
end
s = table.concat(t, “\n”) .. “\n”
io.lines迭代子返回不带换行符的一行，concat在字符串之间插入分隔符，但是最后一字符串之后不会插入分隔符，因此我们需要在最后加上一个分隔符。最后一个连接操作复制了整个字符串，这个时候整个字符串可能是很大的。我们可以使用一点小技巧，插入一个空串：
table.insert(t, “”)
s = table.concat(t, “\n”)

Here are brief descriptions of some projects around the
world that use Lua.

• TeCGraf
• …

TeCGrafComputer Graphics Technology Group,
PUC-Rio

TeCGraf is the result of a partnership between
…
distributed among dozens of final products.

Contact: Waldemar Celes

Here are brief descriptions of some projects around the
world that use Lua.

]])
end
第三,定义entry函数
a.第一个entry函数,将每个工程一列表方式写出,entry的参数o是描述工程的table.
function entry0 (o)
N=N + 1
local title = o.title or ‘(no title)’
fwrite(‘