Lua5.2参考手册：深入解析与应用

5星 · 超过95%的资源需积分: 16 108 浏览量更新于2024-07-24 1 收藏 1.67MB PDF 举报

"lua5.2参考手册（英文版） pdf" 《Lua5.2参考手册》是由Roberto Ierusalimschy、Luiz Henrique de Figueiredo和Waldemar Celes编写的，详细阐述了Lua 5.2版本的语言特性与变化。这本书的版权属于Lua.org和PUC-Rio，遵循Lua许可证的自由使用条款。 Lua是一种通用的扩展编程语言，特别注重数据描述功能，并支持过程化、面向对象、函数式以及数据驱动编程。其设计目标是作为强大而轻量级的嵌入式脚本语言，供任何需要此类语言的程序使用。Lua库以纯净的C语言实现，兼容标准C和C++的子集。作为一门扩展语言，Lua没有“主”程序的概念，它仅在宿主程序（或称为嵌入程序）中运行。宿主程序可以调用函数执行Lua代码，读写Lua变量，还可以注册C函数以便被Lua代码调用。通过使用C函数，Lua的能力可以得到扩展，以适应更广泛的领域，创建具有共同语法框架的定制编程语言。 Lua 5.2相较于5.0版本进行了一些改动，这些变化可能涉及语法、API接口、性能优化等方面。手册会详细介绍这些更新，帮助开发者理解和利用新版本的优点。例如，可能会包括新的数据类型、语言特性的增强、错误处理的改进、内存管理的调整等。在本书中，读者将学习到如何在Lua中声明变量、控制流程结构（如if语句、循环）、函数定义和调用、表（Lua的核心数据结构）的使用、模块化编程、元表和元方法的概念，以及如何与C语言进行交互等核心概念。此外，手册还会涵盖更高级的主题，如协程（coroutines）支持、垃圾回收机制、字符串处理、文件I/O操作，以及如何调试和优化Lua代码。对于初学者，手册将提供基础教学，帮助快速入门；对于经验丰富的开发者，手册则是一个详尽的参考，可以解决具体问题和深入理解语言机制。《Lua5.2参考手册》是学习和掌握Lua 5.2不可或缺的资源。

if not (var and limit and step) then error() end

while (step > 0 and var <= limit) or (step <= 0 and var >= limit) do

local v = var

block

var = var + step

end

Note the following:

z All three control expressions are evaluated only once, before the loop starts. They must all result in

numbers.

z var, limit, and step are invisible variables. The names shown here are for explanatory

purposes only.

z If the third expression (the step) is absent, then a step of 1 is used.

z You can use break to exit a for loop.

z The loop variable v is local to the loop; you cannot use its value after the for ends or is broken. If

you need this value, assign it to another variable before breaking or exiting the loop.

The generic for statement works over functions, called iterators. On each iteration, the iterator function is

called to produce a new value, stopping when this new value is nil. The generic for loop has the

following syntax:

stat ::= for namelist in explist do block end

namelist ::= Name {‘,’ Name}

A for statement like

for var_1, ···, var_n in explist do block end

is equivalent to the code:

local f, s, var = explist

while true do

local var_1, ···, var_n = f(s, var)

if var_1 == nil then break end

var = var_1

block

end

Note the following:

z explist is evaluated only once. Its results are an iterator function, a state, and an initial value for

the first iterator variable.

z f, s, and var are invisible variables. The names are here for explanatory purposes only.

z You can use break to exit a for loop.

z The loop variables var_i are local to the loop; you cannot use their values after the for ends. If

you need these values, then assign them to other variables before breaking or exiting the loop.

3.3.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 §3.4.9.

3.3.7 – Local Declarations

Local variables can be declared anywhere inside a block. The declaration can include an initial

assignment:

stat ::= loca

namelist [‘

’ explist]

If present, an initial assignment has the same semantics of a multiple assignment (see §3.3.3).

Otherwise, all variables are initialized with nil.

A chunk is also a block (see §3.3.2), and so local variables can be declared in a chunk outside any

explicit block.

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

3.4 – Expressions

The basic expressions in Lua are the following:

exp ::= prefixexp

exp ::= nil | false | true

exp ::= Number

exp ::= String

exp ::= functiondef

exp ::= tableconstructor

exp ::= ‘...’

exp ::= exp binop exp

exp ::= unop exp

prefixexp ::= var | functioncall | ‘(’ exp ‘)’

Numbers and literal strings are explained in §3.1; variables are explained in §3.2; function definitions are

explained in §3.4.10; function calls are explained in §3.4.9; table constructors are explained in §3.4.8.

Vararg expressions, denoted by three dots ('...'), can only be used when directly inside a vararg

function; they are explained in §3.4.10.

Binary operators comprise arithmetic operators (see §3.4.1), relational operators (see §3.4.3), logical

operators (see §3.4.4), and the concatenation operator (see §3.4.5). Unary operators comprise the unary

minus (see §3.4.1), the unary not (see §3.4.4), and the unary length operator (see §3.4.6).

Both function calls and vararg expressions can result in multiple values. If a function call is used as a

statement (see §3.3.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 expression 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.)

3.4.1 – Arithmetic Operators

