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

3星 · 超过75%的资源需积分: 9 181 浏览量更新于2024-07-30 收藏 296KB PDF 举报

"Lua 5.1 Reference Manual 是一本官方的Lua语言参考手册，PDF格式，由Roberto Ierusalimschy、Luiz Henrique de Figueiredo和Waldemar Celes共同编著。该手册版权归属2006-2008年的Lua.org和PUC-Rio，根据Lua许可证免费提供。内容涵盖英文、葡萄牙文和西班牙文版本的索引和目录。" 在《Lua 5.1 Reference Manual》中，你可以深入学习以下关键知识点： 1. **Lua简介**：Lua是一种支持通用过程编程和数据描述功能的扩展编程语言。它提供了面向对象编程、函数式编程以及数据驱动编程的良好支持。作为脚本语言，Lua设计用于为任何需要它的程序提供强大且轻量级的解决方案。 2. **实现与结构**：Lua是作为一个库实现的，用纯净的C语言编写（即，兼容ANSI C和C++的子集）。这意味着它可以在多种平台上轻松集成到其他应用中。 3. **嵌入式使用**：与其他拥有独立“主”程序的语言不同，Lua被设计为嵌入式语言，运行在主机程序（或称宿主程序）内。主机程序可以调用函数执行Lua代码，读写Lua变量，并注册C函数供Lua代码调用。 4. **交互性**：通过C函数接口，Lua能够扩展其功能，适应各种不同的领域。这使得开发者可以根据需求创建定制化的编程语言，共享相同的语法和基础结构。 5. **编程模型**：Lua的核心特性包括动态类型、垃圾回收机制、轻量级的表（用于数据结构和类模拟）、第一类函数（可作为值传递和存储的函数）以及模块系统。 6. **控制结构**：Lua支持条件语句（if-then-else）、循环（while、for）、以及基于块的结构，使其代码简洁而灵活。 7. **函数和变量**：Lua中的函数定义是匿名的，可以作为参数传递，也可以作为返回值。局部变量和全局变量的管理简单明了，且支持赋值操作。 8. **表（Table）**：表是Lua的主要数据结构，可以用来表示数组、集合、哈希映射、记录等。它们的灵活性使Lua能够实现多种编程范式。 9. **元表和元方法**：Lua允许通过元表来改变基本操作的行为，如索引和比较，从而实现面向对象编程的特性。 10. **模块和包**：Lua的模块系统允许将代码组织成独立的单元，便于重用和隔离。 11. **错误处理**：Lua通过异常处理机制（try-catch-finally）来处理运行时错误。 12. **标准库**：Lua的标准库包含了各种实用函数，如字符串和数学操作，以及文件I/O。通过阅读这本手册，开发者不仅可以了解Lua 5.1的语法和特性，还能学习如何在实际项目中有效地利用这些特性，实现高效、灵活的脚本解决方案。

Parameters act as local variables that are initialized with the argument values:

parlist ::= namelist [`,´ `...´] | `...´

When a function is called, the list of arguments is adjusted to the length of the list of parameters, unless the

function is a variadic or vararg function, which is indicated by three dots ('

...') at the end of its parameter

list. A vararg function does not adjust its argument list; instead, it collects all extra arguments and supplies

them to the function through a vararg expression, which is also written as three dots. The value of this

expression is a list of all actual extra arguments, similar to a function with multiple results. If a vararg

expression is used inside another expression or in the middle of a list of expressions, then its return list is

adjusted to one element. If the expression is used as the last element of a list of expressions, then no

adjustment is made (unless that last expression is enclosed in parentheses).

As an example, consider the following definitions:

function f(a, b) end

function g(a, b, ...) end

function r() return 1,2,3 end

Then, we have the following mapping from arguments to parameters and to the vararg expression:

CALL PARAMETERS

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, ... --> (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 x being declared is not in scope yet, and so the

second

x 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

y variable, while all of them share the same x.

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 is

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

 "sub": the - operation. Behavior similar to the "add" operation.

 "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

剩余72页未读，继续阅读

薛定谔之死猫

粉丝: 724
资源: 66

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

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

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

Lua5.1参考手册：强大的嵌入式脚本语言

Lua 5.1 Reference Manual.pdf

Lua 5.1 Reference Manual 用户手册

Lua 5.1 Reference Manual（pdf版）

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 中文手册备用文档,仅做学习使用