Lua 5.1官方手册PDF版：轻量级脚本语言详解

需积分: 10 38 浏览量更新于2024-07-24 收藏 2.79MB PDF 举报

Lua 5.1 Reference Manual 是一本由 Roberto Ierusalimschy、Luiz Henriquede Figueiredo 和 Waldemar Celes 合著的官方文档，版权日期为2006年至2008年。该手册是基于 Lua 语言版本5.1的详细参考指南，它以PDF格式提供，旨在帮助学习者深入理解和掌握这款强大的轻量级脚本语言。Lua的设计初衷是为了支持多种编程范式，包括但不限于通用过程编程、面向对象编程、函数式编程以及数据驱动编程。 Lua作为一种扩展性编程语言，其核心特性在于其作为嵌入式语言的模式，这意味着没有传统的“main”程序概念。它主要用于嵌入到其他应用程序（称为“宿主”或“客户端”），如C或C++程序，以执行Lua代码。宿主程序可以调用Lua函数，操作Lua变量，并注册C函数供Lua调用。这种设计使得Lua能够与各种不同的应用领域紧密结合，通过C接口实现定制化的编程语言，共享一致的语法框架。在Lua 5.1 Reference Manual中，读者可以找到以下主要内容： 1. **简介**：这部分介绍了Lua语言的总体理念、目标和设计原则，强调其灵活性和高效性，适合用于需要脚本语言的程序中。 2. **语言结构**：涵盖Lua的基本语法，如变量、数据类型（如数字、字符串、表）、控制结构（循环、条件语句）和函数定义等。 3. **表和集合**：Lua的核心数据结构，包括基本表的创建、操作和遍历，以及更复杂的集合和多维数组。 4. **函数和闭包**：Lua的高阶函数和闭包功能，这对于函数式编程的支持至关重要。 5. **错误处理**：如何捕获和处理Lua运行时的错误，确保程序的健壮性。 6. **C API**：详细说明了Lua如何与C环境交互，包括如何嵌入Lua代码、调用C函数以及管理内存等。 7. **性能和优化**：讨论Lua的性能特点，以及如何通过优化代码来提高执行效率。 8. **安全性**：涉及如何限制Lua代码的访问权限，确保宿主程序的安全。 9. **模块和包**：Lua模块系统的设计，包括如何组织和加载模块，以支持代码复用和模块化开发。 10. **附录**：包含了Lua的命令行解释器、内置函数列表以及与其他语言的接口信息等实用参考资料。通过阅读Lua 5.1 Reference Manual，无论是初学者还是经验丰富的开发者，都能深入了解并熟练运用Lua语言进行高效、灵活的编程。

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, ... --> (nothing)

g(3, 4) a=3, b=4, ... --> (nothing)

g(3, 4, 5, 8) a=3, b=4, ... --> 5 8

g(5, r()) a=5, b=1, ... --> 2 3

Results are returned using the return statement (see §2.4.4). If control reaches the end of a function without

encountering a return statement, then the function returns with no results.

The colon syntax is used for defining methods, that is, functions that have an implicit extra parameter

self

Thus, the statement

function t.a.b.c:f (params) body end

is syntactic sugar for

t.a.b.c.f = function (self, params) body end

2.6 - Visibility Rules

Lua is a lexically scoped language. The scope of variables begins at the first statement after their

declaration and lasts until the end of the innermost block that includes the declaration. Consider the

following example:

x = 10 -- global variable

do -- new block

local x = x -- new 'x', with value 10

print(x) --> 10

x = x+1

do -- another block

local x = x+1 -- another 'x'

print(x) --> 12

end

print(x) --> 11

end

print(x) --> 10 (the global one)

Notice that, in a declaration like

local x = x

, the new

being declared is not in scope yet, and so the

second

refers to the outside variable.

Because of the lexical scoping rules, local variables can be freely accessed by functions defined inside their

scope. A local variable used by an inner function is called an upvalue, or external local variable, inside the

inner function.

Notice that each execution of a local statement defines new local variables. Consider the following

example:

a = {}

local x = 20

for i=1,10 do

local y = 0

a[i] = function () y=y+1; return x+y end

end

The loop creates ten closures (that is, ten instances of the anonymous function). Each of these closures

uses a different

variable, while all of them share the same

2.7 - Error Handling

Because Lua is an embedded extension language, all Lua actions start from C code in the host program

calling a function from the Lua library (see

lua_pcall

). Whenever an error occurs during Lua compilation or

execution, control returns to C, which can take appropriate measures (such as printing an error message).

Lua code can explicitly generate an error by calling the

error

function. If you need to catch errors in Lua,

you can use the

pcall

function.

2.8 - Metatables

Every value in Lua can have a metatable. This metatable is an ordinary Lua table that defines the behavior

