Lua 5.1参考手册

 Lua 5.1参考手册

1 - 介绍
Lua是一种扩展编程语言，旨在支持具有数据描述功能的通用程序编程。它还为面向对象编程，函数式编程和数据驱动编程提供了很好的支持。Lua旨在用作任何需要的程序的功能强大，轻量级的脚本语言。Lua被实现为一个库，用干净的 C语言编写（即，在ANSI C和C ++的公共子集中）。


作为一种扩展语言，Lua没有“主要”程序的概念：它只能嵌入主机客户端，称为嵌入程序或简单的主机。这个主机程序可以调用函数来执行一段Lua代码，可以写入和读取Lua变量，并且可以注册由Lua代码调用的C函数。通过使用C函数，Lua可以被扩展来处理广泛的不同领域，从而创建定制的编程语言，共享一个语法框架。Lua发行版包含一个调用的主机程序示例lua，它使用Lua库来提供一个完整的，独立的Lua解释器。


Lua是免费的软件，并像往常一样提供没有担保，如其许可证所述。本手册中介绍的实施可在Lua的官方网站上找到www.lua.org。


像任何其他的参考手册一样，这个文件是干燥的地方。有关Lua设计背后的决定的讨论，请参阅Lua网站上的技术文章。有关Lua编程的详细介绍，请参阅Roberto的书，Lua编程（第二版）。


2 - 语言
本节介绍Lua的词汇，语法和语义。换句话说，本节描述哪些令牌是有效的，它们如何组合，以及它们的组合是什么意思。


语言结构将使用通常的扩展BNF符号进行解释，其中{ a }表示0或更多a，而[ a ]表示可选的a。非终端显示为非终端，关键字显示为kword，其他终端符号显示为“ = ”。Lua的完整语法可以在 本手册末尾的§8中找到。


2.1 - 词汇约定
Lua中的名称 （也称为标识符）可以是字母，数字和下划线的任何字符串，而不是以数字开始。这与大多数语言中的名字定义一致。（字母的定义取决于当前语言环境：任何被当前语言环境认为是字母的字符都可以用在标识符中。）标识符用于命名变量和表格字段。


以下关键字是保留的，不能用作名称：

     并打破别的elseif
     结束假功能如果
     在当地没有或没有
     重复返回，直到while
Lua是区分大小写的语言： and是一个保留字，但And并AND 是两个不同的，有效的名称。作为惯例，名称以下划线开头，后面跟大写字母（如_VERSION）保留给Lua使用的内部全局变量。

以下字符串表示其他标记：

     +  -  * /％^＃
     ==〜= <=> = <> =
     （）{} []
     ; ：，。.. ...
文字串 可以通过匹配单引号或双引号进行分隔，并且可以包含下面的C状的转义序列：“ \a”（钟形），“ \b”（退格），“ \f”（形式进料），“ \n”（换行），“ \r” （回车符），' \t'（水平制表符），' \v'（垂直制表符），' \\'（反斜杠），' \"'（引号[双引号]）和' \''（撇号[单引号]）。此外，一个反斜杠后跟一个真正的换行符会导致字符串换行。字符串中的字符也可以通过其数值使用转义序列来指定，其中ddd\ddd是一个最多三位十进制数字的序列。（请注意，如果数字转义后面跟着一个数字，则必须使用三位数字来表示。）Lua中的字符串可以包含任何8位值，包括嵌入的零，可以将其指定为“ \0'。