Lua supports the usual arithmetic operators: the binary + (addition), - (subtraction), * (multiplication), /

(division), % (modulo), and ^ (exponentiation); and unary - (mathematical negation). If the operands are

numbers, or strings that can be converted to numbers (see §3.4.2), 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.

3.4.2 – Coercion

Lua provides automatic conversion between string and number values at run time. Any arithmetic

operation applied to a string tries to convert this string to a number, following the rules of the Lua lexer.

(The string may have leading and trailing spaces and a sign.) Conversely, whenever a number is used

where a string is expected, the number is converted to a string, in a reasonable format. For complete

control over how numbers are converted to strings, use the format function from the string library (see

string.format).

3.4.3 – Relational Operators

The relational operators in Lua are

== ~= < > <= >=

These operators always result in false or true.

Equality (==) first compares the type of its operands. If the types are different, then the result is false.

Otherwise, the values of the operands are compared. Numbers and strings are compared in the usual

way. Tables, userdata, and threads are compared by reference: two objects are considered equal only if

they are the same object. Every time you create a new object (a table, userdata, or thread), this new

object is different from any previously existing object. Closures with the same reference are always

equal. Closures with any detectable difference (different behavior, different definition) are always

different.

You can change the way that Lua compares tables and userdata by using the "eq" metamethod (see

§2.4).

The conversion rules of §3.4.2 do not apply to equality comparisons. Thus, "0"==0 evaluates to false,

and t[0] and t["0"] denote different entries in a table.

The operator ~= is exactly the negation of equality (==).

The order operators work as follows. If both arguments are numbers, then they are compared as such.

Otherwise, if both arguments are strings, then their values are compared according to the current locale.

Otherwise, Lua tries to call the "lt" or the "le" metamethod (see §2.4). A comparison a > b is translated

to b < a and a >= b is translated to b <= a.

3.4.4 – Logical Operators

The logical operators in Lua are and, or, and not. Like the control structures (see §3.3.4), all logical

operators consider both false and nil as false and anything else as true.

The negation operator not always returns false or true. The conjunction operator and returns its first

argument if this value is false or nil; otherwise, and returns its second argument. The disjunction

operator or returns its first argument if this value is different from nil and false; otherwise, or returns its

second argument. Both and and or use short-cut evaluation; that is, the second operand is evaluated

only if necessary. Here are some examples:

10 or 20 --> 10

10 or error() --> 10

nil or "a" --> "a"

nil and 10 --> nil

false and error() --> false

false and nil --> false

false or nil --> nil

10 and 20 --> 20

(In this manual, --> indicates the result of the preceding expression.)

3.4.5 – Concatenation

The string concatenation operator in Lua is denoted by two dots ('..'). If both operands are strings or

numbers, then they are converted to strings according to the rules mentioned in §3.4.2. Otherwise, the

__concat metamethod is called (see §2.4).

3.4.6 – The Length Operator

The length operator is denoted by the unary prefix operator #. The length of a string is its number of

bytes (that is, the usual meaning of string length when each character is one byte).

A program can modify the behavior of the length operator for any value but strings through the __len

metamethod (see §2.4).

Unless a __len metamethod is given, the length of a table t is only defined if the table is a sequence,

that is, the set of its positive numeric keys is equal to {1..n} for some integer n. In that case, n is its

length. Note that a table like

{10, 20, nil, 40}

is not a sequence, because it has the key 4 but does not have the key 3. (So, there is no n such that the

set {1..n} is equal to the set of positive numeric keys of that table.) Note, however, that non-numeric keys

do not interfere with whether a table is a sequence.

3.4.7 – Precedence

Operator precedence in Lua follows the table below, from lower to higher priority:

and

< > <= >= ~= ==

+ -

* / %

not # - (unary)

As usual, you can use parentheses to change the precedences of an expression. The concatenation

('..') and exponentiation ('^') operators are right associative. All other binary operators are left

associative.

3.4.8 – Table Constructors

Table constructors are expressions that create tables. Every time a constructor is evaluated, a new table

is created. A constructor can be used to create an empty table or to create a table and initialize some of

its fields. The general syntax for constructors is

tableconstructor ::= ‘{’ [fieldlist] ‘}’

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

field ::= ‘[’ exp ‘]’ ‘=’ exp | Name ‘=’ exp | exp

fieldsep ::= ‘,’| ‘;’

Each field of the form [exp1] = exp2 adds to the new table an entry with key exp1 and value exp2. A

field of the form name = exp is equivalent to ["name"] = exp. Finally, fields of the form exp are

剩余87页未读，继续阅读

程序员猪猪侠

粉丝: 24
资源: 14

Lua5.2参考手册：深入解析与应用

lua5.2全中文参考手册

lua5.2中文参考手册-完整翻译.rar

lua5.2中文参考手册（高清）

lua5.2中文参考手册.zip

Lua 5.2 参考手册：轻量级可嵌入式脚本语言

Lua 5.2 Reference Manual(Lua 5.2引用指南)

lua中文参考手册 中文教程pdf版本

lua 5.2 source

Lua5.2源码

Laravel 5.2参考手册

最新资源

lua中文参考手册中文教程pdf版本