of the original value under certain special operations. You can change several aspects of the behavior of

operations over a value by setting specific fields in its metatable. For instance, when a non-numeric value is

the operand of an addition, Lua checks for a function in the field

"__add"

in its metatable. If it finds one, Lua

calls this function to perform the addition.

We call the keys in a metatable events and the values metamethods. In the previous example, the event is

"add"

and the metamethod is the function that performs the addition.

You can query the metatable of any value through the getmetatable function.

You can replace the metatable of tables through the

setmetatable

function. You cannot change the

metatable of other types from Lua (except by using the debug library); you must use the C API for that.

Tables and full userdata have individual metatables (although multiple tables and userdata can share their

metatables). Values of all other types share one single metatable per type; that is, there is one single

metatable for all numbers, one for all strings, etc.

A metatable controls how an object behaves in arithmetic operations, order comparisons, concatenation,

length operation, and indexing. A metatable also can define a function to be called when a userdata is

garbage collected. For each of these operations Lua associates a specific key called an event. When Lua

performs one of these operations over a value, it checks whether this value has a metatable with the

corresponding event. If so, the value associated with that key (the metamethod) controls how Lua will

perform the operation.

Metatables control the operations listed next. Each operation is identified by its corresponding name. The

key for each operation is a string with its name prefixed by two underscores, '

'; for instance, the key for

operation "add" is the string

"__add"

. The semantics of these operations is better explained by a Lua

function describing how the interpreter executes the operation.

The code shown here in Lua is only illustrative; the real behavior is hard coded in the interpreter and it is

much more efficient than this simulation. All functions used in these descriptions (

rawget

tonumber

, etc.)

are described in §5.1. In particular, to retrieve the metamethod of a given object, we use the expression

metatable(obj)[event]

This should be read as

rawget(getmetatable(obj) or {}, event)

That is, the access to a metamethod does not invoke other metamethods, and the access to objects with no

metatables does not fail (it simply results in nil).

"add": the

operation.

The function

getbinhandler

below defines how Lua chooses a handler for a binary operation. First,

Lua tries the first operand. If its type does not define a handler for the operation, then Lua tries the

second operand.

function getbinhandler (op1, op2, event)

return metatable(op1)[event] or metatable(op2)[event]

end

By using this function, the behavior of the

op1 + op2

function add_event (op1, op2)

local o1, o2 = tonumber(op1), tonumber(op2)

if o1 and o2 then -- both operands are numeric?

return o1 + o2 -- '+' here is the primitive 'add'

else -- at least one of the operands is not numeric

local h = getbinhandler(op1, op2, "__add")

if h then

-- call the handler with both operands

return (h(op1, op2))

else -- no handler available: default behavior

error(···)

end

l "sub": the

operation. Behavior similar to the "add" operation.

l "mul": the * operation. Behavior similar to the "add" operation.

"div": the

operation. Behavior similar to the "add" operation.

"mod": the

operation. Behavior similar to the "add" operation, with the operation

o1 - floor(o1/o2)

*o2

as the primitive operation.

"pow": the

(exponentiation) operation. Behavior similar to the "add" operation, with the function

pow

(from the C math library) as the primitive operation.

"unm": the unary

operation.

function unm_event (op)

local o = tonumber(op)

if o then -- operand is numeric?

return -o -- '-' here is the primitive 'unm'

else -- the operand is not numeric.

-- Try to get a handler from the operand

local h = metatable(op).__unm

if h then

-- call the handler with the operand

return (h(op))

else -- no handler available: default behavior

error(···)

end

"concat": the

(concatenation) operation.

function concat_event (op1, op2)

if (type(op1) == "string" or type(op1) == "number") and

(type(op2) == "string" or type(op2) == "number") then

return op1 .. op2 -- primitive string concatenation

else

local h = getbinhandler(op1, op2, "__concat")

if h then

return (h(op1, op2))

else

error(···)

end

剩余75页未读，继续阅读

iwoyiluxiangbei

粉丝: 1
资源: 4

Lua 5.1官方手册PDF版：轻量级脚本语言详解

Lua 5.1编程参考手册：扩展与应用

Lua 5.1 官方参考手册：脚本编程与扩展指南

Lua编程指南第二版：更新至Lua 5.1

Lua 5.1 Reference Manual.pdf

Lua 5.1 Reference Manual

Lua 5.1 Reference Manual 用户手册

lua-5.1 Reference Manual 中文手册 备用文档,仅做学习使用

Lua_5.1_Reference_Manual

Lua 5.2 Reference Manual(hacked)英文原版

Lua 5.0 Reference Manual(Revision 1.0) - ZIP

最新资源

lua-5.1 Reference Manual 中文手册备用文档,仅做学习使用