forked from cloudwu/lua53doc
-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathmanual.html
More file actions
9674 lines (6480 loc) · 302 KB
/
manual.html
File metadata and controls
9674 lines (6480 loc) · 302 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>Lua 5.3 参考手册</title>
<link rel="stylesheet" type="text/css" href="lua.css">
<link rel="stylesheet" type="text/css" href="manual.css">
<META HTTP-EQUIV="content-type" CONTENT="text/html; charset=utf-8">
</head>
<body>
<hr>
<h1>
<a href="http://www.lua.org/"><img src="logo.gif" alt="" border="0"></a>
Lua 5.3 参考手册
</h1>
作者 Roberto Ierusalimschy, Luiz Henrique de Figueiredo, Waldemar Celes
<p>
译者 <a href="http://blog.codingnow.com">云风</a>
<p>
<small>
Lua.org, PUC-Rio 版权所有 © 2015 ，
在遵循
<A HREF="http://www.lua.org/license.html">Lua license</A>
条款下，可自由使用。
</small>
<hr>
<p>
<a href="contents.html#contents">目录</A>
·
<a href="contents.html#index">索引</A>
·
<A HREF="term.html">中英术语对照表</A>
<!-- ====================================================================== -->
<p>
<!-- $Id: manual.of,v 1.146 2015/01/06 11:23:01 roberto Exp $ -->
<h1>1 – <a name="1">概要</a></h1>
<p>
Lua 是一门扩展式程序设计语言，它被设计成支持通用过程式编程，并有相关数据描述设施。
同时也很好的支持了面向对象编程、函数式编程、数据驱动式编程。
它作为一个强大、轻量的嵌入式脚本语言，可供任何需要的程序使用。
它以库形式实现，用 <em>clean C</em> 写成。
所谓 clean C ，指的是标准 C 和 C++ 间共通的一个子集。
<p>
作为一个扩展式语言，Lua 没有 "main" 程序的概念：
它只能 <em>嵌入</em> 一个宿主程序中工作，
这个宿主程序被称作 <em>被嵌入的程序</em> 或简称为 <em>宿主</em> 。
宿主程序可以调用函数执行一小段 Lua 代码，可以读写 Lua 变量，可以注入 C 函数让 Lua 代码调用。
依靠这些 C 函数，在各种不同的领域中，都可以将拥有相同句法结构的 Lua 定制为该领域下的编程语言。
Lua 的官方发布版包含了一个叫做 <code>lua</code> 的简单的宿主程序，
它用 Lua 库实现了一个完整的独立 Lua 解释器。
你可以把它作交互式应用或用于批处理。
<p>
Lua 是一个自由软件，它的使用许可证决定了它的使用过程没有任何担保。
这份手册中描述的实现，可以在 Lua 的官方网站 <code>www.lua.org</code> 找到。
<p>
跟其它的许多参考手册一样，这份文档有些地方比较枯燥。
Lua 设计决定方面的讨论，
可以看看 Lua 网站上提供的技术论文。
有关用 Lua 编程的细节介绍，
可以读一下 Roberto 的书，<em>Programming in Lua</em>。
<h1>2 – <a name="2">基本概念</a></h1>
<p>
这一章描述了语言的基本概念。
<h2>2.1 – <a name="2.1">值与类型</a></h2>
<p>
Lua 是一门<em>动态类型语言</em>。
这意味着变量没有类型；只有值才有类型。
语言中不设类型定义。
所有的值都带有自己的类型。
<p>
Lua 中所有的值都是 <em>一等公民</em>。
这意味着所有的值都可以保存在变量中、
当作参数传递给其它函数、以及作为返回值出现。
<p>
Lua 中有八种基本类型：
<em>nil</em>, <em>boolean</em>, <em>number</em>,
<em>string</em>, <em>function</em>, <em>userdata</em>,
<em>thread</em>, and <em>table</em>.
<em>Nil</em> 是值 <b>nil</b> 的类型，
它的主要特征就是和其它值区别开；
它通常用来表示一个有意义的值不存在时的状态。
<em>Boolean</em> 是 <b>false</b> 与 <b>true</b> 两个值的类型。
<b>nil</b> 和 <b>false</b> 都会导致条件判断为假；
所有其它的值都表现为真。
<em>Number</em> 代表了整数或实数（浮点数）。
<em>String</em> 表示一个不可变的字节序列。
Lua 是 8 位友好的：
字符串可以包含任意 8 位值，
其中包括零 ('<code>\0</code>') 。
Lua 的字符串编码无关；
它不理会字符串里的内容到底是什么。
<p>
<em>number</em> 类型有两种内部呈现方式，
一种称为 <em>整数</em> 另一种称为 <em>浮点数</em>。
对于使用哪种内部形式，Lua 有明确的规则，
但它也按需（参见 <a href="#3.4.3">§3.4.3</a>）自动转换。
因此，程序员需要选择完全忽略其间的差异
还是对如何在内部呈现数字做完全的控制。
标准 Lua 使用 64 位整数以及双精度（64 位）浮点数，
但你可以把 Lua 编译成使用 32 位整数及单精度（32 位）浮点数。
以 32 位表示数字对小型机器以及嵌入式系统特别有意义。
（参见 <code>luaconf.h</code> 文件中的宏 <code>LUA_32BITS</code> 。）
<p>
Lua 可以调用（以及操作）用 Lua 或 C （参见 <a href="#3.4.10">§3.4.10</a>）编写的函数。
这两种函数有统一的类型 <em>function</em>。
<p>
<em>userdata</em> 类型允许将 C 中的数据保存在 Lua 变量中。
用户数据类型的值是一个内存块。
有两种用户数据：
<em>完全用户数据</em> 指一块由 Lua 管理的内存对应的对象；
<em>轻量用户数据</em> 则指一个简单的 C 指针。
用户数据在 Lua 中没有预定义的操作，你只能对它进行赋值操作及判断两个用户数据是否相同。
使用 <em>元表</em> 的话，程序员可以给完全用户数据定义一系列的操作
（参见 <a href="#2.4">§2.4</a>）。
在 Lua 代码中，你不能查和修改一个用户数据的值，这些工作只能通过 C API 完成。
这保证了数据仅被宿主程序所控制。
<p>
<em>thread</em> 类型表示了一个独立的执行序列，它被用于实现协程
（参见 <a href="#2.6">§2.6</a>）。
Lua 线程并非操作系统线程。
Lua 为所有的系统，包括那些不提供原生线程支持的系统，提供了协程支持。
<p>
<em>table</em> 是一个关联数组，
也就是说，这个数组不仅仅以数做索引，除了 <b>nil</b> 和 NaN 之外的 Lua 值
都可以做索引。
（<em>Not a Number</em> 是一个特殊的数字，它用于表示未定义或表示不了的运算结果，比如 <code>0/0</code>。）
表可以是 <em>异构</em> 的；
也就是说，表内可以包含（除 <b>nil</b> 外的任何类型的值）。
任何键的值若为 <b>nil</b> 就不会被记入表结构内部。
换句话说，对于表内不存在的键，都对应着值 <b>nil</b> 。
<p>
表是 Lua 中唯一的数据结构；
它可被用于表示普通数组、序列、符号表、集合、记录、图、树、等等。
对于记录，Lua 使用域名作为索引。
语言提供了 <code>a.name</code> 这样的语法糖来替代
<code>a["name"]</code> 这种写法以方便记录这种结构的使用。
有多种方式在 Lua 中创建表结构（参见 <a href="#3.4.9">§3.4.9</a>）。
<p>
我们使用 <em>序列</em> 这个术语来表示一个用 {1..<em>n</em>} 的正整数集
做索引的表。这里的非负整数 <em>n</em> 被称为这个序列的长度
（参见 <a href="#3.4.7">§3.4.7</a>）。
<p>
和索引一样，表中每个域的值也可以是任何类型。
需要特别指出的是：既然函数是一等公民，那么表的域也可以是函数。
这样，表就可以携带 <em>方法</em> 了。
（参见 <a href="#3.4.11">§3.4.11</a>）。
<p>
索引一张表的原则遵循语言中的直接比较规则。
当且仅当 <code>i</code> 与 <code>j</code>直接比较相等时
（即不通过元方法的比较），
表达式 <code>a[i]</code> 与 <code>a[j]</code>
表示了表中相同的元素。
特别指出：一个可以完全表达为整数的浮点数和对应的整数相等
（例如：<code>1.0 == 1</code>）。
为了消除歧义，当一个可以完全表达为整数的浮点数做为键值时，
都会被转换为对应的整数储存。
例如，当你写 <code>a[2.0] = true</code> 时，
实际被插入表中的键是整数 <code>2</code> 。
（另一方面，2 与 "<code>2</code>" 是两个不同的 Lua 值，
故而它们可以是同一张表中的不同项。）
<p>
表、函数、线程、以及完全用户数据在 Lua 中被称为 <em>对象</em>：
变量并不真的 <em>持有</em> 它们的值，而仅保存了对这些对象的 <em>引用</em>。
赋值、参数传递、函数返回，都是针对引用而不是针对值的操作；
这些操作均不会做任何形式的隐式拷贝。
<p>
库函数 <a href="#pdf-type"><code>type</code></a> 用于以字符串形式返回给定值的类型。
（参见 <a href="#6.1">§6.1</a>）。
<h2>2.2 – <a name="2.2">环境与全局环境</a></h2>
<p>
后面在 <a href="#3.2">§3.2</a> 以及 <a href="#3.3.3">§3.3.3</a> 会讨论，
引用一个叫 <code>var</code> 的自由名字（指在任何层级都未被声明的名字）
在句法上都被翻译为 <code>_ENV.var</code> 。
此外，每个被编译的 Lua 代码块都会有一个额外的局部变量叫 <code>_ENV</code>
（参见 <a href="#3.3.2">§3.3.2</a>），
因此，<code>_ENV</code> 这个名字永远都不会成为一个代码块中的自由名字。
<p>
在转译那些自由名字时，<code>_ENV</code> 是否是那个额外的局部变量无所谓。
<code>_ENV</code> 和其它你可以使用的变量名没有区别。
这里特别指出，你可以定义一个新变量或指定一个参数叫这个名字。
当编译器在转译自由名字时所用到的 <code>_ENV</code> ，
指的是你的程序在那个点上可见的那个名为 _ENV 的变量。
（Lua 的可见性规则参见 <a href="#3.5">§3.5</a>）
<p>
被 <code>_ENV</code> 用于值的那张表被称为 <em>环境</em>。
<p>
Lua 保有一个被称为 <em>全局环境</em> 特别环境。它被保存在 C 注册表
（参见 <a href="#4.5">§4.5</a>）的一个特别索引下。
在 Lua 中，全局变量 <a href="#pdf-_G"><code>_G</code></a> 被初始化为这个值。
（<a href="#pdf-_G"><code>_G</code></a> 不被内部任何地方使用。）
<p>
当 Lua 加载一个代码块，<code>_ENV</code> 这个上值的默认值就是这个全局环境
（参见 <a href="#pdf-load"><code>load</code></a>）。
因此，在默认情况下，Lua 代码中提及的自由名字都指的全局环境中的相关项
（因此，它们也被称为 <em>全局变量</em> ）。
此外，所有的标准库都被加载入全局环境，一些函数也针对这个环境做操作。
你可以用 <a href="#pdf-load"><code>load</code></a> （或 <a href="#pdf-loadfile"><code>loadfile</code></a>）加载代码块，并赋予它们不同的环境。
（在 C 里，当你加载一个代码块后，可以通过改变它的第一个上值来改变它的环境。）
<h2>2.3 – <a name="2.3">错误处理</a></h2>
<p>
Lua 作为一门嵌入式语言，
所有的 Lua 行为都始于宿主程序的 C 代码中对于 Lua 库里某函数的一次调用。
（当你使用 Lua 独立版本时，<code>lua</code> 程序就是那个宿主程序。）
在编译或运行一个 Lua 代码块时，无论发生任何错误，
控制权都返还给宿主。接下来可以针对情况来采取恰当的措施
（比如打印错误消息）。
<p>
Lua 代码中可以通过调用 <a href="#pdf-error"><code>error</code></a> 函数来显式的抛出一个错误。
如果你需要在 Lua 中捕获这些错误，
你可以使用 <a href="#pdf-pcall"><code>pcall</code></a> 或
<a href="#pdf-xpcall"><code>xpcall</code></a>
以 <em>保护模式</em> 来调用一个函数。
<p>
无论何时错误发生，都会产生一个携带有错误信息的 <em>错误对象</em>
（也被称为 <em>错误消息</em>）。
Lua 本身只会产生字符串类型的错误对象，
但你的程序可以为一个错误抛出任何类型的错误对象。
这就看 Lua 程序或你的宿主如何处理这些错误对象了。
<p>
当你使用 <a href="#pdf-xpcall"><code>xpcall</code></a> 或
<a href="#lua_pcall"><code>lua_pcall</code></a> 时，
你应当给出一个 <em>消息处理器</em> 用于发生错误时的处理流程。
这个处理器函数会被传入原始的错误消息，并应返回一个新的错误消息。
它在错误发生后栈尚未展开时调用，
因此它可以通过栈来收集更多的信息。
例如它可以通过探知栈来创建一组栈回溯信息。
这个处理器函数也被保护模式调用以保护；
因此在处理器函数内发生的错误会再次调用它。
如果递归调用太深，Lua 会打破递归并返回一个恰当的消息。
<h2>2.4 – <a name="2.4">元表及元方法</a></h2>
<p>
Lua 中的每个值都可以用一个 <em>元表</em>。
这个 <em>元表</em> 就是一个普通的 Lua 表，
它用于定义原始值在特定操作下的行为。
如果你想改变一个值在特定操作下的行为，你可以在它的元表中设置对应域。
例如，当你对非数字值做加操作时，
Lua 会检查该值的元表中的 "<code>__add</code>" 域下的函数。
如果能找到，Lua 则调用这个函数来完成加这个操作。
<p>
元表中的键对应着不同的 <em>事件</em> 名；
键关联的那些值被称为 <em>元方法</em>。
在上面那个例子中引用的事件为 <code>"add"</code> ，
完成加操作的那个函数就是元方法。
<p>
你可以用 <a href="#pdf-getmetatable"><code>getmetatable</code></a> 函数
来获取任何值的元表。
<p>
使用 <a href="#pdf-setmetatable"><code>setmetatable</code></a>
来替换一张表的元表。在 Lua 中，你不可以改变其它类型的值的元表
（除非你使用调试库（参见<a href="#6.10">§6.10</a>））；
若想改变这些非表类型的值的元表，请使用 C API。
<p>
表和完全用户数据有独立的元表
（当然，多个表和用户数据可以共享同一个元表）。
其它类型的值按类型共享元表；
也就是说所有的数字都共享同一个元表，
所有的字符串共享另一个元表等等。
默认情况下，值是没有元表的，
但字符串库在初始化的时候为字符串类型设置了元表
（参见 <a href="#6.4">§6.4</a>）。
<p>
元表决定了一个对象在数学运算、位运算、比较、连接、
取长度、调用、索引时的行为。
元表还可以定义一个函数，当表对象或用户数据对象在垃圾回收
（参见<a href="#2.5">§2.5</a>）时调用它。
<p>
接下来会给出一张元表可以控制的事件的完整列表。
每个操作都用对应的事件名来区分。
每个事件的键名用加有 '<code>__</code>' 前缀的字符串来表示；
例如 "add" 操作的键名为字符串 "<code>__add</code>"。
注意、Lua 从元表中直接获取元方法；
访问元表中的元方法永远不会触发另一次元方法。
下面的代码模拟了 Lua 从一个对象 <code>obj</code> 中获取一个元方法的过程：
<pre>
rawget(getmetatable(obj) or {}, "__" .. event_name)
</pre>
<p>
对于一元操作符（取负、求长度、位反），
元方法调用的时候，第二个参数是个哑元，其值等于第一个参数。
这样处理仅仅是为了简化 Lua 的内部实现
（这样处理可以让所有的操作都和二元操作一致），
这个行为有可能在将来的版本中移除。
（使用这个额外参数的行为都是不确定的。）
<ul>
<li><b>"add": </b>
<code>+</code> 操作。
如果任何不是数字的值（包括不能转换为数字的字符串）做加法，
Lua 就会尝试调用元方法。
首先、Lua 检查第一个操作数（即使它是合法的），
如果这个操作数没有为 "<code>__add</code>" 事件定义元方法，
Lua 就会接着检查第二个操作数。
一旦 Lua 找到了元方法，
它将把两个操作数作为参数传入元方法，
元方法的结果（调整为单个值）作为这个操作的结果。
如果找不到元方法，将抛出一个操作。
</li>
<li><b>"sub": </b>
<code>-</code> 操作。
行为和 "add" 操作类似。
</li>
<li><b>"mul": </b>
<code>*</code> 操作。
行为和 "add" 操作类似。
</li>
<li><b>"div": </b>
<code>/</code> 操作。
行为和 "add" 操作类似。
</li>
<li><b>"mod": </b>
<code>%</code> 操作。
行为和 "add" 操作类似。
</li>
<li><b>"pow": </b>
<code>^</code> （次方）操作。
行为和 "add" 操作类似。
</li>
<li><b>"unm": </b>
<code>-</code> （取负）操作。
行为和 "add" 操作类似。
</li>
<li><b>"idiv": </b>
<code>//</code> （向下取整除法）操作。
行为和 "add" 操作类似。
</li>
<li><b>"band": </b>
<code>&</code> （按位与）操作。
行为和 "add" 操作类似，
不同的是 Lua 会在任何一个操作数无法转换为整数时
（参见 <a href="#3.4.3">§3.4.3</a>）尝试取元方法。
</li>
<li><b>"bor": </b>
<code>|</code> （按位或）操作。
行为和 "band" 操作类似。
</li>
<li><b>"bxor": </b>
<code>~</code> （按位异或）操作。
行为和 "band" 操作类似。
</li>
<li><b>"bnot": </b>
<code>~</code> （按位非）操作。
行为和 "band" 操作类似。
</li>
<li><b>"shl": </b>
<code><<</code> （左移）操作。
行为和 "band" 操作类似。
</li>
<li><b>"shr": </b>
<code>>></code> （右移）操作。
行为和 "band" 操作类似。
</li>
<li><b>"concat": </b>
<code>..</code> （连接）操作。
行为和 "add" 操作类似，
不同的是 Lua 在任何操作数即不是一个字符串
也不是数字（数字总能转换为对应的字符串）的情况下尝试元方法。
</li>
<li><b>"len": </b>
<code>#</code> （取长度）操作。
如果对象不是字符串，Lua 会尝试它的元方法。
如果有元方法，则调用它并将对象以参数形式传入，
而返回值（被调整为单个）则作为结果。
如果对象是一张表且没有元方法，
Lua 使用表的取长度操作（参见 <a href="#3.4.7">§3.4.7</a>）。
其它情况，均抛出错误。
</li>
<li><b>"eq": </b>
<code>==</code> （等于）操作。
和 "add" 操作行为类似，
不同的是 Lua 仅在两个值都是表或都是完全用户数据
且它们不是同一个对象时才尝试元方法。
调用的结果总会被转换为布尔量。
</li>
<li><b>"lt": </b>
<code><</code> （小于）操作。
和 "add" 操作行为类似，
不同的是 Lua 仅在两个值不全为整数也不全为字符串时才尝试元方法。
调用的结果总会被转换为布尔量。
</li>
<li><b>"le": </b>
<code><=</code> （小于等于）操作。
和其它操作不同，
小于等于操作可能用到两个不同的事件。
首先，像 "lt" 操作的行为那样，Lua 在两个操作数中查找 "<code>__le</code>" 元方法。
如果一个元方法都找不到，就会再次查找 "<code>__lt</code>" 事件，
它会假设 <code>a <= b</code> 等价于 <code>not (b < a)</code>。
而其它比较操作符类似，其结果会被转换为布尔量。
</li>
<li><b>"index": </b>
索引 <code>table[key]</code>。
当 <code>table</code> 不是表或是表 <code>table</code> 中不存在
<code>key</code> 这个键时，这个事件被触发。
此时，会读出 <code>table</code> 相应的元方法。
<p>
尽管名字取成这样，
这个事件的元方法其实可以是一个函数也可以是一张表。
如果它是一个函数，则以 <code>table</code> 和 <code>key</code> 作为参数调用它。
如果它是一张表，最终的结果就是以 <code>key</code> 取索引这张表的结果。
（这个索引过程是走常规的流程，而不是直接索引，
所以这次索引有可能引发另一次元方法。）
</li>
<li><b>"newindex": </b>
索引赋值 <code>table[key] = value</code> 。
和索引事件类似，它发生在
<code>table</code> 不是表或是表 <code>table</code> 中不存在
<code>key</code> 这个键的时候。
此时，会读出 <code>table</code> 相应的元方法。
<p>
同索引过程那样，
这个事件的元方法即可以是函数，也可以是一张表。
如果是一个函数，
则以 <code>table</code>、 <code>key</code>、以及 <code>value</code> 为参数传入。
如果是一张表，
Lua 对这张表做索引赋值操作。
（这个索引过程是走常规的流程，而不是直接索引赋值，
所以这次索引赋值有可能引发另一次元方法。）
<p>
一旦有了 "newindex" 元方法，
Lua 就不再做最初的赋值操作。
（如果有必要，在元方法内部可以调用 <a href="#pdf-rawset"><code>rawset</code></a>
来做赋值。）
</li>
<li><b>"call": </b>
函数调用操作 <code>func(args)</code>。
当 Lua 尝试调用一个非函数的值的时候会触发这个事件
（即 <code>func</code> 不是一个函数）。
查找 <code>func</code> 的元方法，
如果找得到，就调用这个元方法，
<code>func</code> 作为第一个参数传入，原来调用的参数（<code>args</code>）后依次排在后面。
</li>
</ul>
<h2>2.5 – <a name="2.5">垃圾收集</a></h2>
<p>
Lua 采用了自动内存管理。
这意味着你不用操心新创建的对象需要的内存如何分配出来，
也不用考虑在对象不再被使用后怎样释放它们所占用的内存。
Lua 运行了一个 <em>垃圾收集器</em> 来收集所有 <em>死对象</em>
（即在 Lua 中不可能再访问到的对象）来完成自动内存管理的工作。
Lua 中所有用到的内存，如：字符串、表、用户数据、函数、线程、
内部结构等，都服从自动管理。
<p>
Lua 实现了一个增量标记-扫描收集器。
它使用这两个数字来控制垃圾收集循环：
<em>垃圾收集器间歇率</em> 和 <em>垃圾收集器步进倍率</em>。
这两个数字都使用百分数为单位
（例如：值 100 在内部表示 1 ）。
<p>
垃圾收集器间歇率控制着收集器需要在开启新的循环前要等待多久。
增大这个值会减少收集器的积极性。
当这个值比 100 小的时候，收集器在开启新的循环前不会有等待。
设置这个值为 200 就会让收集器等到总内存使用量达到
之前的两倍时才开始新的循环。
<p>
垃圾收集器步进倍率控制着收集器运作速度相对于内存分配速度的倍率。
增大这个值不仅会让收集器更加积极，还会增加每个增量步骤的长度。
不要把这个值设得小于 100 ，
那样的话收集器就工作的太慢了以至于永远都干不完一个循环。
默认值是 200 ，这表示收集器以内存分配的“两倍”速工作。
<p>
如果你把步进倍率设为一个非常大的数字
（比你的程序可能用到的字节数还大 10% ），
收集器的行为就像一个 stop-the-world 收集器。
接着你若把间歇率设为 200 ，
收集器的行为就和过去的 Lua 版本一样了：
每次 Lua 使用的内存翻倍时，就做一次完整的收集。
<p>
你可以通过在 C 中调用 <a href="#lua_gc"><code>lua_gc</code></a>
或在 Lua 中调用 <a href="#pdf-collectgarbage"><code>collectgarbage</code></a>
来改变这俩数字。
这两个函数也可以用来直接控制收集器（例如停止它或重启它）。
<h3>2.5.1 – <a name="2.5.1">垃圾收集元方法</a></h3>
<p>
你可以为表设定垃圾收集的元方法，
对于完全用户数据（参见 <a href="#2.4">§2.4</a>），
则需要使用 C API 。
该元方法被称为 <em>终结器</em>。
终结器允许你配合 Lua 的垃圾收集器做一些额外的资源管理工作
（例如关闭文件、网络或数据库连接，或是释放一些你自己的内存）。
<p>
如果要让一个对象（表或用户数据）在收集过程中进入终结流程，
你必须 <em>标记</em> 它需要触发终结器。
当你为一个对象设置元表时，若此刻这张元表中用一个以字符串
"<code>__gc</code>" 为索引的域，那么就标记了这个对象需要触发终结器。
注意：如果你给对象设置了一个没有 <code>__gc</code>
域的元表，之后才给元表加上这个域，
那么这个对象是没有被标记成需要触发终结器的。
然而，一旦对象被标记，
你还是可以自由的改变其元表中的 <code>__gc</code> 域的。
<p>
当一个被标记的对象成为了垃圾后，
垃圾收集器并不会立刻回收它。
取而代之的是，Lua 会将其置入一个链表。
在收集完成后，Lua 将遍历这个链表。
Lua 会检查每个链表中的对象的 <code>__gc</code>
元方法：如果是一个函数，那么就以对象为唯一参数调用它；
否则直接忽略它。
<p>
在每次垃圾收集循环的最后阶段，
本次循环中检测到的需要被回收之对象，
其终结器的触发次序按当初给对象作需要触发终结器的标记之次序的逆序进行；
这就是说，第一个被调用的终结器是程序中最后一个被标记的对象所携的那个。
每个终结器的运行可能发生在执行常规代码过程中的任意一刻。
<p>
由于被回收的对象还需要被终结器使用，
该对象（以及仅能通过它访问到的其它对象）一定会被 Lua <em>复活</em>。
通常，复活是短暂的，对象所属内存会在下一个垃圾收集循环释放。
然后，若终结器又将对象保存去一些全局的地方
（例如：放在一个全局变量里），这次复活就持续生效了。
此外，如果在终结器中对一个正进入终结流程的对象再次做一次标记让它触发终结器，
只要这个对象在下个循环中依旧不可达，它的终结函数还会再调用一次。
无论是哪种情况，
对象所属内存仅在垃圾收集循环中该对象不可达且
没有被标记成需要触发终结器才会被释放。
<p>
当你关闭一个状态机（参见 <a href="#lua_close"><code>lua_close</code></a>），
Lua 将调用所有被标记了需要触发终结器对象的终结过程，
其次序为标记次序的逆序。
在这个过程中，任何终结器再次标记对象的行为都会不会生效。
<h3>2.5.2 – <a name="2.5.2">弱表</a></h3>
<p>
<em>弱表</em> 指内部元素为 <em>弱引用</em> 的表。
垃圾收集器会忽略掉弱引用。
换句话说，如果一个对象只被弱引用引用到，
垃圾收集器就会回收这个对象。
<p>
一张弱表可以有弱键或是弱值，也可以键值都是弱引用。
仅含有弱键的表允许收集器回收它的键，但会阻止对值所指的对象被回收。
若一张表的键值均为弱引用，
那么收集器可以回收其中的任意键和值。
任何情况下，只要键或值的任意一项被回收，
相关联的键值对都会从表中移除。
一张表的元表中的 <code>__mode</code> 域控制着这张表的弱属性。
当 <code>__mode</code> 域是一个包含字符 '<code>k</code>'
的字符串时，这张表的所有键皆为弱引用。
当 <code>__mode</code> 域是一个包含字符 '<code>v</code>'
的字符串时，这张表的所有值皆为弱引用。
<p>
属性为弱键强值的表也被称为 <em>暂时表</em>。
对于一张暂时表，
它的值是否可达仅取决于其对应键是否可达。
特别注意，如果表内的一个键仅仅被其值所关联引用，
这个键值对将被表内移除。
<p>
对一张表的弱属性的修改仅在下次收集循环才生效。
尤其是当你把表由弱改强，Lua 还是有可能在修改生效前回收表内一些项目。
<p>
只有那些有显式构造过程的对象才会从弱表中移除。
值，例如数字和轻量 C 函数，不受垃圾收集器管辖，
因此不会从弱表中移除
（除非它们的关联项被回收）。
虽然字符串受垃圾回收器管辖，
但它们没有显式的构造过程，所以也不会从弱表中移除。
<p>
弱表针对复活的对象
（指那些正在走终结流程，仅能被终结器访问的对象）
有着特殊的行为。
弱值引用的对象，在运行它们的终结器前就被移除了，
而弱键引用的对象则要等到终结器运行完毕后，到下次收集当对象真的被释放时才被移除。
这个行为使得终结器运行时得以访问到由该对象在弱表中所关联的属性。
<p>
如果一张弱表在当次收集循环内的复活对象中，
那么在下个循环前这张表有可能未被正确地清理。
<h2>2.6 – <a name="2.6">协程</a></h2>
<p>
Lua 支持协程，同时它也被称为 <em>协同式多线程</em>。
Lua 为每个协程提供一个独立的运行序。
然而和多线程系统中的线程不同，
协程仅在显式地调用一个让出函数时才挂起当前的执行状态。
<p>
通过调用
<a href="#pdf-coroutine.create"><code>coroutine.create</code></a>
可创建一个协程。
它唯一的参数是一个函数，这个函数将作为这个协程的主函数。
<code>create</code> 函数仅仅创建出这个协程然后返回它的句柄
（一个类型为 <em>thread</em> 的对象）；
它并不运行该协程。
<p>
通过调用
<a href="#pdf-coroutine.resume"><code>coroutine.resume</code></a>
可执行一个协程。
第一次调用
<a href="#pdf-coroutine.resume"><code>coroutine.resume</code></a>
时，第一个参数应传入
<a href="#pdf-coroutine.create"><code>coroutine.create</code></a>
返回的线程对象，这样协程就会从其主函数的第一行开始执行。
<a href="#pdf-coroutine.resume"><code>coroutine.resume</code></a>
后面的参数将作为主函数的参数传入。
协程将一直运行到它结束或 <em>让出</em>。
<p>
协程的运行可能被两种方式终止：
正常途径是主函数返回
（显式返回或运行完最后一条指令）；
非正常途径是发生了一个未被捕获的错误。
对于正常结束，
<a href="#pdf-coroutine.resume"><code>coroutine.resume</code></a> 将返回 <b>true</b>，
并接上协程主函数的返回值。
当错误发生时，
<a href="#pdf-coroutine.resume"><code>coroutine.resume</code></a> 将返回 <b>false</b>
与错误消息。
<p>
让出协程的执行通过调用
<a href="#pdf-coroutine.yield"><code>coroutine.yield</code></a> 完成。
当协程让出，
即使让出发生在内嵌函数调用中
（即不在主函数，但在主函数直接或间接调用的函数内部），
之前对该协程调用的 <a href="#pdf-coroutine.resume"><code>coroutine.resume</code></a> 会立刻返回。
在让出的情况下，
<a href="#pdf-coroutine.resume"><code>coroutine.resume</code></a> 依旧返回 <b>true</b>，
接下来的返回值是传给
<a href="#pdf-coroutine.yield"><code>coroutine.yield</code></a> 的那些参数。
当下一次你延续同一个协程时，
协程会接在让出点继续运行。
调用 <a href="#pdf-coroutine.yield"><code>coroutine.yield</code></a>
的让出点会返回传给
<a href="#pdf-coroutine.resume"><code>coroutine.resume</code></a>
的额外参数。
<p>
就像
<a href="#pdf-coroutine.create"><code>coroutine.create</code></a> 那样，
<a href="#pdf-coroutine.wrap"><code>coroutine.wrap</code></a> 函数也会创建一个协程。
不同的是，它不返回协程本身，而是返回一个函数。
调用这个函数将延续这个协程。
为这个函数提供的参数相当于
传给 <a href="#pdf-coroutine.resume"><code>coroutine.resume</code></a> 的额外参数。
<a href="#pdf-coroutine.wrap"><code>coroutine.wrap</code></a>
的返回值是
<a href="#pdf-coroutine.resume"><code>coroutine.resume</code></a>
的返回值中除去第一个返回值（布尔型的错误码）剩余的部分。
和 <a href="#pdf-coroutine.resume"><code>coroutine.resume</code></a> 不同，
<a href="#pdf-coroutine.wrap"><code>coroutine.wrap</code></a>
不会捕获错误；
错误会传播给调用者。
<p>
下面的代码展示了一个协程工作的范例：
<pre>
function foo (a)
print("foo", a)
return coroutine.yield(2*a)
end
co = coroutine.create(function (a,b)
print("co-body", a, b)
local r = foo(a+1)
print("co-body", r)
local r, s = coroutine.yield(a+b, a-b)
print("co-body", r, s)
return b, "end"
end)
print("main", coroutine.resume(co, 1, 10))
print("main", coroutine.resume(co, "r"))
print("main", coroutine.resume(co, "x", "y"))
print("main", coroutine.resume(co, "x", "y"))
</pre><p>
当你运行它，将产生下列输出：
<pre>
co-body 1 10
foo 2
main true 4
co-body r
main true 11 -9
co-body x y
main true 10 end
main false cannot resume dead coroutine
</pre>
<p>
你也可以通过 C API 来创建及操作协程：
参见函数
<a href="#lua_newthread"><code>lua_newthread</code></a>，
<a href="#lua_resume"><code>lua_resume</code></a>，
以及 <a href="#lua_yield"><code>lua_yield</code></a>。
<h1>3 – <a name="3">语言定义</a></h1>
<p>
这一章描述了 Lua 的词法、语法和句法。
换句话说，本章描述哪些符记是有效的，
它们如何被组合起来，这些组合方式有什么含义。
<p>
关于语言的构成概念将用常见的扩展 BNF 表达式写出。
也就是这个样子：
{<em>a</em>} 表示 0 或多个 <em>a</em>，
[<em>a</em>] 表示一个可选的 <em>a</em>。
可以被分解的非最终符号会这样写 non-terminal ，
关键字会写成这样 <b>kword</b>，
而其它不能被分解的最终符号则写成这样 ‘<b>=</b>’ 。
完整的 Lua 语法可以在本手册最后一章 <a href="#9">§9</a> 找到。
<h2>3.1 – <a name="3.1">词法约定</a></h2>
<p>
Lua 语言的格式自由。
它会忽略语法元素（符记）间的空格（包括换行）和注释，
仅把它们看作为名字和关键字间的分割符。
<p>
Lua 中的 <em>名字</em>
（也被称为 <em>标识符</em>）
可以是由非数字打头的任意字母下划线和数字构成的字符串。
标识符可用于对变量、表的域、以及标签命名。
<p>
下列 <em>关键字</em> 是保留的，不可用于名字：
<pre>
and break do else elseif end
false for function goto if in
local nil not or repeat return
then true until while
</pre>
<p>
Lua 语言对大小写敏感：
<code>and</code> 是一个保留字，但 <code>And</code> 与 <code>AND</code>
则是两个不同的有效名字。
作为一个约定，程序应避免创建以下划线加一个或多个大写字母构成的名字
（例如 <a href="#pdf-_VERSION"><code>_VERSION</code></a>）。
<p>
下列字符串是另外一些符记：
<pre>
+ - * / % ^ #
& ~ | << >> //
== ~= <= >= < > =
( ) { } [ ] ::
; : , . .. ...
</pre>
<p>
<em>字面串</em> 可以用单引号或双引号括起。
字面串内部可以包含下列 C 风格的转义串：
'<code>\a</code>' （响铃），
'<code>\b</code>' （退格），
'<code>\f</code>' （换页），
'<code>\n</code>' （换行），
'<code>\r</code>' （回车），
'<code>\t</code>' （横项制表），
'<code>\v</code>' （纵向制表），
'<code>\\</code>' （反斜杠），
'<code>\"</code>' （双引号），
以及 '<code>\'</code>' (单引号)。
在反斜杠后跟一个真正的换行等价于在字符串中写一个换行符。
转义串 '<code>\z</code>' 会忽略其后的一系列空白符，包括换行；
它在你需要对一个很长的字符串常量断行为多行并希望在每个新行保持缩进时非常有用。
<p>
Lua 中的字符串可以保存任意 8 位值，其中包括用 '<code>\0</code>' 表示的 0 。
一般而言，你可以用字符的数字值来表示这个字符。
方式是用转义串 <code>\x<em>XX</em></code>，
此处的 <em>XX</em> 必须是恰好两个字符的 16 进制数。
或者你也可以使用转义串 <code>\<em>ddd</em></code> ，
这里的 <em>ddd</em> 是一到三个十进制数字。
（注意，如果在转义符后接着恰巧是一个数字符号的话，
你就必须在这个转义形式中写满三个数字。）
<p>
对于用 UTF-8 编码的 Unicode 字符，你可以用
转义符 <code>\u{<em>XXX</em>}</code> 来表示
（这里必须有一对花括号），
此处的 <em>XXX</em> 是用 16 进制表示的字符编号。
<p>
字面串还可以用一种 <em>长括号</em> 括起来的方式定义。
我们把两个正的方括号间插入 <em>n</em> 个等号定义为 <em>第 <em>n</em> 级开长括号</em>。
就是说，0 级开的长括号写作 <code>[[</code> ， 一级开长括号写作 <code>[=[</code> ，
如此等等。
<em>闭长括号</em>也作类似定义；
举个例子，4 级反的长括号写作 <code>]====]</code> 。
一个 <em>长字面串</em> 可以由任何一级的开长括号开始，而由第一个碰到的同级的闭长括号结束。
这种方式描述的字符串可以包含任何东西，当然特定级别的反长括号除外。
整个词法分析过程将不受分行限制，不处理任何转义符，并且忽略掉任何不同级别的长括号。