Lua5.1参考手册：扩展编程语言与脚本解决方案

Lua

需积分: 10 147 浏览量更新于2024-07-20 收藏 334KB PDF 举报

身份认证购VIP最低享 7 折!

领优惠券(最高得80元）

"Lua5.1参考手册，由Roberto Ierusalimschy, Luiz Henriquede Figueiredo, Waldemar Celes编写，版权归属2006-2008年的Lua.org和PUC-Rio，遵循Lua许可协议。" Lua是一种通用的扩展编程语言，其设计目标是支持过程化编程、数据描述特性，并提供了面向对象编程、函数式编程以及数据驱动编程的良好支持。Lua作为一个轻量级的脚本语言，适用于任何需要内嵌脚本功能的程序，如游戏引擎、服务器应用等。 Lua的核心实现是一套用纯净C语言（即C与C++的公共子集）编写的库。作为扩展语言，Lua没有“主程序”的概念，它工作在宿主客户端中，这个宿主程序可以调用函数执行Lua代码，读写Lua变量，并注册C函数供Lua代码调用。这种机制使得Lua能够与宿主程序紧密集成，提供高度定制的编程体验。通过使用C函数，Lua可以被扩展以处理各种不同的领域问题，从而创建出适应特定需求的定制化编程语言。例如，你可以定义新的数据类型、操作符，甚至是新的编程范式。Lua的这种灵活性使得它能够在许多领域中发挥重要作用，包括但不限于游戏开发、系统配置、网络编程和科学计算。 Lua的语法简洁明了，易于学习和使用。它的核心特性包括： 1. 变量：Lua支持动态类型，这意味着变量的类型可以根据赋值自动改变。它有多种内置类型，如数字、字符串、布尔值、表（用于实现数组和关联数组）、函数、线程以及nil（表示空或不存在的值）。 2. 表：表是Lua的核心数据结构，可以视为关联数组，支持数字索引和字符串键。表可以用来实现数组、集合、哈希表、类等概念。 3. 函数：Lua中的函数是第一类公民，可以作为参数传递，也可以作为返回值。函数可以使用局部变量，支持闭包和递归。 4. 模块：Lua支持模块化编程，允许将代码组织成独立的模块，通过require函数导入和使用。 5. 错误处理：Lua使用异常处理机制，通过pcall函数来捕获和处理运行时错误。 6. 脚本控制：Lua可以嵌入到其他程序中，宿主程序可以通过luaL_dostring或luaL_dofile等接口执行Lua代码。 7. 内存管理：Lua负责内存的分配和释放，程序员无需直接管理内存，这降低了内存泄漏的风险。 8. 轻量级：Lua的源代码体积小，运行效率高，适合嵌入到资源有限的环境中。 Lua5.1参考手册是学习和理解Lua语言的重要资源，涵盖了语言的所有核心概念、语法、库函数和API，对于开发者来说，它是编写高效、灵活和可扩展的嵌入式脚本的必备工具。无论是初学者还是经验丰富的程序员，都能从中受益匪浅。

资源详情

资源推荐

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页未读，继续阅读

ShuLanguhS

粉丝: 6
资源: 13

Lua5.1参考手册：扩展编程语言与脚本解决方案

lua 参考手册

lua参考手册和lua常用函数

lua 5.3中文手册

请给我推荐学习Lua的链接？

esp8266 LUA

stm32f103zet6_lua.rar

lua 74h164八位数码管

lua语言是怎么解决鼠标移动的问题

使用ESP8266等独立的WiFi模块进行开发

现有一个蓝牙JDY-31模块与一个pic32mx130f128l单片机，要求实现uart连接并能通过命令控制单片机的rg3

another+redis+desktop+mannager

esp8266 开发资料

SMART200导入库文件

clion2022.1配置git的方法

请基于寄存器编程设置，设置P1口1,3,5为输出模式，默认输出电平为低电平。 设置P2口2,4,6口为输出模式，默认输出电平为高电平

QYR2024-2030全球及中国机载光电吊舱行业研究及十五五规划分析报告 wugege.pdf

KLite 是嵌入式操作系统内核，并以MIT协议开放源代码

Avatar_Utils-1.4.0-py3-none-any.whl.zip

全球与中国合同餐饮市场现状及未来发展趋势（2024版）.docx

qt框架的概要介绍与分析

最新资源

请基于寄存器编程设置，设置P1口1,3,5为输出模式，默认输出电平为低电平。设置P2口2,4,6口为输出模式，默认输出电平为高电平