Lua 5.1编程参考手册：脚本语言扩展与应用

5星 · 超过95%的资源需积分: 10 98 浏览量更新于2023-03-16 3 收藏 334KB PDF 举报

"Lua 5.1 Reference Manual.pdf 是一本详细介绍 Lua 5.1 版本编程语言的官方参考手册，由 Roberto Ierusalimschy、Luiz Henrique de Figueiredo 和 Waldemar Celes 联合编写。该手册在 2006-2008 年间由 Lua.org 和 PUC-Rio 发布，并遵循 Lua 许可协议，供自由使用。手册包含了多种语言版本，如英文、葡萄牙语和西班牙语。" Lua 5.1 是一种轻量级的脚本语言，设计用于支持通用过程化编程和数据描述功能。它还具备面向对象编程、函数式编程以及数据驱动编程的良好支持。Lua 实现为一个 C 语言编写的库，兼容 ANSI C 和 C++ 的子集，因此可以在各种平台上方便地嵌入到宿主程序中。作为一门扩展语言，Lua 没有“主”程序的概念，它的运行依赖于一个宿主程序（embedding program）。宿主程序可以调用 Lua 函数执行 Lua 代码，读写 Lua 变量，还可以注册 C 函数以便被 Lua 代码调用。这种灵活性使得 Lua 可以根据需求扩展，适应不同的领域，创建出定制化的编程语言。手册中的内容可能包括以下几个方面： 1. **基础语法**：涵盖 Lua 的基本语法结构，如变量声明、赋值、控制流（条件语句、循环）、函数定义等。 2. **表（Table）**：Lua 的核心数据结构，可以用于实现数组、哈希表、对象等多种用途。 3. **元表（Metatables）**：允许用户自定义操作符行为，实现动态类型系统和面向对象特性。 4. **环境（Environment）**：Lua 中的全局变量实际上存储在一个特殊的表中，称为环境。 5. **C API**：描述了如何使用 C 语言编写与 Lua 交互的函数，包括创建和注册 C 函数、调用 Lua 函数、操作 Lua 堆栈等。 6. **垃圾收集**：Lua 自带自动垃圾回收机制，管理内存的分配和释放。 7. **模块（Modules）**：如何组织和加载代码模块，实现代码复用。 8. **错误处理**：关于异常和错误处理的机制。 9. **调试**：支持调试工具的接口和使用方法。 10. **标准库**：介绍 Lua 标准库提供的函数和功能，如字符串处理、数学运算、日期时间等。通过深入学习 Lua 5.1 Reference Manual，开发者可以全面理解 Lua 5.1 的特性和用法，从而有效地将 Lua 集成到他们的应用程序中，提升软件的可扩展性和易用性。

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

页码，12

73(W)w

2011-01-07http://www.lua.or

/manual/5.1/manual.html

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.

页码，13

73(W)w

2011-01-07http://www.lua.or

/manual/5.1/manual.html

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

页码，14

73(W)w

2011-01-07http://www.lua.or

/manual/5.1/manual.html

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

 "len": the # operation.

function len_event (op)

if type(op) == "string" then

return strlen(op) -- primitive string length

elseif type(op) == "table" then

return #op -- primitive table length

else

local h = metatable(op).__len

if h then

-- call the handler with the operand

return (h(op))

else -- no handler available: default behavior

error(···)

end

See §2.5.5 for a description of the length of a table.

 "eq": the == operation. The function getcomphandler defines how Lua chooses a metamethod for

comparison operators. A metamethod only is selected when both objects being compared have the

same type and the same metamethod for the selected operation.

function getcomphandler (op1, op2, event)

if type(op1) ~= type(op2) then return nil end

local mm1 = metatable(op1)[event]

local mm2 = metatable(op2)[event]

if mm1 == mm2 then return mm1 else return nil end

end

The "eq" event is defined as follows:

function eq_event (op1, op2)

if type(op1) ~= type(op2) then -- different types?

return false -- different objects

end

if op1 == op2 then -- primitive equal?

return true -- objects are equal

end

-- try metamethod

local h = getcomphandler(op1, op2, "__eq")

if h then

return (h(op1, op2))

else

return false

end

页码，15

73(W)w

2011-01-07http://www.lua.or

/manual/5.1/manual.html

剩余72页未读，继续阅读

sunsongshan0711

粉丝: 0
资源: 4

Lua 5.1编程参考手册：脚本语言扩展与应用

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

Lua 5.1 Reference Manual（pdf版）

Lua 5.1.4 reference manual(参考文档)

lua5.1中有math.floor这个函数吗

lua-5.1.dll 启动崩溃

易语言 lua5.1支持库

error while loading shared libraries: libluajit-5.1.so.2: cannot open shared object file: No such file or directory

lua 5.1 lib静态库

lua-5.1.dll 还需要其他什么库吗

lua5.1和lua5.2有什么区别

最新资源

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