也可以使用由长括号括起来的长格式来定义文字字符串。我们定义一个开放的n级开放长括号作为开放的方括号，然后是n等号，然后是另一个开放的方括号。因此，0级[[开放长括号写为[=[，1级开放长括号写为，等等。甲长括号被类似地定义; 例如，4级的结尾长括号写为]====]。一个长的字符串从一个开放的任何级别的长支架开始，并在同一级别的第一个关闭长支架结束。括号内的文字可以运行多行，不要解释任何转义序列，忽略任何其他级别的长括号。它们可以包含除适当级别的右括号之外的任何内容。

为方便起见，当开头的长括号紧跟着一个换行符时，换行符不包含在字符串中。例如，在一个使用ASCII的系统中（其中' a'编码为97，新行编码为10，' 1'编码为49），下面的五个字符串表示相同的字符串：

     a ='alo \ n123“'
     a =“alo \ n123 \”“
     a ='\ 97lo \ 10 \ 04923''
     a = [[al
     123" ]]
     a = [== [
     ALO
     123" ] ==]
甲数值常数可以与一个可选的小数部分和可选的小数指数被写入。Lua也接受整数十六进制常量，通过前缀0x。有效的数字常量的例子是


     3 3.0 3.1416 314.16e-2 0.31416E1 0xff 0x56
一个注释开始用双连字符（--）的字符串以外的任何地方。如果紧接着的文本--不是开头的长括号，则注释是一个简短的注释，直到行尾。否则，这是一个长期的评论，它运行，直到相应的结束长期支架。经常使用长注释来临时禁用代码。


2.2 - 值和类型
Lua是一种动态类型的语言。这意味着变量没有类型; 只有值才能做到。语言中没有类型定义。所有的价值观都有自己的类型。


Lua中的所有值都是一流的值。这意味着所有值都可以存储在变量中，作为参数传递给其他函数，并作为结果返回。


Lua中有八种基本类型： nil，boolean，number， string，function，userdata， thread和table。类型零有一个单一的值，零，其主要性质是不同于任何其他价值; 它通常代表没有有用的价值。布尔类型有两个值，false和true。两个零和假赚了条件为假; 任何其他的价值都是如此。该类型的号码代表整数和实数（浮点数）。类型字符串表示不可变的字节序列。Lua是8位清理：字符串可以包含任何8位值，包括嵌入的零（' \0'）。Lua也是编码不可知的; 它不会假定字符串的内容。


类型编号使用两个内部表示，或两个子类型，一个称为整型，另一个称为浮点型。Lua明确规定了每个表示的使用时间，但是它也根据需要自动进行转换（见§3.4.3）。因此，程序员可能会选择忽略整数和浮点之间的差异，或者完全控制每个数字的表示。标准Lua使用64位整数和双精度（64位）浮点数，但是也可以编译Lua，以便使用32位整数和/或单精度浮点数（32位）。对于小型机器和嵌入式系统，整数和浮点数都是32位的选项特别有吸引力。（见宏LUA_32BITS在文件中）luaconf.h。


Lua可以调用（和操作）用Lua编写的函数和用C编写的函数（参见§3.4.10）。两者都由类型函数表示。


提供 类型userdata以允许将任意C数据存储在Lua变量中。用户数据值表示一块原始内存。有两种用户数据： 完整的用户数据，它是一个由Lua管理的内存块的对象，和轻量级的用户数据，它只是一个C指针值。用户数据在Lua中没有预定义的操作，除了赋值和身份测试。通过使用metatables，程序员可以定义完整的用户数据值的操作（见§2.4）。用户数据值不能在Lua中创建或修改，只能通过C API。这保证了主机程序拥有的数据的完整性。


类型线程表示独立的执行线程，用于实现协程（参见§2.6）。Lua线程与操作系统线程无关。Lua支持所有系统上的协同程序，甚至是那些本地不支持线程的协程。


类型表实现了关联数组，即不仅可以用数字进行索引的数组，也可以使用除nil和NaN 之外的任何Lua值。（不是数字是用来表示未定义或不可表示的数字结果的特殊值，例如0/0。）表可以是异构的 ; 也就是说，它们可以包含所有类型的值（nil除外）。任何值为零的键都不被视为表格的一部分。相反，任何不属于表的键都有一个关联的值nil。

表是Lua中唯一的数据结构化机制; 它们可以用来表示普通数组，列表，符号表，集合，记录，图形，树等。为了表示记录，Lua使用字段名称作为索引。该语言通过提供a.name作为语法糖来支持这种表示a["name"]。在Lua中创建表格有几种方便的方法（参见§3.4.9）。

像索引一样，表字段的值可以是任何类型的。特别是，因为函数是一流的值，所以表字段可以包含函数。因此表格也可以携带方法（见§3.4.11）。

表的索引遵循语言中原始平等的定义。表达式a[i]和a[j] 表示同一个表元素当且仅当i和j原始相等（即没有元方法时相等）。具体而言，具有整数值的浮点数等于它们各自的整数（例如1.0 == 1）。为了避免歧义，任何用整数值作为键的浮点数都被转换为相应的整数。例如，如果你写的话a[2.0] = true，插入到表中的实际密钥将是整数2。（另一方面，2和“ 2”是不同的Lua值，因此表示不同的表项。）
表，函数，线程和（完整）用户数据值都是对象：变量实际上不包含这些值，只有对它们的引用。赋值，参数传递和函数返回总是操作对这些值的引用; 这些操作并不意味着任何形式的副本。
库函数type返回一个描述给定值类型的字符串（见§6.1）。

与索引一样，表字段的值可以是任何类型（除非为零）。特别是，因为函数是一流的值，所以表字段可以包含函数。因此表格也可以携带方法（见§2.5.9）

表，函数，线程和（完整）用户数据值都是对象：变量实际上不包含这些值，只有对它们的引用。赋值，参数传递和函数返回总是操作对这些值的引用; 这些操作并不意味着任何形式的副本。
库函数type返回一个描述给定值类型的字符串。


2.2.1 - 胁迫
Lua在运行时提供字符串和数字值之间的自动转换。应用于字符串的任何算术运算都会尝试将此字符串转换为数字，遵循通常的转换规则。相反，只要在需要字符串的地方使用数字，数字就会以合理的格式转换为字符串。要完全控制数字如何转换为字符串，请使用format字符串库中的函数（请参阅参考资料string.format）。


2.3 - 变量
变量是存储值的地方。Lua中有三种变量：全局变量，局部变量和表格字段。


一个名称可以表示一个全局变量或一个局部变量（或一个函数的形式参数，它是一种特殊的局部变量）：


var :: =名称
名称表示标识符，如§2.1中定义。


任何变量都被认为是全局的，除非显式声明为局部变量（见§2.4.7）。局部变量在词汇范围上：局部变量可以通过在其范围内定义的函数自由访问（见第2.6节）。


在第一次赋值给变量之前，它的值是零。


方括号用于索引表：


var :: = prefixexp` [ ' exp` ] '
访问全局变量和表字段的含义可以通过metatables来改变。对索引变量的访问t[i]相当于一个调用gettable_event(t,i)。（关于函数的完整描述见§2.8， gettable_event这个函数在Lua中没有定义或调用，我们在这里只是为了解释目的。


语法var.Name只是语法糖 var["Name"]：


var :: = prefixexp` 。名称
所有的全局变量都作为普通的Lua表中的字段来使用，称为环境表或简单的 环境（见§2.9）。每个函数都有自己对一个环境的引用，所以这个函数中的所有全局变量都会引用这个环境表。当一个函数被创建时，它会从创建它的函数继承这个环境。要获得一个Lua函数的环境表，你可以调用getfenv。要取代它，你打电话setfenv。（你只能通过调试库来操作C函数的环境;（见5.9））


对全局变量的访问x 相当于_env.x，而这相当于


     gettable_event（_env，“x”）
_env运行功能的环境 在哪里？（关于函数的完整描述见§2.8， gettable_event这个函数在Lua中没有定义或调用，同样的，这个_env变量也没有在Lua中定义，我们在这里只是为了说明的目的而使用它们。


2.4 - 陈述
Lua支持几乎常规的语句集，类似于Pascal或C语言。这个集合包括赋值，控制结构，函数调用和变量声明。


2.4.1 - 块
Lua的执行单位被称为一个块。块只是一系列的语句，按顺序执行。每个语句可以选择后跟一个分号：


chunk :: = {stat [` ; ']}
There are no empty statements and thus ';;' is not legal.


Lua handles a chunk as the body of an anonymous function with a variable number of arguments (see §2.5.9). As such, chunks can define local variables, receive arguments, and return values.


A chunk can be stored in a file or in a string inside the host program. To execute a chunk, Lua first pre-compiles the chunk into instructions for a virtual machine, and then it executes the compiled code with an interpreter for the virtual machine.


Chunks can also be pre-compiled into binary form; see program luac for details. Programs in source and compiled forms are interchangeable; Lua automatically detects the file type and acts accordingly.


2.4.2 – Blocks
A block is a list of statements; syntactically, a block is the same as a chunk:


block ::= chunk
A block can be explicitly delimited to produce a single statement:


stat ::= do block end
Explicit blocks are useful to control the scope of variable declarations. Explicit blocks are also sometimes used to add a return or break statement in the middle of another block (see §2.4.4).


2.4.3 – Assignment
Lua allows multiple assignments. Therefore, the syntax for assignment defines a list of variables on the left side and a list of expressions on the right side. The elements in both lists are separated by commas:


stat ::= varlist `=´ explist
varlist ::= var {`,´ var}
explist ::= exp {`,´ exp}
Expressions are discussed in §2.5.


Before the assignment, the list of values is adjusted to the length of the list of variables. If there are more values than needed, the excess values are thrown away. If there are fewer values than needed, the list is extended with as many nil's as needed. If the list of expressions ends with a function call, then all values returned by that call enter the list of values, before the adjustment (except when the call is enclosed in parentheses; see §2.5).


The assignment statement first evaluates all its expressions and only then are the assignments performed. Thus the code


     我= 3
     我，a [i] = i + 1，20
设置a[3]为20，而不会影响，a[4] 因为i在a[i]分配之前评估（至3）。4.同样，行


     x，y = y，x
交换x和y，和 的价值


     x，y，z = y，z，x
周期性的置换的值x，y和z。


赋值给全局变量和表字段的含义可以通过metatables来改变。对索引变量的赋值t[i] = val等同于 settable_event(t,i,val)。（关于函数的完整描述见§2.8， settable_event这个函数在Lua中没有定义或调用，我们在这里只是为了解释目的。


对全局变量x = val 的赋值等同于赋值_env.x = val，而赋值 又相当于


     settable_event（_env，“x”，val）
_env运行功能的环境 在哪里？（这个_env变量在Lua中没有定义，我们在这里使用它只是为了解释的目的。）


2.4.4 - 控制结构
控制结构 ，如果，同时和重复具有通常意义和熟悉的语法：


STAT :: = 而 EXP 做阻断年底 
统计:: = 重复块，直到 EXP
stat :: = if exp then block { elseif exp then block} [ else block] end
Lua中也有一个用于说法，两种口味（见§2.4.5）。


控制结构的条件表达式可以返回任何值。这两种假和零被认为是假的。所有不同于nil和false的值都被认为是真的（特别是数字0和空字符串也是如此）。


在repeat - until循环中，内部块不会在until关键字处结束，而只会在条件之后结束。所以，条件可以引用在循环块中声明的局部变量。


在返回语句用来从一个函数或块（这仅仅是一个函数）返回值。函数和块可以返回多个值，所以return语句的语法是


stat :: = return [explist]
该休息语句用于终止执行 ，同时，重复，或用于循环，跳到循环之后的下一条语句：


stat :: = break
甲休息结束该最内层循环。


该回报和休息 语句只能写成最后一个块的声明。如果真的有必要回归或破裂的块的中间，然后一个明确的内部块都可以使用，如在成语 do return end和do break end，因为现在恢复和休息在他们（内部）块的最后陈述。


2.4.5 - 用于陈述
该对语句有两种形式：一个数字和一个通用的。


该对语句有两种形式：一个数字和一个通用的。


数值为同时控制变量通过算术级数运行循环重复的代码块。它具有以下语法：


stat :: = for name' = 'exp' ， 'exp [' ， 'exp] do block end
该块从第一个exp的值开始重复名称，直到第三个exp的步骤通过第二个exp。更确切地说，一个for语句像


     对于v = e1，e2，e3做块结束
相当于代码：


     做
       当地var，限制，step = tonumber（e1），tonumber（e2），tonumber（e3）
       如果不是（var和limit和step），则error（）结束
        var = var - step
       而真的呢
         var = var + step 
         if（step > = 0且var > limit）或（step <0 and var < limit）
           打破
         结束
         本地v = var 
         块
       结束
     结束
请注意以下几点：


在循环开始之前，所有三个控制表达式都只计算一次。他们都必须得到数字。
var，limit并且step是不可见的变量。此处显示的名称仅用于说明目的。
如果第三个表达式（步骤）不存在，则使用1的步骤。
你可以使用break和goto来退出一个for循环。
循环变量v是循环体的局部变量。如果在循环之后需要它的值，则在退出循环之前将其分配给另一个变量。
通用的声明在工作职能，叫做迭代器。在每次迭代中，迭代器函数被调用来产生一个新值，当这个新值为零时停止。泛型for循环具有以下语法：


STAT :: = 对于名称列表中 explist 不阻止端 
名称列表:: = {名称“ ”名称}
一个for语句像


     对于VAR_1，...，var_n在explist做块结束
相当于代码：


     做
       本地f，s，var = explist
       而真的呢
         局部var_1，...，var_n = f（s，var）
         如果var_1 == nil，则结束
          var = var_1 
         块
       结束
     结束
请注意以下几点：


explist只评估一次。其结果是第一个迭代器变量的迭代器函数，状态和初始值。
f，s并且var是不可见的变量。名字只是为了解释的目的。
您可以使用break来退出for循环。
循环变量var_i是循环的局部变量; 之后，你不能用自己的价值观为目的。如果您需要这些值，则在分解或退出循环之前将其分配给其他变量。
2.4.6 – Function Calls as Statements
To allow possible side-effects, function calls can be executed as statements:


stat ::= functioncall
In this case, all returned values are thrown away. Function calls are explained in §2.5.8.


2.4.7 – Local Declarations
Local variables can be declared anywhere inside a block. The declaration can include an initial assignment:


stat ::= local namelist [`=´ explist]
If present, an initial assignment has the same semantics of a multiple assignment (see §2.4.3). Otherwise, all variables are initialized with nil.


A chunk is also a block (see §2.4.1), and so local variables can be declared in a chunk outside any explicit block. The scope of such local variables extends until the end of the chunk.


The visibility rules for local variables are explained in §2.6.


2.5 – Expressions
The basic expressions in Lua are the following:


exp ::= prefixexp
exp ::= nil | false | true
exp ::= Number
exp ::= String
exp ::= function
exp ::= tableconstructor
exp ::= `...´
exp ::= exp binop exp
exp ::= unop exp
prefixexp ::= var | functioncall | `(´ exp `)´
Numbers and literal strings are explained in §2.1; variables are explained in §2.3; function definitions are explained in §2.5.9; function calls are explained in §2.5.8; table constructors are explained in §2.5.7. Vararg expressions, denoted by three dots ('...'), can only be used when directly inside a vararg function; they are explained in §2.5.9.


Binary operators comprise arithmetic operators (see §2.5.1), relational operators (see §2.5.2), logical operators (see §2.5.3), and the concatenation operator (see §2.5.4). Unary operators comprise the unary minus (see §2.5.1), the unary not (see §2.5.3), and the unary length operator (see §2.5.5).


Both function calls and vararg expressions can result in multiple values. If an expression is used as a statement (only possible for function calls (see §2.4.6)), then its return list is adjusted to zero elements, thus discarding all returned values. If an expression is used as the last (or the only) element of a list of expressions, then no adjustment is made (unless the call is enclosed in parentheses). In all other contexts, Lua adjusts the result list to one element, discarding all values except the first one.


Here are some examples:


     f()                -- adjusted to 0 results
     g(f(), x)          -- f() is adjusted to 1 result
     g(x, f())          -- g gets x plus all results from f()
     a,b,c = f(), x     -- f() is adjusted to 1 result (c gets nil)
     a,b = ...          -- a gets the first vararg parameter, b gets
                        -- the second (both a and b can get nil if there
                        -- is no corresponding vararg parameter)
     
     a,b,c = x, f()     -- f() is adjusted to 2 results
     a,b,c = f()        -- f() is adjusted to 3 results
     return f()         -- returns all results from f()
     return ...         -- returns all received vararg parameters
     return x,y,f()     -- returns x, y, and all results from f()
     {f()}              -- creates a list with all results from f()
     {...}              -- creates a list with all vararg parameters
     {f(), nil}         -- f() is adjusted to 1 result
Any expression enclosed in parentheses always results in only one value. Thus, (f(x,y,z)) is always a single value, even if f returns several values. (The value of (f(x,y,z)) is the first value returned by f or nil if f does not return any values.)


2.5.1 – Arithmetic Operators
Lua supports the usual arithmetic operators: the binary + (addition), - (subtraction), * (multiplication), / (division), % (modulo), and ^ (exponentiation); and unary - (negation). If the operands are numbers, or strings that can be converted to numbers (see §2.2.1), then all operations have the usual meaning. Exponentiation works for any exponent. For instance, x^(-0.5) computes the inverse of the square root of x. Modulo is defined as


     a % b == a - math.floor(a/b)*b
That is, it is the remainder of a division that rounds the quotient towards minus infinity.


2.5.2 – Relational Operators
The relational operators in Lua are


     ==    ~=    <     >     <=    >=
这些操作员总是导致错误或真实。


Equality（==）首先比较其操作数的类型。如果类型不同，那么结果是错误的。否则，将比较操作数的值。数字和字符串以通常的方式进行比较。对象（表，用户数据，线程，和函数）是通过比较参考：两个对象被认为是只有当它们是相等同的对象。每当你创建一个新的对象（一个表，用户数据，线程或函数）时，这个新对象都不同于任何先前存在的对象。


你可以通过使用“eq”元方法来改变Lua比较表和用户数据的方式（见§2.8）。


的转换规则§2.2.1 不适用于相等比较。因此，"0"==0计算结果为假，并t[0]和t["0"]在表中表示不同的条目。


运算符~=正是等于（==）的否定。


订单操作员的工作如下。如果两个参数都是数字，那么他们就是这样比较的。否则，如果两个参数都是字符串，则根据当前的语言环境比较它们的值。否则，Lua会尝试调用“lt”或“le”元方法（请参阅第2.8节）。一个比较a > b被翻译成b < a 并a >= b翻译成b <= a。


2.5.3 - 逻辑运算符
Lua中的逻辑运算符是 和，或者，而不是。就像控制结构一样（见§2.4.4），所有的逻辑运算符都把false和nil都视为假，其他的都是真的。


否定运算符不总是返回false或true。的结合操作和如果该值返回第一个参数假或零 ; 否则，并且返回第二个参数。析取操作或如果这个值是从不同的返回它的第一个参数零和假 ; 否则，或者返回第二个参数。无论与和或使用快捷评价; 也就是说，第二个操作数仅在必要时才被评估。这里有些例子：


     10或20  - > 10
     10或错误（） - > 10
     零或“a” - >“a”
     零和10  - >无
     错误和错误（） - >错误
     假和无 - >错误
     虚假或零 - >零
     10和20  - > 20
（在本手册中， -->表示前面的表达式的结果。）


2.5.4 - 连接
Lua中的字符串连接运算符用两个点（' ..'）表示。如果两个操作数都是字符串或数字，则根据§2.2.1中提到的规则将它们转换为字符串。否则，调用“concat”元方法（参见§2.8）。


2.5.5 - 长度运算符
长度运算符由一元运算符表示#。字符串的长度是它的字节数（也就是每个字符是一个字节时字符串长度的通常含义）。


表的长度t被定义为任何整数索引n ，使得t[n]不是零，并且t[n+1]是零 ; 而且，如果t[1]是零，n可以是零。对于一个规则的数组，非零值从1到给定n，它的长度就是n它的最后一个值的索引。如果该数组有“洞”（即，零其它非零值之间的值），则#t可以是任何直接先于所述指数的零值（即，可考虑任何这样的零值作为所述端部数组）。


2.5.6 - 优先
Lua中的运算符优先级如下表所示，从低到高优先级：


     要么
     和
     <> <=> =〜= ==
     ..
     +  - 
     * /％
     不是＃ - （一元）
     ^
像往常一样，您可以使用圆括号来更改表达式的优先顺序。连接（' ..'）和求幂（' ^'）操作符是正确的关联。所有其他二元运算符都是关联的。


2.5.7 - 表构造器
表构造函数是创建表的表达式。每次评估构造函数时，都会创建一个新表。一个构造函数可以用来创建一个空表或者创建一个表并初始化它的一些字段。构造函数的一般语法是


tableconstructor :: =` { '[fieldlist]` } '
fieldlist :: = field {fieldsep field} [fieldsep]
field :: =` [ 'exp` ] '` = 'exp | 名称` = 'exp | EXP
fieldsep :: =` ， '| ` ; “
表单的每个字段都会[exp1] = exp2向新表添加一个包含键exp1和值的条目exp2。表单的字段name = exp相当于 ["name"] = exp。最后，表单字段exp相当于 [i] = exp，在那里i是连续的数值整数，1在其他格式字段开始不影响此计数。例如，


     a = {[f（1）] = g; “x”，“y”; x = 1，f（x），[30] = 23; 45}
相当于


     做
       本地t = {}
       t [f（1）] = g
       t [1] =“x” - 第一个exp
       t [2] =“y” - 第二个exp
       tx = 1  -  t [“x”] = 1
       t [3] = f（x） - 第3个exp
       t [30] = 23
       t [4] = 45  - 第四课
       a = t
     结束
如果列表中的最后一个字段是形式exp ，而表达式是一个函数调用或一个可变参数表达式，那么这个表达式返回的所有值都会连续地进入列表（见§2.5.8）。为了避免这种情况，请将函数调用或可变参数表达式括在括号内（请参阅第2.5节）。


字段列表可以有一个可选的结尾分隔符，以方便机器生成的代码。


2.5.8 - 函数调用
Lua中的函数调用具有以下语法：


functioncall :: = prefixexp args
在一个函数调用中，第一个prefixexp和args被评估。如果prefixexp的值具有类型函数，则使用给定的参数调用该函数。否则，调用prefixexp“call”metamethod，将prefixexp的值作为第一个参数，然后是原始的调用参数（请参阅第2.8节）。


表格


functioncall :: = prefixexp` ： '名称参数
可以用来调用“方法”。一个调用 是语法糖，除了只评估一次。 v:name(args)v.name(v,args)v


参数具有以下语法：


args :: =` （ '[explist]` ） '
args :: = tableconstructor
args :: = String
在调用之前，所有参数表达式都被计算。一个形式的调用是语法糖; 也就是说，参数列表是一个新的表格。形式 （或或）的调用是语法糖; 也就是说，参数列表是一个单一的文字字符串。 f{fields}f({fields})f'string'f"string"f[[string]]f('string')


作为Lua的自由格式语法的一个例外，你不能(在函数调用中的' ' 之前放一个换行符。这一限制避免了语言中的一些含糊之处。如果你写


     a = f
     （克）.X（a）中
Lua会把这个看成是一个单一的陈述a = f(g).x(a)。所以，如果你想要两个语句，你必须在它们之间添加一个分号。如果你真的想打电话f，你必须先删除换行符(g)。


return 函数 形式的调用叫做尾调用。Lua实现适当的尾部调用 （或适当的尾部递归）：在尾部调用中，被调用函数重用调用函数的堆栈条目。因此，程序可以执行的嵌套尾调用的数量没有限制。但是，尾部调用将删除有关调用函数的任何调试信息。请注意，tail调用只会发生在特定的语法，其中返回有一个单一的函数调用作为参数; 这个语法使调用函数完全返回被调用函数的返回值。所以，下面的例子都不是尾调用：


     返回（f（x）） - 结果调整为1
     返回2 * f（x）
     返回x，f（x） - 附加结果
     F（X）; 返回 - 结果丢弃
     返回x或f（x） - 结果调整为1
2.5.9 - 功能定义
函数定义的语法是


function :: = function funcbody
funcbody :: =` （ '[parlist]` ） '块结束
下面的语法糖简化了函数定义：


stat :: = function funcname funcbody
stat :: = 本地 函数名称funcbody
funcname :: =名称{` 。'Name} [` ： 'Name]
该声明


     函数f（）体结束
翻译成


     f = function（）正文结束
该声明


     函数tabcf（）正文结束
翻译成


     tabcf = function（）正文结束
该声明


     本地函数f（）正文结束
翻译成


     本地f; f = function（）正文结束
不给


     本地f =函数（）身体结束
（这只有在函数的主体包含引用时才有所作用f。）


函数定义是一个可执行的表达式，其值具有类型函数。当Lua预编译一个块时，它的所有函数体也被预编译。然后，每当Lua执行函数定义，函数就被实例化（或关闭）。这个函数实例（或闭包）是表达式的最终值。同一个函数的不同实例可以引用不同的外部局部变量，并可以有不同的环境表。


参数作为使用参数值初始化的局部变量：


parlist :: = namelist [` ， '` ... '] | ` ... '
当一个函数被调用时，参数列表将被调整为参数列表的长度，除非该函数是可变参数或可变参数函数，...在参数列表的末尾用三个点（“ '）表示。可变参数函数不调整参数列表; 相反，它收集所有额外的参数，并通过可变表达式将它们提供给函数，也写成三个点。此表达式的值是所有实际额外参数的列表，类似于具有多个结果的函数。如果在另一个表达式或表达式列表的中间使用可变表达式，则将其返回列表调整为一个元素。如果表达式用作表达式列表的最后一个元素，则不做任何调整（除非最后一个表达式括在圆括号中）。


作为例子，请考虑以下定义：


     函数f（a，b）结束
     函数g（a，b，...）结束
     函数r（）返回1,2,3结束
然后，我们有以下从参数到参数和可变参数表达式的映射：


     呼叫参数
     
     f（3）a = 3，b = nil
     f（3,4）a = 3，b = 4
     f（3,4,5）a = 3，b = 4
     f（r（），10）a = 1，b = 10
     f（r（））a = 1，b = 2
     
     g（3）a = 3，b = nil，...  - >（无）
     g（3,4）a = 3，b = 4，...→（无）
     g（3,4,5,8）a = 3，b = 4，...，> 5 8
     g（5，r（））a = 5，b = 1，...，> 2 3
结果使用return语句返回（请参阅第2.4.4节）。如果控件在没有遇到return语句的情况下到达函数的结尾，那么该函数将返回而没有结果。


在结肠语法用于定义方法，即，具有一个隐含的额外的参数的功能self。因此，声明


     函数tabc：f（params）body end
是语法糖


     tabcf = function（self，params）body end
2.6 - 可见性规则
Lua是一个词汇范围的语言。变量的范围从声明后的第一个语句开始， 一直持续到包含声明的最内层块的末尾。考虑下面的例子：


     x = 10  - 全局变量
     做 - 新的块
       本地x = x  - 新的“x”，值为10
       打印（x） - > 10
       x = x + 1
       做 - 另一个块
         本地x = x + 1  - 另一个'x'
         打印（x） - > 12
       结束
       print（x） - > 11
     结束
     打印（x） - > 10（全球一个）
请注意，在声明中local x = x，声明的新x声明不在范围内，所以第二个声明是x外部变量。


由于词法范围规则，局部变量可以通过范围内定义的函数自由访问。内部函数使用的局部变量在内部函数内被称为upvalue或外部局部变量。


注意每个本地语句的执行定义了新的局部变量。考虑下面的例子：


     a = {}
     本地x = 20
     因为我= 1,10
       本地y = 0
       a [i] = function（）y = y + 1; 返回x + y结束
     结束
该循环创建十个闭包（即，匿名函数的十个实例）。每个关闭使用一个不同的y变量，而他们都共享相同x。


2.7 - 错误处理
由于Lua是一种嵌入式扩展语言，因此所有Lua动作都从主机程序中的C代码开始，从Lua库中调用一个函数（请参阅参考资料lua_pcall）。每当Lua编译或执行期间发生错误，控制权就会返回到C，C可以采取适当的措施（如打印错误消息）。


Lua代码可以通过调用该error函数来明确地产生一个错误 。如果你需要在Lua中发现错误，你可以使用这个pcall函数。


2.8 - Metatables
Lua中的每个值都可以有一个元表。这个metatable是一个普通的Lua表，它定义了特定操作下原始值的行为。您可以通过在其元表中设置特定字段来改变操作行为的多个方面。例如，当一个非数字值是一个加法的操作数时，Lua检查"__add"其元表中的一个函数。如果找到了，则Lua调用这个函数来执行加法。


我们在一个metatable 事件 和metamethods中调用这个键。在前面的例子中，事件是"add" 和metamethod是执行加法的函数。


您可以通过getmetatable函数查询任何值的元表。


您可以通过该setmetatable 函数替换表格的元数据。你不能从Lua中改变其他类型的metatable（除了使用调试库）。你必须使用C API。


表和完整的用户数据有单独的metatables（尽管多个表和userdata可以共享他们的metatables）。所有其他类型的值每个类型共享一个单一的metatable; 也就是说，所有的数字都有一个单一的metatable，所有的字符串都有一个单一的metatable。


一个metatable控制一个对象在算术运算，排序比较，连接，长度操作和索引中的表现。metatable也可以定义一个函数，当用户数据被垃圾收集时被调用。对于这些操作中的每一个，Lua都会关联一个称为事件的特定键。当Lua通过一个值执行这些操作之一时，它会检查这个值是否与相应的事件有一个metatable。如果是这样，与该键相关的值（metamethod）将控制Lua如何执行操作。


Metatables控制下面列出的操作。每个操作都由其相应的名称标识。每个操作的关键字是一个字符串，其名称前面加两个下划线“ __'; 例如，操作“add”的键是字符串"__add"。这些操作的语义可以用描述解释器如何执行操作的Lua函数来解释。


这里在Lua中显示的代码只是说明性的; 真正的行为在解释器中被硬编码，并且比这个模拟更有效率。在这些描述（使用所有的功能rawget，tonumber等）中描述§5.1。特别是，要检索给定对象的元方法，我们使用表达式


     元表（OBJ）[事件]
这应该被解读为


     rawget（getmetatable（obj）或{}，event）
也就是说，对元方法的访问不会调用其他元方法，并且对没有元表达式的对象的访问不会失败（它只是导致nil）。


“添加”： 该+操作。
getbinhandler下面 的函数定义了Lua如何为二元操作选择一个处理程序。首先，Lua尝试第一个操作数。如果它的类型没有为操作定义一个处理程序，那么Lua尝试第二个操作数。


     函数getbinhandler（op1，op2，event）
       返回metatable（op1）[event]或metatable（op2）[event]
     结束
通过使用这个函数，op1 + op2is 的行为


     函数add_event（op1，op2）
       当地o1，o2 = tonumber（op1），tonumber（op2）
       如果o1和o2那么 - 两个操作数都是数字的？
         返回o1 + o2  - '+'这里是原始的'add'
       否则 - 至少有一个操作数不是数字
         本地h = getbinhandler（op1，op2，“__add”）
         如果h然后
           - 用两个操作数调用处理程序
           返回（h（op1，op2））
         其他 - 没有可用的处理程序：默认行为
           错误（···）
         结束
       结束
     结束
“子”： 该-操作。类似于“添加”操作的行为。
“MUL”： 该*操作。类似于“添加”操作的行为。
“格”： 该/操作。类似于“添加”操作的行为。
“国防部”： 该%操作。类似于“添加”操作的行为，操作 o1 - floor(o1/o2)*o2是基本操作。
“POW”： 在^（幂）操作。类似于“添加”操作的行为，其中函数pow（来自C数学库）作为基本操作。
“unm”： 一元-操作。
     函数unm_event（op）
       本地o = tonumber（op）
       如果那么 - 操作数是数字？
         返回-o  - ' - '这里是原始的'unm'
       否则 - 操作数不是数字。
         - 尝试从操作数中获取一个处理程序
         本地h = metatable（op）.__ unm
         如果h然后
           - 用操作数调用处理程序
           返回（h（op））
         其他 - 没有可用的处理程序：默认行为
           错误（···）
         结束
       结束
     结束
“CONCAT”： 在..（串联）的操作。
     函数concat_event（op1，op2）
       如果（type（op1）==“string”或type（op1）==“number”）和
          （type（op2）==“string”or type（op2）==“number”）
         返回op1 .. op2  - 原始字符串连接
       其他
         本地h = getbinhandler（op1，op2，“__concat”）
         如果h然后
           返回（h（op1，op2））
         其他
           错误（···）
         结束
       结束
     结束
“LEN”： 该#操作。
     函数len_event（op）
       如果输入（op）==“string”那么
         返回strlen（op） - 原始字符串长度
       elseif类型（op）==“表”然后
         返回#op  - 原始表的长度
       其他
         本地h = metatable（op）.__ len
         如果h然后
           - 用操作数调用处理程序
           返回（h（op））
         其他 - 没有可用的处理程序：默认行为
           错误（···）
         结束
       结束
     结束
关于表的长度的描述 见§2.5.5。


“情商”： 该==操作。该函数getcomphandler定义了Lua如何为比较运算符选择一个元方法。仅当被比较的两个对象具有相同的类型和所选操作的相同元方法时才选择元方法。
     函数getcomphandler（op1，op2，event）
       如果输入（op1）〜= type（op2）则返回nil结束
       局部mm1 = metatable（op1）[事件]
       局部mm2 = metatable（op2）[事件]
       如果mm1 == mm2则返回mm1否则返回零结束
     结束
“eq”事件定义如下：


     函数eq_event（op1，op2）
       如果输入（op1）〜= type（op2）那么 - 不同的类型？
         返回false  - 不同的对象
       结束
       如果op1 == op2然后 - 原语相等？
         返回true  - 对象是平等的
       结束
       - 尝试metamethod
       本地h = getcomphandler（op1，op2，“__eq”）
       如果h然后
         返回（h（op1，op2））
       其他
         返回false
       结束
     结束
a ~= b相当于not (a == b)。


“LT”： 该<操作。
     函数lt_event（op1，op2）
       如果输入（op1）==“数字”，然后输入（op2）==“数字”
         返回op1        elseif类型（op1）==“string”，然后键入（op2）==“string”
         返回op1        其他
         本地h = getcomphandler（op1，op2，“__lt”）
         如果h然后
           返回（h（op1，op2））
         其他
           错误（···）
         结束
       结束
     结束
a > b相当于b < a。


“乐”： 该<=操作。
     函数le_event（op1，op2）
       如果输入（op1）==“数字”，然后输入（op2）==“数字”
         返回op1 <= op2  - 数字比较
       elseif类型（op1）==“string”，然后键入（op2）==“string”
         返回op1 <= op2  - 词典对比
       其他
         本地h = getcomphandler（op1，op2，“__le”）
         如果h然后
           返回（h（op1，op2））
         其他
           h = getcomphandler（op1，op2，“__lt”）
           如果h然后
             不返回h（op2，op1）
           其他
             错误（···）
           结束
         结束
       结束
     结束
a >= b相当于b <= a。请注意，在没有“le”元方法的情况下，Lua会尝试“lt”，假设a <= b相当于not (b < a)。


“索引”： 索引访问table[key]。
     函数gettable_event（表，键）
       当地时间
       如果输入（表）==“表”，那么
         本地v = rawget（表，键）
         如果v〜= nil，则返回v结束
         h = metatable（表）.__索引
         如果h == nil则返回nil结束
       其他
         h = metatable（表）.__索引
         如果h == nil那么
           错误（···）
         结束
       结束
       如果输入（h）==“功能”那么
         返回（h（table，key）） - 调用处理程序
       否则返回h [键]  - 或重复操作
       结束
     结束
“newindex”： 索引分配table[key] = value。
     函数settable_event（表，键，值）
       当地时间
       如果输入（表）==“表”，那么
         本地v = rawget（表，键）
         如果v〜= nil则rawset（table，key，value）; 回报结束
         h = metatable（表）.__ newindex
         如果h == nil则rawset（table，key，value）; 回报结束
       其他
         h = metatable（表）.__ newindex
         如果h == nil那么
           错误（···）
         结束
       结束
       如果输入（h）==“功能”那么
         h（表，键，值） - 调用处理程序
       否则h [key] = value  - 或者对其重复操作
       结束
     结束
“call”： 当Lua调用一个值时调用。
     函数function_event（func，...）
       如果输入（func）==“功能”那么
         返回func（...） - 原始调用
       其他
         本地h = metatable（func）.__调用
         如果h然后
           返回h（func，...）
         其他
           错误（···）
         结束
       结束
     结束
2.9 - 环境
除了元表，线程，函数和用户数据类型的对象还有另一个与它们关联的表，称为它们的环境。像metatables一样，环境是常规的表，多个对象可以共享相同的环境。


创建线程共享创建线程的环境。创建用户数据和C函数共享创建C函数的环境。非嵌套Lua函数（通过创建loadfile，loadstring或load）创建共享创建线程的环境。创建嵌套的Lua函数，共享创建Lua函数的环境。


与用户数据相关的环境对Lua没有意义。程序员将表与用户数据相关联只是一个便利功能。


与线程相关的环境称为 全局环境。它们被用作线程创建的线程和非嵌套Lua函数的默认环境，并且可以通过C代码直接访问（参见§3.3）。


与C函数关联的环境可以通过C代码直接访问（参见§3.3）。它被用作该函数创建的其他C函数和userdata的默认环境。


与Lua函数相关的环境被用来解析函数中所有对全局变量的访问（见§2.3）。它们被用作由函数创建的嵌套Lua函数的默认环境。


您可以通过调用来更改Lua函数的环境或正在运行的线程setfenv。您可以通过调用来获取Lua函数的环境或正在运行的线程getfenv。要操纵其他对象（用户数据，C函数，其他线程）的环境，您必须使用C API。


2.10 - 垃圾收集
Lua执行自动内存管理。这意味着您不必担心为新对象分配内存，也不必在不再需要对象时释放内存。Lua通过运行一个垃圾收集器来自动管理内存，以收集所有死对象 （即，不能从Lua访问的对象）。Lua使用的所有内存都受自动管理：表，用户数据，函数，线程，字符串等


Lua实现了一个递增的标记和扫描收集器。它使用两个数字来控制其垃圾收集周期：垃圾收集器暂停和垃圾收集器步骤乘数。都使用百分比作为单位（所以值为100表示​​内部值为1）。


垃圾收集器暂停控制收集器在开始新的循环之前等待的时间。较大的值使收集器不那么积极。小于100的值意味着收集器不会等待开始新的循环。值为200意味着收集器在开始新的循环之前等待使用的总内存翻倍。


步骤乘数控制收集器相对于内存分配的相对速度。较大的值使收集器更具侵略性，但也会增加每个增量步骤的大小。小于100的值会使收集器太慢，并可能导致收集器永远不会完成一个循环。缺省值200表示收集器以内存分配速度的“两倍”运行。


您可以通过lua_gc在C或collectgarbageLua中调用来更改这些数字。有了这些功能，您还可以直接控制收集器（例如，停止并重新启动它）。


2.10.1 - 垃圾收集Metamethods
使用C API，您可以为userdata设置垃圾收集器元方法（请参阅第2.8节）。这些metamethods也被称为finalizer。终结器允许您协调Lua的垃圾回收与外部资源管理（如关闭文件，网络或数据库连接，或释放自己的内存）。


垃圾__gc收集器不会立即收集其元数据中具有字段的垃圾用户数据。相反，Lua把它们放在一个列表中。收集之后，Lua为该列表中的每个用户数据执行以下功能的等效操作：


     函数gc_event（udata）
       本地h = metatable（udata）.__ gc
       如果h然后
         H（UDATA）
       结束
     结束
在每个垃圾收集周期结束时，用户数据的终结器 按照其创建的相反顺序被调用，在那个循环中收集。也就是说，要调用的第一个终结器是与在程序中最后创建的用户数据关联的终结器。用户数据本身只在下一个垃圾收集循环中被释放。


2.10.2 - 弱表
一个弱表是一个表，它的元素是 弱引用。垃圾收集器忽略弱引用。换句话说，如果一个对象的唯一引用是弱引用，那么垃圾收集器将收集这个对象。


弱表可以有弱键，弱值或两者。具有弱密钥的表允许收集其密钥，但是阻止收集其值。具有弱键和弱值的表允许收集键和值。在任何情况下，如果键或值被收集，整个对将从表格中移除。桌子的弱点是由__mode它的metatable字段控制的 。如果该__mode字段是包含字符“ k” 的字符串，则表中的键很弱。如果__mode包含“ v'，表中的值很弱。


在使用表格作为元数据之后，您不应该更改其__mode字段的值。否则，这个metatable控制的表的弱行为是不确定的。


2.11 - 协程
Lua支持协程，也称为协作多线程。Lua中的协程表示一个独立的执行线程。然而，与多线程系统中的线程不同，协程只通过显式调用yield函数来暂停执行。


通过调用创建一个协程coroutine.create。它唯一的参数是一个函数，它是协程的主要功能。该create函数只创建一个新的协程并返回一个句柄（一个线程类型的对象）。它不启动协程执行。


当你第一次调用的时候coroutine.resume，作为第一个参数传递一个返回的线程coroutine.create，协程开始执行它的主函数的第一行。传递给额外的参数传递给coroutine.resume协同主函数。协程开始运行后，它会运行，直到它终止或收益。


协程可以通过两种方式来终止它的执行：通常，当主函数返回（显式或隐式地，在最后一个指令之后）; 如果出现无保护的错误，则会异常。在第一种情况下，coroutine.resume返回true，加上协程主函数返回的任何值。如果发生错误，则coroutine.resume返回错误 并附加错误消息。


协程通过调用产生coroutine.yield。当协程产生时，coroutine.resume立即产生相应的返回值，即使产出发生在嵌套函数调用（即不在main函数中，而是在由main函数直接或间接调用的函数中）。在yield的情况下，coroutine.resume还返回true，加上传递给的任何值coroutine.yield。下一次你恢复同样的协程时，它会继续执行它的执行，并且调用coroutine.yield返回传给它的额外参数coroutine.resume。


就像coroutine.create这个coroutine.wrap函数也创建一个协程，但是它不是返回协程本身，而是返回一个被调用的函数，它恢复协程。任何传递给这个函数的参数都是作为额外的参数coroutine.resume。 coroutine.wrap返回coroutine.resume除第一个（布尔错误代码）以外返回的所有值。不像coroutine.resume， coroutine.wrap不抓错误; 任何错误都传播给调用者。


举个例子，考虑下面的代码：


     函数foo（a）
       打印（“foo”，a）
       返回coroutine.yield（2 * a）
     结束
     
     co = coroutine.create（function（a，b）
           印刷品（“共同体”，a，b）
           本地r = foo（a + 1）
           印刷品（“co-body”，r）
           本地r，s = coroutine.yield（a + b，ab）
           打印（“co-body”，r，s）
           返回b，“结束”
     结束）
            
     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”））
当你运行它时，它会产生以下输出：


     共同体110
     foo 2
     
     主要真实4
     合作机构
     主要真实11 -9
     共同体xy
     主要真正的10个结局
     主要的错误是无法恢复死的协程
3 - 应用程序接口
本节描述Lua的C API，即主机程序可用于与Lua进行通信的一组C函数。所有的API函数以及相关的类型和常量都在头文件中声明lua.h。


即使我们使用术语“功能”，也可以将API中的任何工具作为宏来提供。所有这些宏只使用它们的每个参数一次（除了第一个参数，它总是一个Lua状态），所以不会产生任何隐藏的副作用。


和大多数C库一样，Lua API函数也不检查参数的有效性或一致性。不过，你可以通过luai_apicheck在文件中编译具有适当宏定义的Lua来改变这种行为luaconf.h。


3.1 - 堆栈
Lua使用一个虚拟堆栈来向C和C传递值。这个堆栈中的每个元素表示一个Lua值（零，数字，字符串等）。


每当Lua调用C时，被调用的函数都会得到一个新的堆栈，它独立于之前的堆栈以及仍然处于活动状态的C函数堆栈。这个堆栈最初包含了C函数的所有参数，它是C函数将其结果返回给调用者的地方（请参阅参考资料lua_CFunction）。


为了方便起见，API中的大多数查询操作都不遵循严格的堆栈规则。相反，他们可以通过使用索引来引用堆栈中的任何元素：正数索引表示绝对堆栈位置（从1开始）。负索引表示相对于堆栈顶部的偏移量。更具体地说，如果堆栈有n个元素，那么索引1表示第一个元素（即，先被压入堆栈的元素），而索引  n表示最后一个元素; index -1还表示最后一个元素（即顶部的元素）和index -n表示第一个元素。我们说一个索引是有效的 如果它位于1和栈顶之间（即if 1 ≤ abs(index) ≤ top）。


3.2 - 堆栈大小
当您与Lua API交互时，您有责任确保一致性。特别是 你负责控制堆栈溢出。您可以使用该函数lua_checkstack 来增加堆栈大小。


每当Lua调用C时，它确保至少LUA_MINSTACK堆栈位置可用。 LUA_MINSTACK被定义为20，所以通常你不必担心堆栈空间，除非你的代码有循环把元素推入堆栈。


大多数查询函数接受可用堆栈空间内的任何值作为索引，即索引达到您已设置的最大堆栈大小lua_checkstack。这种指数被称为可接受的指数。更正式地说，我们定义一个可以接受的指标 如下：


     （index <0 && abs（index）<= top）||
     （index> 0 && index <= stackspace）
请注意，0从来不是一个可接受的索引。


3.3 - 伪指数
除非另有说明，否则任何接受有效索引的函数也可以用伪索引来调用，这些 伪索引代表一些可以被C代码访问但不在堆栈中的Lua值。伪索引用于访问线程环境，函数环境，注册表以及C函数的upvalues（参见§3.4）。


线程环境（全局变量所在的地方）始终处于伪索引处LUA_GLOBALSINDEX。运行C函数的环境总是处于伪索引LUA_ENVIRONINDEX。


要访问和更改全局变量的值，可以在环境表上使用常规表操作。例如，要访问全局变量的值，请执行


     lua_getfield（L，LUA_GLOBALSINDEX，varname）;
3.4 - C关闭
当创建C函数时，可以将一些值与它关联，从而创建一个C闭包 ; 这些值被称为upvalues，只要被调用，函数就可以访问这些值（参见参考资料lua_pushcclosure）。


每当一个C函数被调用，它的upvalues都位于特定的伪索引。这些伪指数是由宏产生的 lua_upvalueindex。与函数关联的第一个值在位置 lua_upvalueindex(1)，依此类推。任何访问，其中n大于当前函数的upvalues（但不超过256），产生一个可接受的（但无效的）索引。 lua_upvalueindex(n)


3.5 - 注册表
Lua提供了一个注册表，一个预定义的表，可以被任何C代码用来存储它需要存储的任何Lua值。该表总是位于伪索引处 LUA_REGISTRYINDEX。任何C库都可以将数据存储到这个表中，但是应该注意选择不同于其他库的键，以避免冲突。通常，你应该使用一个包含你的库名的字符串，或者在你的代码中使用一个C对象地址的轻型用户数据。


注册表中的整数键由引用机制使用，由辅助库实现，因此不应用于其他目的。


3.6 - C中的错误处理
在内部，Lua使用C longjmp工具来处理错误。（如果您使用C ++，也可以选择使用异常;请参阅文件luaconf.h。）当Lua面临任何错误（例如内存分配错误，类型错误，语法错误和运行时错误）时，会引发错误; 那就是跳远了。一个受保护的环境使用setjmp 设置一个恢复点; 任何错误都会跳转到最近的活动恢复点。


API中的大多数函数都会引发错误，例如由于内存分配错误。每个函数的文档都指出它是否可以抛出错误。


在C函数中，你可以通过调用来引发错误lua_error。


3.7 - 函数和类型
这里我们按字母顺序列出C API中的所有函数和类型。每个函数都有一个像这样的指示符： [-o，+ p，x ]


第一个字段o是函数从堆栈中弹出多少个元素。第二个字段p是函数将多少元素压入堆栈。（任何函数在弹出其参数后总是推送其结果。）表单中的字段x|y意味着函数可以推送（或弹出） x或y元素，这取决于情况; 询问标记“ ?”意味着我们不能通过仅查看其参数（例如，它们可能取决于栈上的内容）来知道函数弹出/推动多少个元素。第三个字段x告诉函数是否可以抛出错误：“ -'表示函数不会抛出任何错误; ' m'表示由于内存不足，该函数可能会引发错误; “e“意味着函数可能会抛出其他类型的错误; “ v”意味着函数可能会故意抛出错误。


lua_Alloc
typedef void *（* lua_Alloc）（void * ud，
                             void * ptr，
                             size_t osize，
                             size_t nsize）;
Lua状态使用的内存分配函数的类型。分配器函数必须提供类似的功能realloc，但不完全一样。它的论点是 ud，一个不透明的指针传递给lua_newstate; ptr，指向被分配/重新分配/释放的块的指针; osize，块的原始大小; nsize，块的新大小。 ptr是NULL当且仅当osize是零。当nsize为零时，分配器必须返回NULL; 如果osize不是零，则应该释放指向的块ptr。当nsize不为零时，分配器返回NULL 当且仅当它不能填充请求。当nsize不为零并且osize为零时，分配器应该表现得像malloc。当nsize和osize不是零时，分配器的行为就像realloc。Lua假设分配器从来没有失败的时候 osize >= nsize。


这是分配器函数的简单实现。它被用于辅助图书馆luaL_newstate。


     static void * l_alloc（void * ud，void * ptr，size_t osize，
                                                size_t nsize）{
       （空隙）UD; （空隙）osize; /* 不曾用过 */
       if（nsize == 0）{
         免费（PTR）;
         返回NULL;
       }
       其他
         返回realloc（ptr，nsize）;
     }
这个代码假定free(NULL)没有效果，这 realloc(NULL, size)相当于malloc(size)。ANSI C确保两种行为。


lua_atpanic
[-0，+0，- ]
lua_CFunction lua_atpanic（lua_State * L，lua_CFunction panicf）;
设置一个新的恐慌功能，并返回旧的。


如果在任何受保护的环境之外发生错误，Lua会调用一个恐慌函数 ，然后调用exit(EXIT_FAILURE)，从而退出主机应用程序。你的恐慌功能可以通过永不返回来避免这种退出（例如，做一个长时间的跳跃）。


恐慌函数可以访问堆栈顶部的错误消息。


lua_call
[ - （nargs + 1），+ nresults，e ]
void lua_call（lua_State * L，int nargs，int nresults）;
调用一个函数。


要调用函数，您必须使用以下协议：首先，要调用的函数被压入堆栈; 那么，这个函数的参数就会被直接推入; 也就是说，第一个参数是先推。最后你打电话lua_call; nargs是您推入堆栈的参数的数量。当函数被调用时，所有的参数和函数值从堆栈弹出。当函数返回时，函数结果被压入堆栈。结果数被调整到nresults，除非nresults是LUA_MULTRET。在这种情况下，所有功能的结果被推送。Lua注意返回值适合堆栈空间。函数结果以直接的顺序被压入堆栈（第一个结果是先被压入的），这样在调用之后，最后的结果在堆栈的顶端。


被调用函数中的任何错误都向上传播（用a longjmp）。


以下示例显示主机程序如何执行与此Lua代码等效的操作：


     a = f（“how”，tx，14）
这里是在C：


     lua_getfield（L，LUA_GLOBALSINDEX，“f”）; / *函数被调用* /
     lua_pushstring（L，“how”）; / *第一个参数* /
     lua_getfield（L，LUA_GLOBALSINDEX，“t”）; / *表被索引* /
     lua_getfield（L，-1，“x”）; / * tx（2nd arg）的结果* /
     lua_remove（L，-2）; / *从堆栈中删除't'* /
     lua_pushinteger（L，14）; / *第三个参数* /
     lua_call（L，3，1）; / *用3个参数和1个结果调用'f'* /
     lua_setfield（L，LUA_GLOBALSINDEX，“a”）; / *设置全局“a”* /
请注意，上面的代码是“平衡的”：在最后，堆栈回到原来的配置。这被认为是很好的编程实践。


lua_CFunction
typedef int（* lua_CFunction）（lua_State * L）;
输入C函数。


为了和Lua进行正确的通信，一个C函数必须使用下面的协议，它定义了传递参数和结果的方式：一个C函数直接从栈中接收Lua的参数（第一个参数先被压入）。所以，当函数启动时， lua_gettop(L)返回函数收到的参数个数。第一个参数（如果有）位于索引1，最后一个参数位于索引处lua_gettop(L)。为了将值返回给Lua，一个C函数只是将它们按顺序推入堆栈（第一个结果是先被压入的），然后返回结果的数目。结果下方的任何其他值将被Lua正确丢弃。像Lua函数一样，Lua调用的C函数也可以返回许多结果。


作为一个例子，下面的函数接收可变数目的参数并返回它们的平均值和和：


     static int foo（lua_State * L）{
       int n = lua_gettop（L）; / *参数个数* /
       lua_Number sum = 0;
       int i;
       for（i = 1; i <= n; i ++）{
         如果（！lua_isnumber（L，i））{
           lua_pushstring（L，“不正确的参数”）;
           lua_error（L）;
         }
         sum + = lua_tonumber（L，i）;
       }
       lua_pushnumber（L，sum / n）; / *第一个结果* /
       lua_pushnumber（L，sum）; / *第二个结果* /
       返回2; / *结果数量* /
     }
lua_checkstack
[-0，+ 0，m ]
int lua_checkstack（lua_State * L，int extra）;
确保extra堆栈中至少有空闲的堆栈槽。如果无法将堆栈增长到该大小，则返回false。这个函数永远不会缩小堆栈; 如果堆栈已经大于新的大小，则保持不变。


lua_close
[-0，+0，- ]
void lua_close（lua_State * L）;
销毁给定Lua状态下的所有对象（调用相应的垃圾收集元方法，如果有的话）并释放此状态使用的所有动态内存。在多个平台上，您可能不需要调用此函数，因为在主机程序结束时，所有资源都会自然释放。另一方面，长时间运行的程序（如守护进程或Web服务器）可能需要在不需要时立即释放状态，以避免过长。


lua_concat
[-n，+1，e ]
void lua_concat（lua_State * L，int n）;
连接n堆栈顶部的值，弹出它们，并将结果保留在顶部。如果n 是1，结果是堆栈中的单个值（也就是说，该函数什么也不做）; 如果n是0，结果是空字符串。按照Lua的通常语义进行连接（见§2.5.4）。


lua_cpcall
[-0，+（0 | 1），- ]
int lua_cpcall（lua_State * L，lua_CFunction func，void * ud）;
func在保护模式下 调用C函数。 func从它的堆栈中只有一个元素开始，一个轻的userdata包含ud。如果发生错误，则 lua_cpcall返回与lua_pcall堆栈顶部的错误对象相同的错误代码; 否则，它将返回零，并且不会更改堆栈。所有返回的值func都被丢弃。


lua_createtable
[-0，+1，m ]
void lua_createtable（lua_State * L，int narr，int nrec）;
创建一个新的空表并将其压入堆栈。新表具有为narr数组元素和nrec非数组元素预先分配的空间。当您确切知道表中有多少元素时，此预分配很有用。否则，您可以使用该功能lua_newtable。


lua_dump
[-0，+ 0，m ]
int lua_dump（lua_State * L，lua_Writer writer，void * data）;
将函数转储为二进制块。在堆栈的顶部接收一个Lua函数，并产生一个二进制块，如果再次加载，将产生一个相当于被转储的函数。由于它产生的部分块， lua_dump调用功能writer（见lua_Writer）与给定data 写他们。


返回的值是上次调用写入程序返回的错误代码; 0表示没有错误。


这个函数不会从堆栈中弹出Lua函数。


lua_equal
[-0，+ 0，e ]
int lua_equal（lua_State * L，int index1，int index2）;
返回1，如果在可接受的索引的两个值index1和 index2是相等的，继的Lua的语义==操作者（即，可以调用元方法）。否则返回0.如果任何索引无效，则返回0。


lua_error
[-1，+ 0，v ]
int lua_error（lua_State * L）;
生成一个Lua错误。错误消息（实际上可以是任何类型的Lua值）必须位于堆栈顶部。这个功能会跳远，因此永远不会返回。（见luaL_error）。


lua_gc
[-0，+ 0，e ]
int lua_gc（lua_State * L，int what，int data）;
控制垃圾收集器。


该功能根据参数的值执行多个任务what：


LUA_GCSTOP： 停止垃圾收集器。
LUA_GCRESTART： 重新启动垃圾收集器。
LUA_GCCOLLECT： 执行完整的垃圾回收循环。
LUA_GCCOUNT： 返回Lua使用的当前内存量（以KB为单位）。
LUA_GCCOUNTB： 返回由Lua使用的内存的当前字节数除以1024的余数。
LUA_GCSTEP： 执行垃圾收集的增量步骤。步长“大小”是由data 一个非特定的方式控制（更大的数值意味着更多的步骤）。如果你想控制步长，你必须通过实验调整值data。如果该步骤完成垃圾收集循环，则函数返回1。
LUA_GCSETPAUSE： 设置data为收集器暂停的新值（见§2.10）。该函数返回以前的暂停值。
LUA_GCSETSTEPMUL： 设置data为收集器步进倍数的新值（见§2.10）。该函数返回步骤乘数的前一个值。
lua_getallocf
[-0，+0，- ]
lua_Alloc lua_getallocf（lua_State * L，void ** ud）;
返回给定状态的内存分配函数。如果ud不是NULL，Lua存储在*ud传递给它的不透明指针中lua_newstate。


lua_getfenv
[-0，+1，- ]
void lua_getfenv（lua_State * L，int index）;
将指定索引处的值的环境表压入堆栈。


lua_getfield
[-0，+1，e ]
void lua_getfield（lua_State * L，int index，const char * k）;
推入堆栈的值t[k]，其中t是在给定的有效索引值。和Lua一样，这个函数可能触发一个“索引”事件的元方法（见§2.8）。


lua_getglobal
[-0，+1，e ]
void lua_getglobal（lua_State * L，const char * name）;
推入堆栈的全球价值name。它被定义为一个宏：


     #define lua_getglobal（L，s）lua_getfield（L，LUA_GLOBALSINDEX，s）
lua_getmetatable
[-0，+（0 | 1），- ]
int lua_getmetatable（lua_State * L，int index）;
在给定的可接受索引处将值的元表达式推入堆栈。如果索引无效，或者如果该值没有metatable，则该函数返回0，并且不在堆栈上执行任何操作。


lua_gettable
[-1，+ 1，e ]
void lua_gettable（lua_State * L，int index）;
将值推入堆栈t[k]，其中t是给定有效索引k处的值，并且是堆栈顶部的值。


这个函数从堆栈中弹出键（把结果值放在原来的位置）。和Lua一样，这个函数可能触发一个“索引”事件的元方法（见§2.8）。


lua_gettop
[-0，+0，- ]
int lua_gettop（lua_State * L）;
返回堆栈中顶层元素的索引。因为索引从1开始，所以这个结果等于堆栈中元素的数量（所以0表示一个空的堆栈）。


lua_insert
[-1，+ 1，- ]
void lua_insert（lua_State * L，int index）;
将顶层元素移动到给定的有效索引中，向上移动此索引上方的元素以打开空间。不能用伪索引调用，因为伪索引不是实际的堆栈位置。


lua_Integer
typedef ptrdiff_t lua_Integer;
Lua API用来表示整数值的类型。


默认情况下，它是一个ptrdiff_t，这通常是机器处理“舒适”的最大签名整数类型。


lua_isboolean
[-0，+0，- ]
int lua_isboolean（lua_State * L，int index）;
如果给定可接受索引处的值的类型为布尔值，则返回1，否则返回0。


lua_iscfunction
[-0，+0，- ]
int lua_iscfunction（lua_State * L，int index）;
如果给定可接受索引处的值是C函数，则返回1，否则返回0。


lua_isfunction
[-0，+0，- ]
int lua_isfunction（lua_State * L，int index）;
如果给定可接受索引处的值是一个函数（C或Lua），则返回1，否则返回0。


lua_islightuserdata
[-0，+0，- ]
int lua_islightuserdata（lua_State * L，int index）;
如果给定可接受索引处的值是轻量用户数据，则返回1;否则返回0。


lua_isnil
[-0，+0，- ]
int lua_isnil（lua_State * L，int index）;
如果给定可接受索引处的值为零，则返回1;否则返回0。


lua_isnone
[-0，+0，- ]
int lua_isnone（lua_State * L，int index）;
如果给定的可接受索引无效（即引用当前栈之外的元素），则返回1，否则返回0。


lua_isnoneornil
[-0，+0，- ]
int lua_isnoneornil（lua_State * L，int index）;
如果给定的可接受索引无效（即，它引用了当前堆栈外的元素），或者此索引处的值为零，则返回1;否则返回0。


lua_isnumber
[-0，+0，- ]
int lua_isnumber（lua_State * L，int index）;
如果给定可接受索引处的值是可转换为数字的数字或字符串，则返回1，否则返回0。


lua_isstring
[-0，+0，- ]
int lua_isstring（lua_State * L，int index）;
如果给定可接受索引处的值是字符串或数字（总是可以转换为字符串），则返回1，否则返回0。


lua_istable
[-0，+0，- ]
int lua_istable（lua_State * L，int index）;
如果给定可接受索引处的值是表，则返回1，否则返回0。


lua_isthread
[-0，+0，- ]
int lua_isthread（lua_State * L，int index）;
如果给定可接受索引处的值是一个线程，则返回1，否则返回0。


lua_isuserdata
[-0，+0，- ]
int lua_isuserdata（lua_State * L，int index）;
如果给定可接受索引处的值是一个userdata（full或light），则返回1，否则返回0。


lua_lessthan
[-0，+ 0，e ]
int lua_lessthan（lua_State * L，int index1，int index2）;
如果可接受索引index1处的值小于可接受索引处的值（在index2Lua <运算符的语义之后（即可能调用元方法）），则返回1。否则返回0.如果任何索引无效，则返回0。


lua_load
[-0，+1，- ]
int lua_load（lua_State * L，
              lua_Reader阅读器，
              void *数据，
              const char * chunkname）;
加载一个Lua块。如果没有错误， lua_load则将编译的块作为Lua函数推入堆栈顶部。否则，它会推送一条错误消息。返回值lua_load是：


0：没有错误;
LUA_ERRSYNTAX： 预编译期间的语法错误;
LUA_ERRMEM： 内存分配错误。
这个函数只加载一个块; 它不运行它。


lua_load自动检测块是文本还是二进制，并相应地加载它（参见程序luac）。


该lua_load函数使用用户提供的reader函数来读取块（请参阅参考资料lua_Reader）。该data参数是传递给阅读器功能的不透明值。


该chunkname参数给出一个名称组块，其用于错误消息和在调试信息（见§3.8）。


lua_newstate
[-0，+0，- ]
lua_State * lua_newstate（lua_Alloc f，void * ud）;
创建一个新的独立状态。返回NULL如果不能创建状态（由于内存不足）。参数f是分配器函数; Lua通过这个函数为这个状态做所有的内存分配。第二个参数ud是一个不透明的指针，Lua只是在每个调用中传递给分配器。


lua_newtable
[-0，+1，m ]
void lua_newtable（lua_State * L）;
创建一个新的空表并将其压入堆栈。这相当于lua_createtable(L, 0, 0)。


lua_newthread
[-0，+1，m ]
lua_State * lua_newthread（lua_State * L）;
创建一个新的线程，将其推入栈中，并返回一个指向lua_State这个新线程的指针。该函数返回的新状态与原始状态共享所有全局对象（如表），但是具有独立的执行堆栈。


没有显式的函数来关闭或销毁一个线程。线程是垃圾收集的，就像任何Lua对象一样。


lua_newuserdata
[-0，+1，m ]
void * lua_newuserdata（lua_State * L，size_t size）;
这个函数分配一个新的给定大小的内存块，将一个新的完整用户数据和块地址一起压入堆栈，然后返回这个地址。


用户数据表示Lua中的C值。甲全用户数据表示的存储器的块。它是一个对象（如表）：您必须创建它，它可以有自己的metatable，并且可以检测到它正在被收集的时间。一个完整的用户数据只与自身相等（在原始的等式下）。


当Lua用gcmetamethod 收集完整的用户数据时，Lua调用metamethod并将用户数据标记为已完成。当这个用户数据被再次收集，然后Lua释放相应的内存。


lua_next
[-1，+（2 | 0），e ]
int lua_next（lua_State * L，int index）;
从堆栈中弹出一个键，并在给定索引（给定键之后的“下一个”对）处从表中推送键值对。如果表中没有更多的元素，则lua_next返回0（并不推送任何东西）。


典型的遍历看起来像这样：


     / *表位于索引't'的堆栈中* /
     lua_pushnil（L）; / *第一个键* /
     而（lua_next（L，t）！= 0）{
       / *使用“键”（在索引-2）和“值”（在索引-1）* /
       printf（“％s  - ％s \ n”，
              lua_typename（L，lua_type（L，-2）），
              lua_typename（L，lua_type（L，-1）））;
       / *删除“值”; 为下一次迭代保持“关键”* /
       lua_pop（L，1）;
     }
遍历表时，不要lua_tolstring直接调用一个键，除非您知道键实际上是一个字符串。回想一下，改变 给定索引的值; 这混淆了下一个电话。 lua_tolstring lua_next


lua_Number
typedef double lua_Number;
在Lua中的数字的类型。默认情况下，它是双倍的，但可以在中更改luaconf.h。


通过配置文件，您可以将Lua更改为使用其他类型的数字（例如，float或long）。


lua_objlen
[-0，+0，- ]
size_t lua_objlen（lua_State * L，int index）;
返回给定可接受索引处的值的“长度”：对于字符串，这是字符串长度; 对于表，这是长度运算符（' #'）的结果; 对于userdata，这是为用户数据分配的内存块的大小; 对于其他值，它是0。


lua_pcall
[ - （nargs + 1），+（结果| 1），- ]
int lua_pcall（lua_State * L，int nargs，int nresults，int errfunc）;
在保护模式下调用一个函数。


双方nargs并nresults具有相同的含义在lua_call。如果在通话过程中没有错误， lua_pcall表现完全一样lua_call。但是，如果有任何错误，则 lua_pcall捕获它，在堆栈上推送一个值（错误消息），并返回一个错误代码。像lua_call， lua_pcall总是从堆栈中删除函数和它的参数。


如果errfunc是0，那么在堆栈上返回的错误消息就是原来的错误消息。否则，errfunc是一个错误处理函数的堆栈索引 。（在当前的实现中，这个索引不能是一个伪索引。）在运行时错误的情况下，这个函数将会被调用，并且返回的值是堆栈中的返回值lua_pcall。


通常，错误处理函数用于向错误消息添加更多调试信息，例如堆栈回溯。这样的信息在返回后不能被收集lua_pcall，因为到那时栈已经被解开。


该lua_pcall函数在成功的情况下返回0或以下错误代码之一（在中定义lua.h）：


LUA_ERRRUN： 运行时错误。
LUA_ERRMEM： 内存分配错误。对于这样的错误，Lua不会调用错误处理函数。
LUA_ERRERR： 运行错误处理函数时出错。
lua_pop
[-n，+0，- ]
void lua_pop（lua_State * L，int n）;
n从堆栈中 弹出元素。


lua_pushboolean
[-0，+1，- ]
void lua_pushboolean（lua_State * L，int b）;
将一个带有值的布尔值b推入堆栈。


lua_pushcclosure
[-n，+1，m ]
void lua_pushcclosure（lua_State * L，lua_CFunction fn，int n）;
将新的C闭包推入堆栈。


当创建C函数时，可以将一些值与它关联起来，从而创建一个C闭包（参见§3.4）。这些值只要被调用就可以被该函数访问。要将值与C函数相关联，首先应将这些值压入堆栈（当有多个值时，第一个值先被推入）。然后lua_pushcclosure 调用来创建C函数并将其推送到堆栈上，参数n告诉函数应该与多少个值相关联。 lua_pushcclosure也从堆栈中弹出这些值。


最大值n是255。


lua_pushcfunction
[-0，+1，m ]
void lua_pushcfunction（lua_State * L，lua_CFunction f）;
将C函数推入堆栈。这个函数接收到一个指向C函数的指针，并将一个Lua类型的值（function当被调用时）调用相应的C函数。


任何要在Lua中注册的函数都必须遵循正确的协议来接收其参数并返回结果（请参阅参考资料lua_CFunction）。


lua_pushcfunction 被定义为一个宏：


     #define lua_pushcfunction（L，f）lua_pushcclosure（L，f，0）
lua_pushfstring
[-0，+1，m ]
const char * lua_pushfstring（lua_State * L，const char * fmt，...）;
将一个格式化的字符串推入堆栈，并返回一个指向此字符串的指针。它与C函数类似sprintf，但有一些重要的区别：


您不必为结果分配空间：结果是一个Lua字符串，而Lua负责内存分配（并通过垃圾回收解除分配）。
转换说明符是相当有限的。没有标志，宽度或精度。转换说明符只能是' %%'（%在字符串中插入一个'' '，' %s'（插入零终止的字符串，没有大小限制），' %f'（插入一个lua_Number），' %p'（插入一个指针为十六进制数字），' %d'（插入一个int）和' %c'（插入int一个字符）。
lua_pushinteger
[-0，+1，- ]
void lua_pushinteger（lua_State * L，lua_Integer n）;
将有数值的数字n推入堆栈。


lua_pushlightuserdata
[-0，+1，- ]
void lua_pushlightuserdata（lua_State * L，void * p）;
将轻量级用户数据推入堆栈。


用户数据表示Lua中的C值。甲光用户数据表示的指针。它是一个值（像一个数字）：你不创建它，它没有单独的metatable，它不被收集（因为它从来没有创建）。轻的用户数据等于具有相同C地址的“任何”轻用户数据。


lua_pushliteral
[-0，+1，m ]
void lua_pushliteral（lua_State * L，const char * s）;
这个宏相当于lua_pushlstring，但只有当s是一个文字字符串时才能使用。在这些情况下，它会自动提供字符串长度。


lua_pushlstring
[-0，+1，m ]
void lua_pushlstring（lua_State * L，const char * s，size_t len）;
将s尺寸指向的字符串len 推入堆栈。Lua使得（或重新使用）给定字符串的内部副本，所以s在函数返回后，可以立即释放或重用内存。该字符串可以包含嵌入的零。


lua_pushnil
[-0，+1，- ]
void lua_pushnil（lua_State * L）;
将一个零值推入堆栈。


lua_pushnumber
[-0，+1，- ]
void lua_pushnumber（lua_State * L，lua_Number n）;
将有数值的数字n推入堆栈。


lua_pushstring
[-0，+1，m ]
void lua_pushstring（lua_State * L，const char * s）;
将指向的零终止字符串s 推入堆栈。Lua使得（或重新使用）给定字符串的内部副本，所以s在函数返回后，可以立即释放或重用内存。该字符串不能包含嵌入的零; 假定结束于第一个零。


lua_pushthread
[-0，+1，- ]
int lua_pushthread（lua_State * L）;
将代表的线程L推入堆栈。如果此线程是其状态的主线程，则返回1。


lua_pushvalue
[-0，+1，- ]
void lua_pushvalue（lua_State * L，int index）;
将给定有效索引处元素的副本压入堆栈。


lua_pushvfstring
[-0，+1，m ]
const char * lua_pushvfstring（lua_State * L，
                              const char * fmt，
                              va_list argp）;
相当于lua_pushfstring，除了它接收一个va_list 而不是可变数量的参数。


lua_rawequal
[-0，+0，- ]
int lua_rawequal（lua_State * L，int index1，int index2）;
如果在可接受的索引的两个值，则返回1 index1和 index2是原始地等于（即，不调用元方法）。否则返回0.如果任何索引无效，也返回0。


lua_rawget
[-1，+ 1，- ]
void lua_rawget（lua_State * L，int index）;
类似lua_gettable，但没有原始访问（即没有metamethods）。


lua_rawgeti
[-0，+1，- ]
void lua_rawgeti（lua_State * L，int index，int n）;
推入堆栈的值t[n]，其中t是在给定的有效索引值。访问是生的; 也就是说，它不会调用metamethods。


lua_rawset
[-2，+ 0，m ]
void lua_rawset（lua_State * L，int index）;
类似lua_settable，但做了一个原始的任务（即没有metamethods）。


lua_rawseti
[-1，+ 0，m ]
void lua_rawseti（lua_State * L，int index，int n）;
是否相当于t[n] = v，其中t是在给定的有效索引的价值和v位于堆栈的顶部的值。


这个函数从堆栈中弹出值。作业是生的; 也就是说，它不会调用metamethods。


lua_Reader
typedef const char *（* lua_Reader）（lua_State * L，
                                    void *数据，
                                    size_t * size）;
阅读器功能使用lua_load。每次它需要另一块， lua_load调用读者，传递data参数。读者必须返回一个指向一块内存块的指针，并设置size为块大小。该块必须存在，直到读取器功能再次被调用。为了表示块的结束，阅读器必须返回NULL或设置size为零。阅读器功能可以返回大于零的任何尺寸的部分。


lua_register
[-0，+ 0，e ]
void lua_register（lua_State * L，
                   const char * name，
                   lua_CFunction f）;
将C函数设置f为全局的新值name。它被定义为一个宏：


     #define lua_register（L，n，f）\
            （lua_pushcfunction（L，f），lua_setglobal（L，n））
lua_remove
[-1，+ 0，- ]
void lua_remove（lua_State * L，int index）;
删除给定有效索引处的元素，向下移动此索引上方的元素以填补空缺。不能用伪索引调用，因为伪索引不是实际的堆栈位置。


lua_replace
[-1，+ 0，- ]
void lua_replace（lua_State * L，int index）;
将顶层元素移动到给定位置（并弹出），而不移动任何元素（因此替换给定位置的值）。


lua_resume
[ - ？，+ ?, - ]
int lua_resume（lua_State * L，int narg）;
在给定的线程中启动并恢复一个协程。


要开始一个协程，你首先创建一个新的线程（见lua_newthread）; 然后你把它的主函数加上任何参数推入到它的堆栈中; 那么你打电话lua_resume，narg作为参数的数量。这个调用在协程暂停或结束执行时返回。当它返回时，堆栈包含所有传递给的值lua_yield，或者由body函数返回的所有值。 如果协程结果为0，则lua_resume返回LUA_YIELD0;如果协程没有错误，则返回 0;如果有错误，则返回错误代码（请参阅参考资料lua_pcall）。如果发生错误，堆栈不会解开，所以您可以使用调试API覆盖它。错误消息位于堆栈的顶部。要重新启动一个协程，你只把它作为结果传递给它的栈yield，然后调用它lua_resume。


lua_setallocf
[-0，+0，- ]
void lua_setallocf（lua_State * L，lua_Alloc f，void * ud）;
f 用用户数据 改变给定状态的分配器功能ud。


lua_setfenv
[-1，+ 0，- ]
int lua_setfenv（lua_State * L，int index）;
从堆栈中弹出一个表并将其设置为给定索引处的值的新环境。如果给定索引处的值既不是函数也不是线程也不是用户数据，则 lua_setfenv返回0.否则返回1。


lua_setfield
[-1，+ 0，e ]
void lua_setfield（lua_State * L，int index，const char * k）;
是否等效t[k] = v，这里t是在给定的有效索引的价值和v位于堆栈的顶部的值。


这个函数从堆栈中弹出值。和Lua一样，这个函数可能触发“newindex”事件的元方法（见§2.8）。


lua_setglobal
[-1，+ 0，e ]
void lua_setglobal（lua_State * L，const char * name）;
从堆栈中弹出一个值，并将其设置为全局的新值name。它被定义为一个宏：


     #define lua_setglobal（L，s）lua_setfield（L，LUA_GLOBALSINDEX，s）
lua_setmetatable
[-1，+ 0，- ]
int lua_setmetatable（lua_State * L，int index）;
从堆栈中弹出一个表，并将其设置为给定可接受索引处的值的新元数据。


lua_settable
[-2，+ 0，e ]
void lua_settable（lua_State * L，int index）;
是否等同于t[k] = v，这里t是在给定的有效索引值， v是在堆栈的顶部的值，k略低于前值。


该函数弹出堆栈中的键和值。和Lua一样，这个函数可能触发“newindex”事件的元方法（见§2.8）。


lua_settop
[ - ？，+ ?, - ]
void lua_settop（lua_State * L，int index）;
接受任何可接受的索引或0，并将堆栈顶部设置为该索引。如果新的顶部比旧的顶部大，那么新的元素将被填充为零。如果index是0，那么所有堆栈元素都被删除。


lua_State
typedef struct lua_State lua_State;
Opaque structure that keeps the whole state of a Lua interpreter. The Lua library is fully reentrant: it has no global variables. All information about a state is kept in this structure.


A pointer to this state must be passed as the first argument to every function in the library, except to lua_newstate, which creates a Lua state from scratch.


lua_status
[-0, +0, -]
int lua_status (lua_State *L);
Returns the status of the thread L.


The status can be 0 for a normal thread, an error code if the thread finished its execution with an error, or LUA_YIELD if the thread is suspended.


lua_toboolean
[-0, +0, -]
int lua_toboolean (lua_State *L, int index);
Converts the Lua value at the given acceptable index to a C boolean value (0 or 1). Like all tests in Lua, lua_toboolean returns 1 for any Lua value different from false and nil; otherwise it returns 0. It also returns 0 when called with a non-valid index. (If you want to accept only actual boolean values, use lua_isboolean to test the value's type.)


lua_tocfunction
[-0, +0, -]
lua_CFunction lua_tocfunction (lua_State *L, int index);
Converts a value at the given acceptable index to a C function. That value must be a C function; otherwise, returns NULL.


lua_tointeger
[-0, +0, -]
lua_Integer lua_tointeger (lua_State *L, int index);
Converts the Lua value at the given acceptable index to the signed integral type lua_Integer. The Lua value must be a number or a string convertible to a number (see §2.2.1); otherwise, lua_tointeger returns 0.


If the number is not an integer, it is truncated in some non-specified way.


lua_tolstring
[-0, +0, m]
const char *lua_tolstring (lua_State *L, int index, size_t *len);
Converts the Lua value at the given acceptable index to a C string. If len is not NULL, it also sets *len with the string length. The Lua value must be a string or a number; otherwise, the function returns NULL. If the value is a number, then lua_tolstring also changes the actual value in the stack to a string. (This change confuses lua_next when lua_tolstring is applied to keys during a table traversal.)


lua_tolstring returns a fully aligned pointer to a string inside the Lua state. This string always has a zero ('\0') after its last character (as in C), but can contain other zeros in its body. Because Lua has garbage collection, there is no guarantee that the pointer returned by lua_tolstring will be valid after the corresponding value is removed from the stack.


lua_tonumber
[-0, +0, -]
lua_Number lua_tonumber (lua_State *L, int index);
Converts the Lua value at the given acceptable index to the C type lua_Number (see lua_Number). The Lua value must be a number or a string convertible to a number (see §2.2.1); otherwise, lua_tonumber returns 0.


lua_topointer
[-0, +0, -]
const void *lua_topointer (lua_State *L, int index);
Converts the value at the given acceptable index to a generic C pointer (void*). The value can be a userdata, a table, a thread, or a function; otherwise, lua_topointer returns NULL. Different objects will give different pointers. There is no way to convert the pointer back to its original value.


Typically this function is used only for debug information.


lua_tostring
[-0, +0, m]
const char * lua_tostring（lua_State * L，int index）;
相当于lua_tolstring用len等于NULL。


lua_tothread
[-0，+0，- ]
lua_State * lua_tothread（lua_State * L，int index）;
将给定可接受索引处的值转换为一个Lua线程（表示为lua_State*）。这个值必须是一个线程; 否则，函数返回NULL。


lua_touserdata
[-0，+0，- ]
void * lua_touserdata（lua_State * L，int index）;
如果给定可接受索引处的值是完整的用户数据，则返回其块地址。如果该值是一个轻的用户数据，则返回其指针。否则，返回NULL。


lua_type
[-0，+0，- ]
int lua_type（lua_State * L，int index）;
返回给定可接受索引中的值的类型，或者返回LUA_TNONE非有效索引（即，“空”堆栈位置的索引）的值。返回的类型lua_type是通过在定义的以下常量编码lua.h： LUA_TNIL， LUA_TNUMBER， LUA_TBOOLEAN， LUA_TSTRING， LUA_TTABLE， LUA_TFUNCTION， LUA_TUSERDATA， LUA_TTHREAD，和 LUA_TLIGHTUSERDATA。


lua_typename
[-0，+0，- ]
const char * lua_typename（lua_State * L，int tp）;
返回值所编码的类型的名称，该值tp必须是返回的值之一lua_type。


lua_Writer
typedef int（* lua_Writer）（lua_State * L，
                           const void * p，
                           size_t sz，
                           void * ud）;
作者函数使用的类型lua_dump。每次它产生另一块， lua_dump调用写入器，传递缓冲区写入（p），其大小（sz），和data提供给参数lua_dump。


作者返回一个错误代码：0意味着没有错误; 任何其他值意味着一个错误，并停止lua_dump再次调用作家。


lua_xmove
[ - ？，+ ?, - ]
void lua_xmove（lua_State * from，lua_State * to，int n）;
交换相同全局状态的不同线程之间的值。


该函数n从堆栈中弹出值from，并将其推入堆栈to。


lua_yield
[ - ？，+ ?, - ]
int lua_yield（lua_State * L，int nresults）;
产生一个协程。


这个函数只能作为C函数的返回表达式来调用，如下所示：


     返回lua_yield（L，nresults）;
当C函数lua_yield以这种方式调用时，正在运行的协程暂停执行，并且lua_resume启动该协程的调用返回。参数nresults是作为结果传递给堆栈的值的数量lua_resume。


3.8 - 调试接口
Lua没有内置的调试工具。相反，它通过函数和钩子提供了一个特殊的接口。这个接口允许构造不同类型的调试器，分析器和其他需要解释器“内部信息”的工具。


lua_Debug
typedef struct lua_Debug {
  int事件;
  const char * name; / *（n）* /
  const char * namewhat; / *（n）* /
  const char *什么; / *（S）* /
  const char * source; / *（S）* /
  int currentline; / *（l）* /
  int nups; / *（u）upvalues数目* /
  int linedefined; / *（S）* /
  int lastlinedefined; / *（S）* /
  char short_src [LUA_IDSIZE]; / *（S）* /
  / *私人部分* /
  其他领域 
} lua_Debug;
一种结构，用来承载有关活动功能的不同信息。 lua_getstack只填充这个结构的私有部分，供以后使用。要填写lua_Debug有用的信息的其他领域，请致电lua_getinfo。


lua_Debug具有以下含义 的领域：


source： 如果函数是在一个字符串中定义的，那么source是那个字符串。如果函数是在一个文件中定义的，那么source以“ @”开头，后跟文件名。
short_src：source用于错误消息 的“可打印”版本。
linedefined： 函数定义开始的行号。
lastlinedefined： 函数定义结束的行号。
what："Lua"函数是Lua函数 的字符串， "C"是C函数， "main"是块的主要部分"tail"，还是尾部调用的函数。在后一种情况下，Lua没有关于该功能的其他信息。
currentline： 给定函数正在执行的当前行。当没有行信息可用时， currentline设置为-1。
name： 给定函数的合理名称。因为Lua中的函数是一级值，所以它们没有固定的名称：一些函数可以是多个全局变量的值，而另一些函数可以只存储在一个表字段中。该lua_getinfo函数检查如何调用函数来找到合适的名称。如果找不到名称，则name设置为NULL。
namewhat： 解释这个name领域。的值namewhat可以是 "global"，"local"，"method"， "field"，"upvalue"，或""（空字符串），根据功能如何被调用。（当没有其他选项似乎适用时，Lua使用空字符串。）
nups： 函数的upvalues数量。
lua_gethook
[-0，+0，- ]
lua_Hook lua_gethook（lua_State * L）;
返回当前的挂钩函数。


lua_gethookcount
[-0，+0，- ]
int lua_gethookcount（lua_State * L）;
返回当前挂钩计数。


lua_gethookmask
[-0，+0，- ]
int lua_gethookmask（lua_State * L）;
返回当前的钩子掩码。


lua_getinfo
[ - （0 | 1），+（0 | 1 | 2），m ]
int lua_getinfo（lua_State * L，const char * what，lua_Debug * ar）;
返回有关特定函数或函数调用的信息。


要获得关于函数调用的信息，参数ar必须是一个有效的激活记录，该记录由之前调用lua_getstack或作为参数给定的钩子填充（请参阅参考资料lua_Hook）。


要获得关于某个函数的信息，请将其推入堆栈，并what使用字符“ >” 开始字符串。（在这种情况下， lua_getinfo弹出堆栈顶部的函数。）例如，要知道在哪一行函数f定义，可以写下面的代码：


     lua_Debug ar;
     lua_getfield（L，LUA_GLOBALSINDEX，“f”）; / *获得全局'f'* /
     lua_getinfo（L，“> S”，＆ar）;
     printf（“％d \ n”，ar.linedefined）;
字符串中的每个字符都what 选择ar要填充的结构的一些字段或要在堆栈上压入的值：


' n“：填充在该领域name和namewhat;
' S“： 填补了领域source，short_src， linedefined，lastlinedefined，和what;
' l'：填写字段currentline;
' u'：填写字段nups;
“ f'： 将在给定级别运行的函数压入堆栈;
' L'： 将一个表格索引到函数上有效的行号上。（一个有效的行是一些包含相关代码的行，也就是说，可以放置一个断点的行，无效的行包括空行和注释。
错误时该函数返回0（例如，一个无效的选项what）。


lua_getlocal
[-0，+（0 | 1），- ]
const char * lua_getlocal（lua_State * L，lua_Debug * ar，int n）;
获取有关给定激活记录的局部变量的信息。该参数ar必须是一个有效的激活记录，该记录由前一次调用lua_getstack或作为参数给出的参数填充（请参阅参考资料lua_Hook）。索引n选择要检查的局部变量（1是第一个参数或活动局部变量，依此类推，直到最后一个活动局部变量）。 lua_getlocal将变量的值推入堆栈并返回其名称。


以“( '（左括号）表示内部变量（循环控制变量，临时变量和C函数本地变量）。


NULL如果索引大于活动局部变量的数目，则 返回（并不会执行任何操作）。


lua_getstack
[-0，+0，- ]
int lua_getstack（lua_State * L，int level，lua_Debug * ar）;
获取有关解释器运行时堆栈的信息。


这个函数用 一个给定级别执行的函数lua_Debug的激活记录的标识来填充结构的一部分。等级0是当前运行的功能，而等级n + 1是称为等级n的功能。当没有错误时，lua_getstack返回1; 当用大于堆栈深度的级别调用时，它返回0。


lua_getupvalue
[-0，+（0 | 1），- ]
const char * lua_getupvalue（lua_State * L，int funcindex，int n）;
获取有关结算价值的信息。（对于Lua函数，upvalues是函数使用的外部局部变量，因此包含在闭包中） lua_getupvalue获取nupvalue 的索引，将upvalue的值压入堆栈，并返回其名称。 funcindex指向堆栈中的关闭。（Upvalues没有特定的顺序，因为它们在整个函数中是活跃的，所以它们按照任意的顺序编号）。


NULL当索引大于upvalues的数量时， 返回（并且不推送）。对于C函数，此函数使用空字符串"" 作为所有upvalues的名称。


lua_Hook
typedef void（* lua_Hook）（lua_State * L，lua_Debug * ar）;
键入调试挂钩函数。


Whenever a hook is called, its ar argument has its field event set to the specific event that triggered the hook. Lua identifies these events with the following constants: LUA_HOOKCALL, LUA_HOOKRET, LUA_HOOKTAILRET, LUA_HOOKLINE, and LUA_HOOKCOUNT. Moreover, for line events, the field currentline is also set. To get the value of any other field in ar, the hook must call lua_getinfo. For return events, event can be LUA_HOOKRET, the normal value, or LUA_HOOKTAILRET. In the latter case, Lua is simulating a return from a function that did a tail call; in this case, it is useless to call lua_getinfo.


While Lua is running a hook, it disables other calls to hooks. Therefore, if a hook calls back Lua to execute a function or a chunk, this execution occurs without any calls to hooks.


lua_sethook
[-0, +0, -]
int lua_sethook (lua_State *L, lua_Hook f, int mask, int count);
Sets the debugging hook function.


Argument f is the hook function. mask specifies on which events the hook will be called: it is formed by a bitwise or of the constants LUA_MASKCALL, LUA_MASKRET, LUA_MASKLINE, and LUA_MASKCOUNT. The count argument is only meaningful when the mask includes LUA_MASKCOUNT. For each event, the hook is called as explained below:


The call hook: is called when the interpreter calls a function. The hook is called just after Lua enters the new function, before the function gets its arguments.
The return hook: is called when the interpreter returns from a function. The hook is called just before Lua leaves the function. You have no access to the values to be returned by the function.
The line hook: is called when the interpreter is about to start the execution of a new line of code, or when it jumps back in the code (even to the same line). (This event only happens while Lua is executing a Lua function.)
The count hook: is called after the interpreter executes every count instructions. (This event only happens while Lua is executing a Lua function.)
A hook is disabled by setting mask to zero.


lua_setlocal
[-(0|1), +0, -]
const char *lua_setlocal (lua_State *L, lua_Debug *ar, int n);
Sets the value of a local variable of a given activation record. Parameters ar and n are as in lua_getlocal (see lua_getlocal). lua_setlocal assigns the value at the top of the stack to the variable and returns its name. It also pops the value from the stack.


Returns NULL (and pops nothing) when the index is greater than the number of active local variables.


lua_setupvalue
[-(0|1), +0, -]
const char *lua_setupvalue (lua_State *L, int funcindex, int n);
Sets the value of a closure's upvalue. It assigns the value at the top of the stack to the upvalue and returns its name. It also pops the value from the stack. Parameters funcindex and n are as in the lua_getupvalue (see lua_getupvalue).


Returns NULL (and pops nothing) when the index is greater than the number of upvalues.


4 – The Auxiliary Library
The auxiliary library provides several convenient functions to interface C with Lua. While the basic API provides the primitive functions for all interactions between C and Lua, the auxiliary library provides higher-level functions for some common tasks.


All functions from the auxiliary library are defined in header file lauxlib.h and have a prefix luaL_.


All functions in the auxiliary library are built on top of the basic API, and so they provide nothing that cannot be done with this API.


Several functions in the auxiliary library are used to check C function arguments. Their names are always luaL_check* or luaL_opt*. All of these functions throw an error if the check is not satisfied. Because the error message is formatted for arguments (e.g., "bad argument #1"), you should not use these functions for other stack values.


4.1 – Functions and Types
Here we list all functions and types from the auxiliary library in alphabetical order.


luaL_addchar
[-0, +0, m]
void luaL_addchar (luaL_Buffer *B, char c);
Adds the character c to the buffer B (see luaL_Buffer).


luaL_addlstring
[-0, +0, m]
void luaL_addlstring (luaL_Buffer *B, const char *s, size_t l);
Adds the string pointed to by s with length l to the buffer B (see luaL_Buffer). The string may contain embedded zeros.


luaL_addsize
[-0, +0, m]
void luaL_addsize (luaL_Buffer *B, size_t n);
Adds to the buffer B (see luaL_Buffer) a string of length n previously copied to the buffer area (see luaL_prepbuffer).


luaL_addstring
[-0, +0, m]
void luaL_addstring (luaL_Buffer *B, const char *s);
Adds the zero-terminated string pointed to by s to the buffer B (see luaL_Buffer). The string may not contain embedded zeros.


luaL_addvalue
[-1, +0, m]
void luaL_addvalue (luaL_Buffer *B);
Adds the value at the top of the stack to the buffer B (see luaL_Buffer). Pops the value.


This is the only function on string buffers that can (and must) be called with an extra element on the stack, which is the value to be added to the buffer.


luaL_argcheck
[-0, +0, v]
void luaL_argcheck (lua_State *L,
                    int cond,
                    int narg,
                    const char *extramsg);
Checks whether cond is true. If not, raises an error with the following message, where func is retrieved from the call stack:


     bad argument # to ()
luaL_argerror
[-0, +0, v]
int luaL_argerror (lua_State *L, int narg, const char *extramsg);
Raises an error with the following message, where func is retrieved from the call stack:


     bad argument # to ()
This function never returns, but it is an idiom to use it in C functions as return luaL_argerror(args).


luaL_Buffer
typedef struct luaL_Buffer luaL_Buffer;
Type for a string buffer.


A string buffer allows C code to build Lua strings piecemeal. Its pattern of use is as follows:


First you declare a variable b of type luaL_Buffer.
Then you initialize it with a call luaL_buffinit(L, &b).
Then you add string pieces to the buffer calling any of the luaL_add* functions.
You finish by calling luaL_pushresult(&b). This call leaves the final string on the top of the stack.
During its normal operation, a string buffer uses a variable number of stack slots. So, while using a buffer, you cannot assume that you know where the top of the stack is. You can use the stack between successive calls to buffer operations as long as that use is balanced; that is, when you call a buffer operation, the stack is at the same level it was immediately after the previous buffer operation. (The only exception to this rule is luaL_addvalue.) After calling luaL_pushresult the stack is back to its level when the buffer was initialized, plus the final string on its top.


luaL_buffinit
[-0, +0, -]
void luaL_buffinit (lua_State *L, luaL_Buffer *B);
Initializes a buffer B. This function does not allocate any space; the buffer must be declared as a variable (see luaL_Buffer).


luaL_callmeta
[-0, +(0|1), e]
int luaL_callmeta (lua_State *L, int obj, const char *e);
Calls a metamethod.


If the object at index obj has a metatable and this metatable has a field e, this function calls this field and passes the object as its only argument. In this case this function returns 1 and pushes onto the stack the value returned by the call. If there is no metatable or no metamethod, this function returns 0 (without pushing any value on the stack).


luaL_checkany
[-0, +0, v]
void luaL_checkany (lua_State *L, int narg);
Checks whether the function has an argument of any type (including nil) at position narg.


luaL_checkint
[-0, +0, v]
int luaL_checkint (lua_State *L, int narg);
Checks whether the function argument narg is a number and returns this number cast to an int.


luaL_checkinteger
[-0, +0, v]
lua_Integer luaL_checkinteger (lua_State *L, int narg);
Checks whether the function argument narg is a number and returns this number cast to a lua_Integer.


luaL_checklong
[-0, +0, v]
long luaL_checklong (lua_State *L, int narg);
Checks whether the function argument narg is a number and returns this number cast to a long.


luaL_checklstring
[-0, +0, v]
const char *luaL_checklstring (lua_State *L, int narg, size_t *l);
Checks whether the function argument narg is a string and returns this string; if l is not NULL fills *l with the string's length.


This function uses lua_tolstring to get its result, so all conversions and caveats of that function apply here.


luaL_checknumber
[-0, +0, v]
lua_Number luaL_checknumber (lua_State *L, int narg);
Checks whether the function argument narg is a number and returns this number.


luaL_checkoption
[-0, +0, v]
int luaL_checkoption (lua_State *L,
                      int narg,
                      const char *def,
                      const char *const lst[]);
Checks whether the function argument narg is a string and searches for this string in the array lst (which must be NULL-terminated). Returns the index in the array where the string was found. Raises an error if the argument is not a string or if the string cannot be found.


If def is not NULL, the function uses def as a default value when there is no argument narg or if this argument is nil.


这是一个将字符串映射到C枚举的有用函数。（Lua库中的常规约定是使用字符串而不是数字来选择选项。）


luaL_checkstack
[-0，+ 0，v ]
void luaL_checkstack（lua_State * L，int sz，const char * msg）;
将堆栈大小增加到top + sz元素，如果堆栈不能增长到这个大小，则会引发错误。 msg是进入错误消息的附加文本。


luaL_checkstring
[-0，+ 0，v ]
const char * luaL_checkstring（lua_State * L，int narg）;
检查函数参数narg是否是字符串并返回此字符串。


这个函数用来lua_tolstring得到它的结果，所以这个函数的所有转换和注意事项都适用于这里。


luaL_checktype
[-0，+ 0，v ]
void luaL_checktype（lua_State * L，int narg，int t）;
检查函数参数是否narg有类型t。请参阅lua_type类型的编码t。


luaL_checkudata
[-0，+ 0，v ]
void * luaL_checkudata（lua_State * L，int narg，const char * tname）;
检查函数参数是否narg是该类型的用户数据tname（请参阅luaL_newmetatable）。


luaL_dofile
[-0，+？，m ]
int luaL_dofile（lua_State * L，const char * filename）;
加载并运行给定的文件。它被定义为以下宏：


     （luaL_loadfile（L，filename）|| lua_pcall（L，0，LUA_MULTRET，0））
如果没有错误，则返回0;如果有错误，则返回1。


luaL_dostring
[-0，+？，m ]
int luaL_dostring（lua_State * L，const char * str）;
加载并运行给定的字符串。它被定义为以下宏：


     （luaL_loadstring（L，str）|| lua_pcall（L，0，LUA_MULTRET，0））
如果没有错误，则返回0;如果有错误，则返回1。


luaL_error
[-0，+ 0，v ]
int luaL_error（lua_State * L，const char * fmt，...）;
引发错误。错误消息格式由fmt 加上任何额外的参数给出，遵循相同的规则lua_pushfstring。如果该信息可用，它还会在消息的开始处添加文件名和发生错误的行号。


这个函数永远不会返回，但在C函数中使用它是一个习惯用法。 return luaL_error(args)


luaL_getmetafield
[-0，+（0 | 1），m ]
int luaL_getmetafield（lua_State * L，int obj，const char * e）;
e从索引处的对象的元表面上将 字段压入堆栈obj。如果对象没有metatable，或者如果metatable没有这个字段，则返回0，并且不推送任何东西。


luaL_getmetatable
[-0，+1，- ]
void luaL_getmetatable（lua_State * L，const char * tname）;
将与名称相关联的元数据压入堆栈tname （请参阅参考资料luaL_newmetatable）。


luaL_gsub
[-0，+1，m ]
const char * luaL_gsub（lua_State * L，
                       const char * s，
                       const char * p，
                       const char * r）;
创建字符串的副本s替换字符串出现的任何p 以字符串r。将结果字符串推入堆栈并返回。


luaL_loadbuffer
[-0，+1，m ]
int luaL_loadbuffer (lua_State *L,
                     const char *buff,
                     size_t sz,
                     const char *name);
Loads a buffer as a Lua chunk. This function uses lua_load to load the chunk in the buffer pointed to by buff with size sz.


This function returns the same results as lua_load. name is the chunk name, used for debug information and error messages.


luaL_loadfile
[-0, +1, m]
int luaL_loadfile (lua_State *L, const char *filename);
Loads a file as a Lua chunk. This function uses lua_load to load the chunk in the file named filename. If filename is NULL, then it loads from the standard input. The first line in the file is ignored if it starts with a #.


This function returns the same results as lua_load, but it has an extra error code LUA_ERRFILE if it cannot open/read the file.


As lua_load, this function only loads the chunk; it does not run it.


luaL_loadstring
[-0, +1, m]
int luaL_loadstring (lua_State *L, const char *s);
Loads a string as a Lua chunk. This function uses lua_load to load the chunk in the zero-terminated string s.


This function returns the same results as lua_load.


Also as lua_load, this function only loads the chunk; it does not run it.


luaL_newmetatable
[-0, +1, m]
int luaL_newmetatable (lua_State *L, const char *tname);
If the registry already has the key tname, returns 0. Otherwise, creates a new table to be used as a metatable for userdata, adds it to the registry with key tname, and returns 1.


In both cases pushes onto the stack the final value associated with tname in the registry.


luaL_newstate
[-0, +0, -]
lua_State *luaL_newstate (void);
Creates a new Lua state. It calls lua_newstate with an allocator based on the standard C realloc function and then sets a panic function (see lua_atpanic) that prints an error message to the standard error output in case of fatal errors.


Returns the new state, or NULL if there is a memory allocation error.


luaL_openlibs
[-0, +0, m]
void luaL_openlibs (lua_State *L);
Opens all standard Lua libraries into the given state.


luaL_optint
[-0, +0, v]
int luaL_optint (lua_State *L, int narg, int d);
If the function argument narg is a number, returns this number cast to an int. If this argument is absent or is nil, returns d. Otherwise, raises an error.


luaL_optinteger
[-0, +0, v]
lua_Integer luaL_optinteger (lua_State *L,
                             int narg,
                             lua_Integer d);
If the function argument narg is a number, returns this number cast to a lua_Integer. If this argument is absent or is nil, returns d. Otherwise, raises an error.


luaL_optlong
[-0, +0, v]
long luaL_optlong (lua_State *L, int narg, long d);
If the function argument narg is a number, returns this number cast to a long. If this argument is absent or is nil, returns d. Otherwise, raises an error.


luaL_optlstring
[-0, +0, v]
const char *luaL_optlstring (lua_State *L,
                             int narg,
                             const char *d,
                             size_t *l);
If the function argument narg is a string, returns this string. If this argument is absent or is nil, returns d. Otherwise, raises an error.


If l is not NULL, fills the position *l with the results's length.


luaL_optnumber
[-0, +0, v]
lua_Number luaL_optnumber (lua_State *L, int narg, lua_Number d);
If the function argument narg is a number, returns this number. If this argument is absent or is nil, returns d. Otherwise, raises an error.


luaL_optstring
[-0, +0, v]
const char *luaL_optstring (lua_State *L,
                            int narg,
                            const char *d);
If the function argument narg is a string, returns this string. If this argument is absent or is nil, returns d. Otherwise, raises an error.


luaL_prepbuffer
[-0, +0, -]
char *luaL_prepbuffer (luaL_Buffer *B);
Returns an address to a space of size LUAL_BUFFERSIZE where you can copy a string to be added to buffer B (see luaL_Buffer). After copying the string into this space you must call luaL_addsize with the size of the string to actually add it to the buffer.


luaL_pushresult
[-?, +1, m]
void luaL_pushresult (luaL_Buffer *B);
Finishes the use of buffer B leaving the final string on the top of the stack.


luaL_ref
[-1, +0, m]
int luaL_ref (lua_State *L, int t);
Creates and returns a reference, in the table at index t, for the object at the top of the stack (and pops the object).


A reference is a unique integer key. As long as you do not manually add integer keys into table t, luaL_ref ensures the uniqueness of the key it returns. You can retrieve an object referred by reference r by calling lua_rawgeti(L, t, r). Function luaL_unref frees a reference and its associated object.


If the object at the top of the stack is nil, luaL_ref returns the constant LUA_REFNIL. The constant LUA_NOREF is guaranteed to be different from any reference returned by luaL_ref.


luaL_Reg
typedef struct luaL_Reg {
  const char *name;
  lua_CFunction func;
} luaL_Reg;
Type for arrays of functions to be registered by luaL_register. name is the function name and func is a pointer to the function. Any array of luaL_Reg must end with an sentinel entry in which both name and func are NULL.


luaL_register
[-(0|1), +1, m]
void luaL_register (lua_State *L,
                    const char *libname,
                    const luaL_Reg *l);
Opens a library.


When called with libname equal to NULL, it simply registers all functions in the list l (see luaL_Reg) into the table on the top of the stack.


When called with a non-null libname, luaL_register creates a new table t, sets it as the value of the global variable libname, sets it as the value of package.loaded[libname], and registers on it all functions in the list l. If there is a table in package.loaded[libname] or in variable libname, reuses this table instead of creating a new one.


In any case the function leaves the table on the top of the stack.


luaL_typename
[-0, +0, -]
const char *luaL_typename (lua_State *L, int index);
Returns the name of the type of the value at the given index.


luaL_typerror
[-0, +0, v]
int luaL_typerror (lua_State *L, int narg, const char *tname);
Generates an error with a message like the following:


     location: bad argument narg to 'func' (tname expected, got rt)
where location is produced by luaL_where, func is the name of the current function, and rt is the type name of the actual argument.


luaL_unref
[-0, +0, -]
void luaL_unref (lua_State *L, int t, int ref);
Releases reference ref from the table at index t (see luaL_ref). The entry is removed from the table, so that the referred object can be collected. The reference ref is also freed to be used again.


If ref is LUA_NOREF or LUA_REFNIL, luaL_unref does nothing.


luaL_where
[-0, +1, m]
void luaL_where (lua_State *L, int lvl);
Pushes onto the stack a string identifying the current position of the control at level lvl in the call stack. Typically this string has the following format:


     chunkname:currentline:
Level 0 is the running function, level 1 is the function that called the running function, etc.


This function is used to build a prefix for error messages.


5 – Standard Libraries
The standard Lua libraries provide useful functions that are implemented directly through the C API. Some of these functions provide essential services to the language (e.g., type and getmetatable); others provide access to "outside" services (e.g., I/O); and others could be implemented in Lua itself, but are quite useful or have critical performance requirements that deserve an implementation in C (e.g., table.sort).


All libraries are implemented through the official C API and are provided as separate C modules. Currently, Lua has the following standard libraries:


basic library, which includes the coroutine sub-library;
package library;
string manipulation;
table manipulation;
mathematical functions (sin, log, etc.);
input and output;
operating system facilities;
debug facilities.
Except for the basic and package libraries, each library provides all its functions as fields of a global table or as methods of its objects.


To have access to these libraries, the C host program should call the luaL_openlibs function, which opens all standard libraries. Alternatively, it can open them individually by calling luaopen_base (for the basic library), luaopen_package (for the package library), luaopen_string (for the string library), luaopen_table (for the table library), luaopen_math (for the mathematical library), luaopen_io (for the I/O library), luaopen_os (for the Operating System library), and luaopen_debug (for the debug library). These functions are declared in lualib.h and should not be called directly: you must call them like any other Lua C function, e.g., by using lua_call.


5.1 - 基本功能
基础库为Lua提供了一些核心功能。如果您不在应用程序中包含此库，则应仔细检查是否需要为其某些设施提供实现。


assert (v [, message])
当其参数的v值为假时发出错误（即，无或错误）; 否则，返回它的所有参数。 message是一个错误信息; 缺席时，默认为“断言失败！
collectgarbage ([opt [, arg]])
这个函数是垃圾收集器的通用接口。它根据它的第一个参数执行不同的功能opt：


“收集”： 执行完整的垃圾收集循环。这是默认选项。
"stop": stops the garbage collector.
"restart": restarts the garbage collector.
"count": returns the total memory in use by Lua (in Kbytes).
"step": performs a garbage-collection step. The step "size" is controlled by arg (larger values mean more steps) in a non-specified way. If you want to control the step size you must experimentally tune the value of arg. Returns true if the step finished a collection cycle.
"setpause": sets arg as the new value for the pause of the collector (see §2.10). Returns the previous value for pause.
“setstepmul”： 设置arg为收集器阶跃乘数的新值（见§2.10）。返回步骤的以前的值。
dofile ([filename])
打开指定的文件并以Lua块的形式执行其内容。当不带参数调用时， dofile执行标准input（stdin）的内容。返回块返回的所有值。在发生错误的情况下，将错误dofile传播给其调用者（即，dofile不在保护模式下运行）。
error (message [, level])
终止最后一个被调用的保护函数，并返回message错误信息。函数error永不返回。
通常，error在消息的开头添加一些关于错误位置的信息。该level参数指定如何获取错误位置。等级1（默认），错误位置是 error函数被调用的地方。级别2将错误指向调用的函数所在的位置error; 等等。传递级别0避免了错误的位置信息添加到消息。


_G
一个全局变量（而不是一个函数），用于保存全局环境（即_G._G = _G）。Lua本身并不使用这个变量; 改变它的价值不会影响任何环境，反之亦然。（setfenv用于改变环境。）
getfenv ([f])
返回函数正在使用的当前环境。 f可以是一个Lua函数或一个数字，指定在该堆栈级别的函数：级别1是函数调用getfenv。如果给定的函数不是Lua函数，或者f是0，则 getfenv返回全局环境。默认值f是1。
getmetatable (object)
如果object没有metatable，则返回nil。否则，如果对象的metatable有一个"__metatable"字段，则返回相关的值。否则，返回给定对象的元数据。


ipairs (t)
返回三个值：一个迭代器函数，表t和0，这样的构造


     因为我，v在ipairs（t）做身体结束
will iterate over the pairs (1,t[1]), (2,t[2]), ···, up to the first integer key absent from the table.


load (func [, chunkname])
Loads a chunk using function func to get its pieces. Each call to func must return a string that concatenates with previous results. A return of an empty string, nil, or no value signals the end of the chunk.


If there are no errors, returns the compiled chunk as a function; otherwise, returns nil plus the error message. The environment of the returned function is the global environment.


chunkname is used as the chunk name for error messages and debug information. When absent, it defaults to "=(load)".


loadfile ([filename])
Similar to load, but gets the chunk from file filename or from the standard input, if no file name is given.


loadstring (string [, chunkname])
Similar to load, but gets the chunk from the given string.


To load and run a given string, use the idiom


     assert(loadstring(s))()
When absent, chunkname defaults to the given string.


next (table [, index])
Allows a program to traverse all fields of a table. Its first argument is a table and its second argument is an index in this table. next returns the next index of the table and its associated value. When called with nil as its second argument, next returns an initial index and its associated value. When called with the last index, or with nil in an empty table, next returns nil. If the second argument is absent, then it is interpreted as nil. In particular, you can use next(t) to check whether a table is empty.


The order in which the indices are enumerated is not specified, even for numeric indices. (To traverse a table in numeric order, use a numerical for or the ipairs function.)


The behavior of next is undefined if, during the traversal, you assign any value to a non-existent field in the table. You may however modify existing fields. In particular, you may clear existing fields.


pairs (t)
Returns three values: the next function, the table t, and nil, so that the construction


     for k,v in pairs(t) do body end
will iterate over all key–value pairs of table t.


See function next for the caveats of modifying the table during its traversal.


pcall (f, arg1, ···)
Calls function f with the given arguments in protected mode. This means that any error inside f is not propagated; instead, pcall catches the error and returns a status code. Its first result is the status code (a boolean), which is true if the call succeeds without errors. In such case, pcall also returns all results from the call, after this first result. In case of any error, pcall returns false plus the error message.


print (···)
接收任意数量的参数，并打印它们的值stdout，使用tostring函数将它们转换为字符串。 print不适用于格式化的输出，但只能作为显示值的快捷方式，通常用于调试。对于格式化的输出，使用string.format。
rawequal (v1, v2)
检查是否v1等于v2，不调用任何metamethod。返回一个布尔值。
rawget (table, index)
获取真正的价值table[index]，而不用任何metamethod。 table必须是一张桌子; index可能是任何值。
rawset (table, index, value)
设置的实际价值table[index]来value，而不调用任何元方法。 table必须是一个表， index任何不同于零的值，以及value任何Lua值。
这个函数返回table。


select (index, ···)
If index is a number, returns all arguments after argument number index. Otherwise, index must be the string "#", and select returns the total number of extra arguments it received.


setfenv (f, table)
Sets the environment to be used by the given function. f can be a Lua function or a number that specifies the function at that stack level: Level 1 is the function calling setfenv. setfenv returns the given function.


As a special case, when f is 0 setfenv changes the environment of the running thread. In this case, setfenv returns no values.


setmetatable (table, metatable)
设置给定表格的元数据。（你不能从Lua其他类型的元表改变，只是从C）如果metatable是零，删除指定表的元表。如果原始metatable有一个"__metatable"字段，则会引发错误。


这个函数返回table。


tonumber (e [, base])
尝试将其参数转换为数字。如果参数已经是可转换为数字的数字或字符串，则tonumber返回该数字; 否则返回nil。
可选参数指定解释数字的基础。基数可以是2和36之间的任何整数，包括2和36。在10以上的基数中，字母“ A（大写或小写）表示10，” B“表示11，等等，其中” Z“表示35.在基数10（缺省值）中，数字可以具有小数部分，以及一个可选的指数部分（见§2.1）。在其他基础上，只接受无符号整数。


tostring (e)
接收任何类型的参数并将其转换为合理格式的字符串。要完全控制数字如何转换，请使用string.format。
如果metatable e有一个"__tostring"字段，tostring则以e参数的形式调用相应的值，并将调用的结果作为结果。


type (v)
返回唯一参数的类型，以字符串形式编码。这个函数可能的结果是“ nil”（一个字符串，而不是值nil），“ number”，“ string”，“ boolean”，“ table”，“ function”，“ thread”和“ userdata”。
unpack (list [, i [, j]])
返回给定表格中的元素。这个功能相当于
     返回列表[i]，列表[i + 1]，...，列表[j]
除了上面的代码只能写入固定数量的元素。默认情况下，i是1，并且j是长度运算符定义的列表长度（见§2.5.5）。


_VERSION
保存包含当前解释器版本的字符串的全局变量（不是函数）。这个变量的当前内容是“ Lua 5.1”。
xpcall (f, err)
pcall除了你可以设置一个新的错误处理程序之外， 这个功能类似于。


xpcall calls function f in protected mode, using err as the error handler. Any error inside f is not propagated; instead, xpcall catches the error, calls the err function with the original error object, and returns a status code. Its first result is the status code (a boolean), which is true if the call succeeds without errors. In this case, xpcall also returns all results from the call, after this first result. In case of any error, xpcall returns false plus the result from err.


5.2 – Coroutine Manipulation
The operations related to coroutines comprise a sub-library of the basic library and come inside the table coroutine. See §2.11 for a general description of coroutines.


coroutine.create (f)
Creates a new coroutine, with body f. f must be a Lua function. Returns this new coroutine, an object with type "thread".


coroutine.resume (co [, val1, ···])
Starts or continues the execution of coroutine co. The first time you resume a coroutine, it starts running its body. The values val1, ··· are passed as the arguments to the body function. If the coroutine has yielded, resume restarts it; the values val1, ··· are passed as the results from the yield.


If the coroutine runs without any errors, resume returns true plus any values passed to yield (if the coroutine yields) or any values returned by the body function (if the coroutine terminates). If there is any error, resume returns false plus the error message.


coroutine.running ()
Returns the running coroutine, or nil when called by the main thread.


coroutine.status (co)
Returns the status of coroutine co, as a string: "running", if the coroutine is running (that is, it called status); "suspended", if the coroutine is suspended in a call to yield, or if it has not started running yet; "normal" if the coroutine is active but not running (that is, it has resumed another coroutine); and "dead" if the coroutine has finished its body function, or if it has stopped with an error.


coroutine.wrap (f)
Creates a new coroutine, with body f. f must be a Lua function. Returns a function that resumes the coroutine each time it is called. Any arguments passed to the function behave as the extra arguments to resume. Returns the same values returned by resume, except the first boolean. In case of error, propagates the error.


coroutine.yield (···)
Suspends the execution of the calling coroutine. The coroutine cannot be running a C function, a metamethod, or an iterator. Any arguments to yield are passed as extra results to resume.


5.3 – Modules
The package library provides basic facilities for loading and building modules in Lua. It exports two of its functions directly in the global environment: require and module. Everything else is exported in a table package.


module (name [, ···])
Creates a module. If there is a table in package.loaded[name], this table is the module. Otherwise, if there is a global table t with the given name, this table is the module. Otherwise creates a new table t and sets it as the value of the global name and the value of package.loaded[name]. This function also initializes t._NAME with the given name, t._M with the module (t itself), and t._PACKAGE with the package name (the full module name minus last component; see below). Finally, module sets t as the new environment of the current function and the new value of package.loaded[name], so that require returns t.


If name is a compound name (that is, one with components separated by dots), module creates (or reuses, if they already exist) tables for each component. For instance, if name is a.b.c, then module stores the module table in field c of field b of global a.


This function can receive optional options after the module name, where each option is a function to be applied over the module.


require (modname)
Loads the given module. The function starts by looking into the package.loaded table to determine whether modname is already loaded. If it is, then require returns the value stored at package.loaded[modname]. Otherwise, it tries to find a loader for the module.


To find a loader, require is guided by the package.loaders array. By changing this array, we can change how require looks for a module. The following explanation is based on the default configuration for package.loaders.


First require queries package.preload[modname]. If it has a value, this value (which should be a function) is the loader. Otherwise require searches for a Lua loader using the path stored in package.path. If that also fails, it searches for a C loader using the path stored in package.cpath. If that also fails, it tries an all-in-one loader (see package.loaders).


Once a loader is found, require calls the loader with a single argument, modname. If the loader returns any value, require assigns the returned value to package.loaded[modname]. If the loader returns no value and has not assigned any value to package.loaded[modname], then require assigns true to this entry. In any case, require returns the final value of package.loaded[modname].


If there is any error loading or running the module, or if it cannot find any loader for the module, then require signals an error.


package.cpath
The path used by require to search for a C loader.


Lua initializes the C path package.cpath in the same way it initializes the Lua path package.path, using the environment variable LUA_CPATH or a default path defined in luaconf.h.


package.loaded
A table used by require to control which modules are already loaded. When you require a module modname and package.loaded[modname] is not false, require simply returns the value stored there.


package.loaders
A table used by require to control how to load modules.


Each entry in this table is a searcher function. When looking for a module, require calls each of these searchers in ascending order, with the module name (the argument given to require) as its sole parameter. The function can return another function (the module loader) or a string explaining why it did not find that module (or nil if it has nothing to say). Lua initializes this table with four functions.


The first searcher simply looks for a loader in the package.preload table.


The second searcher looks for a loader as a Lua library, using the path stored at package.path. A path is a sequence of templates separated by semicolons. For each template, the searcher will change each interrogation mark in the template by filename, which is the module name with each dot replaced by a "directory separator" (such as "/" in Unix); then it will try to open the resulting file name. So, for instance, if the Lua path is the string


     "./?.lua;./?.lc;/usr/local/?/init.lua"
the search for a Lua file for module foo will try to open the files ./foo.lua, ./foo.lc, and /usr/local/foo/init.lua, in that order.


The third searcher looks for a loader as a C library, using the path given by the variable package.cpath. For instance, if the C path is the string


     "./?.so;./?.dll;/usr/local/?/init.so"
the searcher for module foo will try to open the files ./foo.so, ./foo.dll, and /usr/local/foo/init.so, in that order. Once it finds a C library, this searcher first uses a dynamic link facility to link the application with the library. Then it tries to find a C function inside the library to be used as the loader. The name of this C function is the string "luaopen_" concatenated with a copy of the module name where each dot is replaced by an underscore. Moreover, if the module name has a hyphen, its prefix up to (and including) the first hyphen is removed. For instance, if the module name is a.v1-b.c, the function name will be luaopen_b_c.


第四个搜索者尝试一个全功能的加载器。它在C路径中搜索给定模块的根名称的库。例如，当需要的时候a.b.c，它会搜索一个C库a。如果找到，它会查看子模块的打开功能; 在我们的例子中，这将是luaopen_a_b_c。有了这个功能，一个软件包可以将几个C子模块打包到一个单独的库中，每个子模块保持其原有的开放功能。


package.loadlib (libname, funcname)
动态链接主机程序和C库libname。在这个库里面，查找一个函数funcname 并且把这个函数作为一个C函数返回。（所以，funcname必须遵循协议（见lua_CFunction））。


这是一个低级功能。它完全绕过了封装和模块系统。不像require，它不执行任何路径搜索，并不会自动添加扩展。 libname必须是C库的完整文件名，包括必要的路径和扩展名。 funcname必须是C库导出的确切名称（可能取决于所使用的C编译器和链接器）。


ANSI C不支持此功能。因此，它仅在某些平台（Windows，Linux，Mac OS X，Solaris，BSD以及支持该dlfcn标准的其他Unix系统）上可用。


package.path
用于require搜索Lua加载器的路径。


在启动LUA_PATH时luaconf.h，如果没有定义环境变量，Lua会使用环境变量的值或定义的默认路径初始化此变量。;;环境变量的值中的任何“ ”被替换为默认路径。


package.preload
用于存储特定模块的加载程序的表（请参阅参考资料require）。


package.seeall (module)
module为其__index引用全局环境的字段 设置metatable ，以便该模块继承全局环境中的值。作为一个选项来使用module。


5.4 - 字符串操作
这个库提供了字符串操作的通用函数，例如查找和提取子字符串以及模式匹配。当在Lua中索引一个字符串时，第一个字符位于位置1（不是0，如C）。索引被允许为负数，并被解释为从字符串的末尾向后索引。因此，最后一个字符位于-1，依此类推。


字符串库提供了表内的所有功能 string。它还为__index字段指向string表格的字符串设置了一个metatable 。因此，可以使用面向对象风格的字符串函数。比如，string.byte(s, i) 可以写成s:byte(i)。


字符串库采用单字节字符编码。


string.byte (s [, i [, j]])
返回字符的内部数值代码s[i]， s[i+1]，...， s[j]。默认值为i1; 默认值j是  i。
请注意，数字代码不一定是跨平台移植的。


string.char (···)
接收零个或多个整数。返回长度等于参数个数的字符串，其中每个字符的内部数字代码等于其相应的参数。
请注意，数字代码不一定是跨平台移植的。


string.dump (function)
返回一个包含给定函数的二进制表示的字符串，以便稍后loadstring在此字符串上返回函数的副本。 function必须是没有upvalues的Lua函数。


string.find (s, pattern [, init [, plain]])
寻找pattern字符串中的第一个匹配项 s。如果发现匹配，则find返回s 此事件开始和结束的索引  ; 否则返回nil。第三个可选的数字参数init指定从何处开始搜索; 其默认值是1，可以是负值。作为第四个可选参数的true值plain 会关闭模式匹配工具，所以函数会执行简单的“查找子字符串”操作，而不会将字符pattern视为“魔术”。请注意，如果plain给出，那么也init必须给出。
如果模式已经捕获，那么在成功的匹配中，捕获的值也在两个索引之后被返回。


string.format (formatstring, ···)
按照在其第一个参数（必须是字符串）中给出的描述，返回其可变数量参数的格式化版本。格式字符串遵循与printf标准C函数族相同的规则。唯一的区别是选项/修饰符 *，l，L，n，p，和h不支持，并且有一个额外的选项，q。这个q选项格式化一个适合于被Lua解释器安全地读回的形式的字符串：字符串被写在双引号之间，并且字符串中的所有双引号，换行符，嵌入的零和反斜杠在写入时被正确地转义。例如，电话
     string.format（'％q'，'带有“引号”的字符串和\ n换行符）
会产生字符串：


     “带有”引号“的字符串和”
      新队”
选项c，d，E，e，f， g，G，i，o，u，X，和x所有期望一个数字作为论据，而q与s期望的字符串。


该函数不接受包含嵌入的零的字符串值，除了作为q选项的参数。


string.gmatch (s, pattern)
返回一个迭代器函数，每次调用它时，都会从pattern字符串中返回下一个捕获s。如果pattern没有指定捕捉，则整个比赛在每个呼叫中​​产生。
作为一个例子，下面的循环


     s =“来自Lua的你好世界”
     对于string.gmatch（s，“％a +”）中的w
       打印（W）
     结束
将遍历字符串中的所有单词s，每行打印一个单词。下一个示例key=value将给定字符串中的所有对都收集到一个表中：


     t = {}
     s =“from = world，to = Lua”
     对于k，v in string.gmatch（s，“（％w +）=（％w +）”）做
       t [k] = v
     结束
对于这个函数，^模式开始处的“ '不能作为锚点，因为这会阻止迭代。


string.gsub (s, pattern, repl [, n])
返回s 其中的所有（或第一个n，如果给定）出现pattern已被替换字符串指定的替换字符串的副本repl，可以是字符串，表或函数。 gsub也作为其第二个值返回发生的匹配总数。
If repl is a string, then its value is used for replacement. The character % works as an escape character: any sequence in repl of the form %n, with n between 1 and 9, stands for the value of the n-th captured substring (see below). The sequence %0 stands for the whole match. The sequence %% stands for a single %.


If repl is a table, then the table is queried for every match, using the first capture as the key; if the pattern specifies no captures, then the whole match is used as the key.


If repl is a function, then this function is called every time a match occurs, with all captured substrings passed as arguments, in order; if the pattern specifies no captures, then the whole match is passed as a sole argument.


If the value returned by the table query or by the function call is a string or a number, then it is used as the replacement string; otherwise, if it is false or nil, then there is no replacement (that is, the original match is kept in the string).


Here are some examples:


     x = string.gsub("hello world", "(%w+)", "%1 %1")
     --> x="hello hello world world"
     
     x = string.gsub("hello world", "%w+", "%0 %0", 1)
     --> x="hello hello world"
     
     x = string.gsub（“来自Lua的Hello世界”，“（％w +）％s *（％w +）”，“％2％1”）
     - > x =“世界你好Lua从”
     
     x = string.gsub（“home = $ HOME，user = $ USER”，“％$（％w +）”，os.getenv）
     - > x =“home = / home / roberto，user = roberto”
     
     x = string.gsub（“4 + 5 = $ return 4 + 5 $”，“％$（.-）％$”，函数
           返回loadstring（s）（）
         结束）
     - > x =“4 + 5 = 9”
     
     本地t = {name =“lua”，version =“5.1”}
     x = string.gsub（“$ name- $ version.tar.gz”，“％$（％w +）”，t）
     - > x =“lua-5.1.tar.gz”
string.len (s)
接收一个字符串并返回其长度。空字符串的""长度为0.嵌入的零计数，所以"a\000bc\000"长度为5。
string.lower (s)
接收一个字符串并返回该字符串的一个副本，并将所有大写字母改为小写。所有其他字符保持不变。大写字母的定义取决于当前的语言环境。
string.match (s, pattern [, init])
寻找字符串中的第一个匹配项 。如果它找到一个，然后从模式返回捕获; 否则返回nil。如果指定不捕获，则返回整个匹配。第三个可选的数字参数指定从何处开始搜索; 其默认值是1，可以是负值。 patternsmatchpatterninit
string.rep (s, n)
返回字符串的n副本串联的字符串s。
string.reverse (s)
返回一个字符串，它是s反转的字符串。
string.sub (s, i [, j])
返回的字符串s开始于i 和继续，直到j; i并j可能是负面的。如果j不存在，则假定它等于-1（这与字符串长度相同）。特别地，所述呼叫string.sub(s,1,j)返回的前缀s 与长度j，并且string.sub(s, -i)返回的后缀s 与长度i。
string.upper (s)
接收一个字符串并返回此字符串的一个副本，并将所有小写字母更改为大写。所有其他字符保持不变。小写字母的定义取决于当前的语言环境。
5.4.1 - 模式
字符类：
A character class is used to represent a set of characters. The following combinations are allowed in describing a character class:


x: (where x is not one of the magic characters ^$()%.[]*+-?) represents the character x itself.
.: (a dot) represents all characters.
%a: represents all letters.
%c: represents all control characters.
%d: represents all digits.
%l: represents all lowercase letters.
%p: represents all punctuation characters.
%s: represents all space characters.
%u: represents all uppercase letters.
%w: represents all alphanumeric characters.
%x: represents all hexadecimal digits.
%z: represents the character with representation 0.
%x: (where x is any non-alphanumeric character) represents the character x. This is the standard way to escape the magic characters. Any punctuation character (even the non magic) can be preceded by a '%' when used to represent itself in a pattern.
[set]: represents the class which is the union of all characters in set. A range of characters can be specified by separating the end characters of the range with a '-'. All classes %x described above can also be used as components in set. All other characters in set represent themselves. For example, [%w_] (or [_%w]) represents all alphanumeric characters plus the underscore, [0-7] represents the octal digits, and [0-7%l%-] represents the octal digits plus the lowercase letters plus the '-' character.
The interaction between ranges and classes is not defined. Therefore, patterns like [%a-z] or [a-%%] have no meaning.


[^set]: represents the complement of set, where set is interpreted as above.
For all classes represented by single letters (%a, %c, etc.), the corresponding uppercase letter represents the complement of the class. For instance, %S represents all non-space characters.


The definitions of letter, space, and other character groups depend on the current locale. In particular, the class [a-z] may not be equivalent to %l.


Pattern Item:
A pattern item can be


a single character class, which matches any single character in the class;
a single character class followed by '*', which matches 0 or more repetitions of characters in the class. These repetition items will always match the longest possible sequence;
a single character class followed by '+', which matches 1 or more repetitions of characters in the class. These repetition items will always match the longest possible sequence;
a single character class followed by '-', which also matches 0 or more repetitions of characters in the class. Unlike '*', these repetition items will always match the shortest possible sequence;
a single character class followed by '?', which matches 0 or 1 occurrence of a character in the class;
%n, for n between 1 and 9; such item matches a substring equal to the n-th captured string (see below);
%bxy, where x and y are two distinct characters; such item matches strings that start with x, end with y, and where the x and y are balanced. This means that, if one reads the string from left to right, counting +1 for an x and -1 for a y, the ending y is the first y where the count reaches 0. For instance, the item %b() matches expressions with balanced parentheses.
Pattern:
A pattern is a sequence of pattern items. A '^' at the beginning of a pattern anchors the match at the beginning of the subject string. A '$' at the end of a pattern anchors the match at the end of the subject string. At other positions, '^' and '$' have no special meaning and represent themselves.


Captures:
A pattern can contain sub-patterns enclosed in parentheses; they describe captures. When a match succeeds, the substrings of the subject string that match captures are stored (captured) for future use. Captures are numbered according to their left parentheses. For instance, in the pattern "(a*(.)%w(%s*))", the part of the string matching "a*(.)%w(%s*)" is stored as the first capture (and therefore has number 1); the character matching "." is captured with number 2, and the part matching "%s*" has number 3.


As a special case, the empty capture () captures the current string position (a number). For instance, if we apply the pattern "()aa()" on the string "flaaap", there will be two captures: 3 and 5.


模式不能包含嵌入的零。%z改为使用。


5.5 - 表操纵
这个库提供了表格操作的通用函数。它提供了表内的所有功能table。


表格库中的大多数函数都假定表格代表一个数组或一个列表。对于这些函数，当我们谈论表格的“长度”时，我们指的是长度运算符的结果。


table.concat (table [, sep [, i [, j]]])
给定一个所有元素都是字符串或数字的数组，返回table[i]..sep..table[i+1] ··· sep..table[j]。默认值为sep空字符串，默认i值为1，默认j值为表的长度。如果i大于j，则返回空字符串。
table.insert (table, [pos,] value)
Inserts element value at position pos in table, shifting up other elements to open space, if necessary. The default value for pos is n+1, where n is the length of the table (see §2.5.5), so that a call table.insert(t,x) inserts x at the end of table t.


table.maxn (table)
Returns the largest positive numerical index of the given table, or zero if the table has no positive numerical indices. (To do its job this function does a linear traversal of the whole table.)


table.remove (table [, pos])
如果需要， 从table位置上的元素中移除pos，向下移动其他元素以关闭该空间。返回已移除元素的值。posis 的默认值是n，n表的长度，以便调用table.remove(t)删除表的最后一个元素t。


table.sort (table [, comp])
排序以给定顺序表元素，就地，从table[1]到table[n]，这里n是表的长度。如果comp给出，那么它必须是一个接收两个表元素的函数，当第一个元素小于第二个元素时返回true（所以not comp(a[i+1],a[i])在排序后将是真的）。如果comp没有给出，则使用标准的Lua运算符<来代替。
The sort algorithm is not stable; that is, elements considered equal by the given order may have their relative positions changed by the sort.


5.6 – Mathematical Functions
This library is an interface to the standard C math library. It provides all its functions inside the table math.


math.abs (x)
Returns the absolute value of x.


math.acos (x)
Returns the arc cosine of x (in radians).


math.asin (x)
Returns the arc sine of x (in radians).


math.atan (x)
Returns the arc tangent of x (in radians).


math.atan2 (y, x)
Returns the arc tangent of y/x (in radians), but uses the signs of both parameters to find the quadrant of the result. (It also handles correctly the case of x being zero.)


math.ceil (x)
Returns the smallest integer larger than or equal to x.


math.cos (x)
Returns the cosine of x (assumed to be in radians).


math.cosh (x)
Returns the hyperbolic cosine of x.


math.deg (x)
Returns the angle x (given in radians) in degrees.


math.exp (x)
Returns the value ex.


math.floor (x)
Returns the largest integer smaller than or equal to x.


math.fmod (x, y)
Returns the remainder of the division of x by y that rounds the quotient towards zero.


math.frexp (x)
Returns m and e such that x = m2e, e is an integer and the absolute value of m is in the range [0.5, 1) (or zero when x is zero).


math.huge
The value HUGE_VAL, a value larger than or equal to any other numerical value.


math.ldexp (m, e)
Returns m2e (e should be an integer).


math.log (x)
Returns the natural logarithm of x.


math.log10 (x)
Returns the base-10 logarithm of x.


math.max (x, ···)
Returns the maximum value among its arguments.


math.min (x, ···)
Returns the minimum value among its arguments.


math.modf (x)
Returns two numbers, the integral part of x and the fractional part of x.


math.pi
The value of pi.


math.pow (x, y)
Returns xy. (You can also use the expression x^y to compute this value.)


math.rad (x)
Returns the angle x (given in degrees) in radians.


math.random ([m [, n]])
This function is an interface to the simple pseudo-random generator function rand provided by ANSI C. (No guarantees can be given for its statistical properties.)


When called without arguments, returns a uniform pseudo-random real number in the range [0,1). When called with an integer number m, math.random returns a uniform pseudo-random integer in the range [1, m]. When called with two integer numbers m and n, math.random returns a uniform pseudo-random integer in the range [m, n].


math.randomseed (x)
Sets x as the "seed" for the pseudo-random generator: equal seeds produce equal sequences of numbers.


math.sin (x)
Returns the sine of x (assumed to be in radians).


math.sinh (x)
Returns the hyperbolic sine of x.


math.sqrt (x)
Returns the square root of x. (You can also use the expression x^0.5 to compute this value.)


math.tan (x)
Returns the tangent of x (assumed to be in radians).


math.tanh (x)
Returns the hyperbolic tangent of x.


5.7 – Input and Output Facilities
The I/O library provides two different styles for file manipulation. The first one uses implicit file descriptors; that is, there are operations to set a default input file and a default output file, and all input/output operations are over these default files. The second style uses explicit file descriptors.


When using implicit file descriptors, all operations are supplied by table io. When using explicit file descriptors, the operation io.open returns a file descriptor and then all operations are supplied as methods of the file descriptor.


The table io also provides three predefined file descriptors with their usual meanings from C: io.stdin, io.stdout, and io.stderr. The I/O library never closes these files.


Unless otherwise stated, all I/O functions return nil on failure (plus an error message as a second result and a system-dependent error code as a third result) and some value different from nil on success.


io.close ([file])
Equivalent to file:close(). Without a file, closes the default output file.


io.flush ()
相当于file:flush默认的输出文件。


io.input ([file])
当用文件名称调用时，它将打开指定文件（以文本模式），并将其句柄设置为默认输入文件。当用文件句柄调用时，它只是将这个文件句柄设置为默认的输入文件。当不带参数调用时，它返回当前的默认输入文件。


如果发生错误，该函数将引发错误，而不是返回错误代码。


io.lines ([filename])
以读取模式打开给定的文件名，并返回一个迭代器函数，每次调用时都会从文件中返回一个新行。所以建设


     对于io.lines（文件名）行的身体结束
将迭代文件的所有行。当迭代器函数检测到文件结束时，返回nil（结束循环）并自动关闭文件。


这个调用io.lines()（没有文件名）相当于io.input():lines(); 也就是说，它遍历默认输入文件的行。在这种情况下，循环结束时不会关闭文件。


io.open (filename [, mode])
该函数以字符串中指定的模式打开一个文件mode。它返回一个新的文件句柄，或者在错误情况下，零加一条错误消息。


该mode字符串可以是以下任何一个：


“r”：读取模式（默认）;
“w”：写模式;
“a”：追加模式;
“r +”：更新模式，所有以前的数据被保留;
“w +”：更新模式，所有先前的数据被擦除;
“a +”：追加更新模式，保留以前的数据，只允许在文件末尾写入。
该mode字符串也可以有一个“ b”末，这是需要在某些系统中以二进制方式打开该文件。这个字符串正是在标准C函数中使用的fopen。


io.output ([file])
与io.input默认输出文件类似，但是在默认输出文件上运行


io.popen (prog [, mode])
prog以独立的进程 启动程序，并返回一个文件句柄，您可以使用该句柄从该程序（如果mode是"r"，默认）读取数据或将数据写入该程序（如果mode是"w"）。


此功能是依赖于系统的，并不适用于所有平台。


io.read (···)
相当于io.input():read。


io.tmpfile ()
返回临时文件的句柄。该文件在更新模式下打开，并在程序结束时自动删除。


io.type (obj)
检查是否obj是有效的文件句柄。返回字符串"file"，如果obj是一个开放的文件句柄， "closed file"如果obj是一个封闭的文件句柄，或者为零，如果obj不是一个文件句柄。


io.write (···)
相当于io.output():write。


file:close ()
关闭file。请注意，当他们的手柄被垃圾收集时，文件会自动关闭，但这需要花费不可预测的时间。


file:flush ()
保存任何写入的数据file。


file:lines ()
Returns an iterator function that, each time it is called, returns a new line from the file. Therefore, the construction


     for line in file:lines() do body end
will iterate over all lines of the file. (Unlike io.lines, this function does not close the file when the loop ends.)


file:read (···)
Reads the file file, according to the given formats, which specify what to read. For each format, the function returns a string (or a number) with the characters read, or nil if it cannot read data with the specified format. When called without formats, it uses a default format that reads the entire next line (see below).


The available formats are


"*n": reads a number; this is the only format that returns a number instead of a string.
"*a": reads the whole file, starting at the current position. On end of file, it returns the empty string.
"*l": reads the next line (skipping the end of line), returning nil on end of file. This is the default format.
number: reads a string with up to this number of characters, returning nil on end of file. If number is zero, it reads nothing and returns an empty string, or nil on end of file.
file:seek ([whence] [, offset])
Sets and gets the file position, measured from the beginning of the file, to the position given by offset plus a base specified by the string whence, as follows:


"set": base is position 0 (beginning of the file);
"cur": base is current position;
"end": base is end of file;
In case of success, function seek returns the final file position, measured in bytes from the beginning of the file. If this function fails, it returns nil, plus a string describing the error.


The default value for whence is "cur", and for offset is 0. Therefore, the call file:seek() returns the current file position, without changing it; the call file:seek("set") sets the position to the beginning of the file (and returns 0); and the call file:seek("end") sets the position to the end of the file, and returns its size.


file:setvbuf (mode [, size])
Sets the buffering mode for an output file. There are three available modes:


"no": no buffering; the result of any output operation appears immediately.
"full": full buffering; output operation is performed only when the buffer is full (or when you explicitly flush the file (see io.flush)).
"line": line buffering; output is buffered until a newline is output or there is any input from some special files (such as a terminal device).
For the last two cases, size specifies the size of the buffer, in bytes. The default is an appropriate size.


file:write (···)
Writes the value of each of its arguments to the file. The arguments must be strings or numbers. To write other values, use tostring or string.format before write.


5.8 – Operating System Facilities
这个库是通过表来实现的os。


os.clock ()
返回程序使用的CPU时间量的近似值。


os.date ([format [, time]])
返回包含日期和时间的字符串或表格，根据给定的字符串格式化format。


如果time参数存在，则这是要格式化的时间（请参阅该os.time函数以获取该值的说明）。否则，date格式化当前时间。


如果format以“开头!”，则日期格式为协调世界时。如果format是字符串“ *t”，则date返回一个包含以下字段的表格：（ year四位数字），month（1--12），day（1-31）， hour（0--23），min（0- -59），sec（0--61），wday（星期几 ，星期天是1）， yday（一年中的某一天）和isdst（夏令时标志，一个布尔值）。


如果format不是“ *t”，则date将该日期作为字符串返回，按照与C函数相同的规则进行格式化strftime。


当没有参数的情况下调用时， date返回一个合理的日期和时间表示，这取决于主机系统和当前语言环境（即os.date()相当于os.date("%c")）。


os.difftime (t2, t1)
返回的秒数从时间t1到时间t2。在POSIX，Windows和其他一些系统中，这个值就是t2-t1。


os.execute ([command])
这个功能相当于C功能system。它通过command由操作系统shell执行。它返回一个依赖于系统的状态码。如果command不存在，那么如果shell可用则返回非零值，否则返回零。


os.exit ([code])
调用C函数exit（可选code）来终止主机程序。默认值code是成功代码。


os.getenv (varname)
返回进程环境变量的值，如果变量未定义varname，则返回nil。


os.remove (filename)
用给定的名字删除文件或目录。目录必须是空的才能被删除。如果此函数失败，则返回nil，加上描述错误的字符串。


os.rename (oldname, newname)
重命名命名文件或目录oldname来newname。如果此函数失败，则返回nil，加上描述错误的字符串。


os.setlocale (locale [, category])
设置程序的当前语言环境。 locale是一个指定语言环境的字符串; category是可选的字符串描述改变哪一类： "all"，"collate"，"ctype"， "monetary"，"numeric"，或"time"; 默认类别是"all"。该函数返回新语言环境的名称，如果请求不能被使用，则返回nil。


如果locale是空字符串，则将当前语言环境设置为实现定义的本地语言环境。如果locale是字符串“ C”，则将当前语言环境设置为标准C语言环境。


当用nil作为第一个参数调用时，此函数只返回给定类别的当前语言环境的名称。


os.time ([table])
不带参数的情况下返回当前时间，或者返回表示由给定表指定的日期和时间的时间。此表必须有字段year，month以及day，并可能有田hour，min，sec，和isdst （这些字段的描述，请参阅该os.date功能）。


返回的值是一个数字，其含义取决于您的系统。在POSIX，Windows和其他一些系统中，这个数字计算自某些给定的开始时间（“时代”）以来的秒数。在其它系统中，意思是未指定，并且通过返回的数字time只能用于作为参数 date和difftime。


os.tmpname ()
返回可用于临时文件的文件名的字符串。该文件必须在使用前明确打开，并在不再需要时明确删除。


在某些系统上（POSIX），这个函数也会创建一个名字的文件，以避免安全风险。（其他人可能会在获取名称和创建文件之间的时间内以错误的权限创建文件。）您仍然必须打开文件才能使用该文件并将其删除（即使不使用它）。


在可能的情况下，您可能更喜欢使用io.tmpfile，在程序结束时自动删除文件。


5.9 - 调试库
这个库为Lua程序提供了调试接口的功能。使用这个库时应该注意。这里提供的功能应该专门用于调试和类似的任务，如分析。请不要把它们作为一种常用编程工具的诱惑：它们可能非常慢。而且，这些函数中的一些违反了关于Lua代码的一些假设（例如，函数本地的变量不能从外部访问，或者用户数据元表不能被Lua代码改变），因此可能损害否则安全的代码。


debug表 中提供了该库中的所有功能。所有在线程上运行的函数都有一个可选的第一个参数，它是要运行的线程。默认总是当前线程。


debug.debug ()
与用户进入交互模式，运行用户输入的每个字符串。使用简单的命令和其他调试工具，用户可以检查全局和局部变量，更改它们的值，评估表达式等等。只包含单词的行会cont结束此函数，以便调用方继续执行。


请注意，用于命令的debug.debug任何函数都不是词法上的嵌套，所以不能直接访问局部变量。


debug.getfenv (o)
返回对象的环境o。
debug.gethook ([thread])
返回线程的当前钩子设置，作为三个值：当前钩子函数，当前钩子掩码和当前钩子计数（由debug.sethook函数设置）。


debug.getinfo ([thread,] function [, what])
返回一个包含有关函数信息的表。你可以直接给这个函数，也可以给一个数字作为值function，这意味着function在给定线程的调用堆栈级别上运行的函数：0级是当前函数（getinfo本身）。级别1是调用的函数getinfo; 等等。如果function是一个大于活动函数数的数字，则getinfo返回nil。


返回的表可以包含返回的所有字段lua_getinfo，字符串what描述填写哪些字段。缺省值what是获取除有效行之外的所有信息。如果存在，则选项“ f”添加一个以func该函数本身命名的字段。如果存在，选项“ L'添加一个以activelines有效行表命名的字段。


例如debug.getinfo(1,"n").name，如果可以找到一个合理的名字，那么表达式将返回一个带有当前函数名称debug.getinfo(print) 的表，并且该表达式返回一个包含该print函数所有可用信息的表。


debug.getlocal ([thread,] level, local)
此函数返回本地变量的名称和值，以及堆栈local级别的函数的索引level。（第一个参数或局部变量具有索引1，依此类推，直到最后一个活动局部变量）。如果没有给定索引的局部变量，则函数返回nil，并在level超出范围调用时引发错误。（您可以打电话debug.getinfo查看关卡是否有效。）


以“ (' 开头的变量名（左括号）表示内部变量（循环控制变量，临时变量和C函数本地变量）。


debug.getmetatable (object)
返回给定的元表object 或零，如果没有一个元表。


debug.getregistry ()
返回注册表（参见§3.5）。


debug.getupvalue (func, up)
该函数返回的名称和的upvalue的索引值up的功能func。如果给定的索引没有upvalue，函数返回nil。


debug.setfenv (object, table)
将给定的环境设置给object定table。退货object。


debug.sethook ([thread,] hook, mask [, count])
将给定的函数设置为钩子。字符串mask和数字count描述何时会调用钩子。字符串掩码可以具有以下字符，具有给定的含义：


"c"：每次Lua调用一个函数时都会调用这个钩子;
"r"：每次Lua从一个函数返回时都会调用这个钩子;
"l"：每次Lua输入一行新的代码时都会调用这个钩子。
与count零不同，挂钩在每个count指令之后被调用。


当没有参数调用时， debug.sethook关闭钩子。


当钩子被调用时，它的第一个参数是描述触发它的事件的字符串： "call"，"return"（或者"tail return"当模拟从尾部调用返回时） "line"，和"count"。对于线事件，钩子也获取新的线号作为其第二个参数。在一个钩子里面，你可以调用getinfo2级来得到关于运行函数的更多信息（0级是getinfo函数，1级是钩子函数），除非事件是"tail return"。在这种情况下，Lua只是模拟返回，而调用getinfo将返回无效数据。


debug.setlocal ([thread,] level, local, value)
该函数将该值分配给value本地变量和堆栈local级别的函数的索引level。如果给定索引不存在局部变量，则函数返回nil，并在level超出范围调用时引发错误。（您可以调用getinfo以检查该级别是否有效。）否则，它将返回局部变量的名称。


debug.setmetatable (object, table)
给定object给定的元数据table （可以为零）。


debug.setupvalue (func, up, value)
该函数将该值value与up该函数的索引一起赋值func。如果给定的索引没有upvalue，函数返回nil。否则，它返回upvalue的名称。


debug.traceback ([thread,] [message [, level]])
返回一个跟踪调用堆栈的字符串。message追踪开始处追加可选字符串。一个可选的level数字告诉在哪个级别开始回溯（默认是1，函数调用traceback）。


6 - Lua独立
尽管Lua被设计成一种扩展语言，被嵌入在一个C语言程序中，但它也经常作为一种独立的语言来使用。Lua作为一个独立语言的翻译被简单地称为lua标准分发。独立的解释器包括所有的标准库，包括调试库。它的用法是：


     lua [options] [script [args]]
选项是：


-e stat：执行字符串stat ;
-l mod： “require” mod ;
-i：运行脚本后进入交互模式;
-v：打印版本信息;
--：停止处理选项;
-：stdin作为文件执行并停止处理选项。
处理它的选项后，lua运行给定的脚本，并将给定的参数传递给字符串参数。当不带参数的情况下调用时， lua就像lua -v -i 标准input（stdin）是一个终端时一样，lua -否则就是如此。


在运行任何参数之前，解释器检查一个环境变量LUA_INIT。如果其格式是，则执行该文件。否则，执行字符串本身。 @filenamelualua


所有选项都按顺序处理，除了-i。例如，像一个调用


     $ lua -e'a = 1'-e'print（a）'script.lua
将首先设置a为1，然后打印a（“是1”）的值，最后运行script.lua没有参数的文件。（这里$是shell提示符，你的提示可能会有所不同）


在开始运行脚本之前， lua在全局表中调用命令行中的所有参数arg。脚本名称存储在索引0处，脚本名称转到索引1后的第一个参数，依此类推。脚本名称之前的任何参数（即解释器名称加上选项）将转到负数索引。例如，在通话中


     $ lua -la b.lua t1 t2
解释器首先运行该文件a.lua，然后创建一个表


     arg = {[-2] =“lua”，[-1] =“-la”，
             [0] =“b.lua”，
             [1] =“t1”，[2] =“t2”}
最后运行该文件b.lua。该脚本调用arg[1]，arg[2]，...作为参数; 它也可以使用可变参数表达式“ ...' 来访问这些参数。


在交互模式下，如果你写了一个不完整的语句，那么解释器通过发出不同的提示来等待它的完成。


如果全局变量_PROMPT包含一个字符串，则其值被用作提示。同样，如果全局变量_PROMPT2包含一个字符串，则其值将用作次要提示（在不完整的语句中发出）。因此，这两个提示可以直接在命令行上或在任何Lua程序中通过赋值来更改_PROMPT。看下面的例子：


     $ lua -e“_PROMPT ='myprompt>'”-i
（外面的一对引号是用于外壳的，内部的一对是Lua的。）注意使用-i进入交互模式; 否则，程序只会在赋值后立即结束_PROMPT。


为了允许在Unix系统中使用Lua作为脚本解释器，独立解释器跳过块的第一行（如果它开始的话）#。因此，Lua脚本可以通过使用chmod +x和  #!表格形式变成可执行程序，如


     ＃！的/ usr / local / bin目录/ LUA
（当然，在你的机器上，Lua解释器的位置可能不同，如果你的机器lua是在你的机器上的PATH话


     ＃！/ usr / bin / env lua
是一个更便携的解决方案。）


7 - 与以前的版本不兼容
在这里，我们列出了将程序从Lua 5.0移植到Lua 5.1时可能遇到的不兼容问题。你可以避免大部分的不兼容性用适当的选项编译Lua（见文件luaconf.h）。但是，所有这些兼容性选项将在下一个版本的Lua中删除。


7.1 - 语言的变化
可变参数系统从arg具有额外参数的表的伪参数变为可变参数表达式。（见编译时的选项LUA_COMPAT_VARARG在luaconf.h）。
for语句和repeat语句 的隐式变量的范围发生了微妙的变化。
长字符串/长注释语法（）不允许嵌套。在这些情况下，您可以使用新的语法（）。（见编译时的选项在）。 [[string]][=[string]=]LUA_COMPAT_LSTRluaconf.h
7.2 - 图书馆的变化
函数string.gfind被重命名string.gmatch。（见编译时的选项LUA_COMPAT_GFIND在luaconf.h）。
当string.gsub函数调用第三个参数时，只要这个函数返回nil或false，替换字符串就是整个匹配，而不是空字符串。
函数table.setn已被弃用。函数table.getn对应于新的长度运算符（#）; 使用操作符而不是函数。（见编译时的选项LUA_COMPAT_GETN在luaconf.h）。
函数loadlib被重命名package.loadlib。（见编译时的选项LUA_COMPAT_LOADLIB在luaconf.h）。
函数math.mod被重命名math.fmod。（见编译时的选项LUA_COMPAT_MOD在luaconf.h）。
功能table.foreach和table.foreachi弃用。您可以使用一个for循环使用pairs或ipairs代替。
require由于新的模块系统 ，功能发生了实质性的变化。但是，新的行为大多是与旧的兼容，但require会从路径package.path，而不是从LUA_PATH。
函数collectgarbage有不同的参数。功能gcinfo被弃用; 使用collectgarbage("count")来代替。
7.3 - API的变化
的luaopen_*函数（以打开库）不能被直接调用，像一个普通的C函数。他们必须通过Lua调用，就像Lua函数一样。
函数lua_open被替换lua_newstate为允许用户设置内存分配功能。您可以使用luaL_newstate标准库来创建具有标准分配功能的状态（基于realloc）。
函数luaL_getn和luaL_setn （来自辅助库）已被弃用。使用lua_objlen而不是，luaL_getn 而不是luaL_setn。
函数luaL_openlib被替换为luaL_register。
luaL_checkudata当给定值不是预期类型的​​用户数据时， 函数现在会引发错误。（在Lua 5.0中，它返回NULL。）
8 - Lua的完整句法
这里是扩展BNF中Lua的完整语法。（它没有描述运算符的优先级。）




chunk :: = {stat [` ; ']} [laststat [` ; “]


块:: =块


stat :: = varlist` = 'explist |
functioncall | 
做块结束 | 
而 exp 做 block end | 
重复块，直到 exp | 
如果 exp 然后阻塞{ elseif exp 然后阻塞} [ else block] end | 
for name` = 'exp` ， 'exp [` ， 'exp] do block end | 
对于名称列表中 explist 做块结束 | 
功能funcname funcbody | 
本地 函数名称funcbody | 
本地名称[` = 'explist]


laststat :: = return [explist] | 打破


funcname :: =名称{` 。'Name} [` ： 'Name]


varlist :: = var {` ， 'var}


var :: = Name | prefixexp` [ ' exp` ] '| prefixexp` 。名称


namelist :: =名称{` ， 'Name}


explist :: = {exp` ， '} exp


exp :: =   nil | false | true | 数字| 字符串| ` ... '| 函数|
prefixexp | tableconstructor | exp binop exp | unop exp


prefixexp :: = var | functioncall | ` （ 'exp` ） '


functioncall :: = prefixexp args | prefixexp` ： '名称参数


args :: =` （ '[explist]` ） '| tableconstructor | 串


函数:: = 函数 funcbody


funcbody :: =` （ '[parlist]` ） '块结束


parlist :: = namelist [` ， '` ... '] | ` ... '


tableconstructor :: =` { '[fieldlist]` } '


fieldlist :: = field {fieldsep field} [fieldsep]


field :: =` [ 'exp` ] '` = 'exp | 名字` = 'exp | EXP


fieldsep :: =` ， '| ` ; “


binop :: =` + '| ` - '| ` * '| ` / '| ` ^ '| ` ％ '| ` .. '|
` < '| ` <= '| ` > '| ` > = '| ' == '| ` 〜= '| 
和 | 要么


unop :: =` - '| 不是 | ` ＃ '


最后更新：2012年11月13日19:16:29 brst