Lua语言的演变历程：从配置工具到广泛应用的脚本语言

需积分: 0 164 浏览量更新于2024-06-30 收藏 682KB PDF 举报

Lua的进化1 本文由罗伯托·伊尔萨鲁伊斯·奇斯齐、路易斯·埃尼基乌·德·费格雷多和瓦尔德马尔·塞莱斯三位作者共同撰写，主要探讨了Lua语言自1993年在巴西里约热内卢的 Pontifical Catholic University of Rio de Janeiro（PUC-Rio）诞生以来的发展历程。起初，Lua被设计为一种简单的配置语言，但随着时间的推移，它已经发展成为一个功能强大、广泛应用的脚本语言，支持扩展的语义、匿名函数、完整的词法作用域、属性尾递归以及协程。 1. 引言 Lua的诞生标志着脚本语言领域的一个重要里程碑，它的出现旨在简化工业应用的编程任务。早期的Lua主要用于配置和控制其他软件系统，然而其简洁的语法和灵活性使其迅速在各种领域崭露头角，包括机器人技术、文档编写（literate programming）、分布式商业应用、图像处理、可扩展文本编辑器、网络交换机、生物信息学、有限元分析软件、Web开发等。随着需求的增长和技术的进步，Lua不断进化，逐步添加了高级特性，使得它不仅能满足基础配置需求，还能进行复杂的逻辑处理和高效的程序设计。 2. 语言演进的关键特性 - **扩展的语义**：Lua的设计者意识到，为了适应不断变化的应用场景，语言必须具有丰富的内置库和模块支持，允许开发者轻松地扩展其功能。 - **匿名函数**：Lua引入了匿名函数，也称为lambda表达式，这使得代码更简洁，并且在函数式编程中发挥了重要作用，提升了代码的复用性。 - **词法作用域**：Lua采用的是完整的词法作用域规则，这意味着变量的作用范围由其在源代码中的位置而非函数定义来确定，这对于避免命名冲突和提高代码可读性非常有益。 - **属性尾递归**：Lua支持尾递归优化，这是一种优化技术，能够使递归调用看起来像循环，从而避免栈溢出问题，提高了性能。 - **协程**：作为并发编程的重要工具，Lua引入了轻量级的线程机制——协程，这使得在单个线程中实现非阻塞I/O和多任务处理成为可能，增强了其在实时系统和高性能计算环境中的应用潜力。 3. 应用领域的拓展随着Lua语言的这些核心特性不断完善，其在工业界的应用越来越广泛，不仅在传统的服务器端脚本（如PHP、Node.js）中占据一席之地，还在嵌入式设备、游戏开发、科学计算和数据处理等领域展现出了强大的适应性和效率。 4. 结论 Lua的进化是一个从配置工具到通用编程语言的成功转型，它通过不断的改进和扩展，满足了用户对高效、灵活和易扩展编程的需求。今天，Lua仍然保持着活跃的社区支持和持续的更新，证明了其作为一种高效脚本语言的持久生命力。

plementation simple and portable. Because the new language

was partially inspired by SOL (sun in Portuguese), a friend

at Tecgraf (Carlos Henrique Levy) suggested the name ‘Lua’

(moon in Portuguese), and Lua was born. (DEL did not in-

ﬂuence Lua as a language. The main inﬂuence of DEL on

the birth of Lua was rather the realization that large parts

of complex applications could be written using embeddable

scripting languages.)

We wanted a light full language with data-description fa-

cilities. So we took SOL’s syntax for record and list con-

struction (but not type declaration), and uniﬁed their imple-

mentation using tables: records use strings (the ﬁeld names)

as indices; lists use natural numbers. An assignment such as

T = @track{ y=9, x=10, id="1992-34" }

which was valid in SOL, remained valid in Lua, but with

a different meaning: it created an object (that is, a table)

with the given ﬁelds, and then called the function track on

this table to validate the object or perhaps to provide default

values to some of its ﬁelds. The ﬁnal value of the expression

was that table.

Except for its procedural data-description constructs, Lua

introduced no new concepts: Lua was created for production

use, not as an academic language designed to support re-

search in programming languages. So, we simply borrowed

(even unconsciously) things that we had seen or read about

in other languages. We did not reread old papers to remem-

ber details of existing languages. We just started from what

we knew about other languages and reshaped that according

to our tastes and needs.

We quickly settled on a small set of control structures,

with syntax mostly borrowed from Modula (while, if, and

repeat until). From CLU we took multiple assignment

and multiple returns from function calls. We regarded mul-

tiple returns as a simpler alternative to reference parameters

used in Pascal and Modula and to in-out parameters used in

Ada; we also wanted to avoid explicit pointers (used in C).

From C++ we took the neat idea of allowing a local vari-

able to be declared only where we need it. From SNOBOL

and Awk we took associative arrays, which we called tables;

however, tables were to be objects in Lua, not attached to

variables as in Awk.

One of the few (and rather minor) innovations in Lua was

the syntax for string concatenation. The natural ‘+’ operator

would be ambiguous, because we wanted automatic coer-

cion of strings to numbers in arithmetic operations. So, we

invented the syntax ‘..’ (two dots) for string concatenation.

A polemic point was the use of semicolons. We thought

that requiring semicolons could be a little confusing for en-

gineers with a Fortran background, but not allowing them

could confuse those with a C or Pascal background. In typi-

cal committee fashion, we settled on optional semicolons.

Initially, Lua had seven types: numbers (implemented

solely as reals), strings, tables, nil, userdata (pointers to

C objects), Lua functions, and C functions. To keep the lan-

guage small, we did not initially include a boolean type:

as in Lisp, nil represented false and any other value repre-

sented true. Over 13 years of continuous evolution, the only

changes in Lua types were the uniﬁcation of Lua functions

and C functions into a single function type in Lua 3.0 (1997)

and the introduction of booleans and threads in Lua 5.0

(2003) (see §6.1). For simplicity, we chose to use dynamic

typing instead of static typing. For applications that needed

type checking, we provided basic reﬂective facilities, such

as run-time type information and traversal of the global en-

vironment, as built-in functions (see §6.11).

By July 1993, Waldemar had ﬁnished the ﬁrst implemen-

tation of Lua as a course project supervised by Roberto.

The implementation followed a tenet that is now central to

Extreme Programming: “the simplest thing that could pos-

sibly work” [7]. The lexical scanner was written with lex

and the parser with yacc, the classic Unix tools for imple-

menting languages. The parser translated Lua programs into

instructions for a stack-based virtual machine, which were

then executed by a simple interpreter. The C API made it

easy to add new functions to Lua, and so this ﬁrst version

provided only a tiny library of ﬁve built-in functions (next,

nextvar, print, tonumber, type) and three small exter-

nal libraries (input and output, mathematical functions, and

string manipulation).

Despite this simple implementation — or possibly be-

cause of it — Lua surpassed our expectations. Both PGM

and ED used Lua successfully (PGM is still in use today;

ED was replaced by EDG [12], which was mostly written

in Lua). Lua was an immediate success in Tecgraf and soon

other projects started using it. This initial use of Lua at Tec-

graf was reported in a brief talk at the VII Brazilian Sympo-

sium on Software Engineering, in October 1993 [29].

The remainder of this paper relates our journey in im-

proving Lua.

5. History

Figure 1 shows a timeline of the releases of Lua. As can be

seen, the time interval between versions has been gradually

increasing since Lua 3.0. This reﬂects our perception that

1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006

1.0 1.1 2.1 2.2 2.4 2.5 3.0 3.1 3.2 4.0 5.0 5.1

Figure 1. The releases of Lua.

1.0 1.1 2.1 2.2 2.4 2.5 3.0 3.1 3.2 4.0 5.0 5.1

constructors • • • • • • • • • • • •

garbage collection • • • • • • • • • • • •

extensible semantics ◦ ◦ • • • • • • • • • •

support for OOP ◦ ◦ • • • • • • • • • •

long strings ◦ ◦ ◦ • • • • • • • • •

debug API ◦ ◦ ◦ • • • • • • • • •

external compiler ◦ ◦ ◦ ◦ • • • • • • • •

vararg functions ◦ ◦ ◦ ◦ ◦ • • • • • • •

pattern matching ◦ ◦ ◦ ◦ ◦ • • • • • • •

conditional compilation ◦ ◦ ◦ ◦ ◦ ◦ • • • ◦ ◦ ◦

anonymous functions, closures ◦ ◦ ◦ ◦ ◦ ◦ ◦ • • • • •

debug library ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ • • • •

multi-state API ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ • • •

for statement ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ • • •

long comments ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ • •

full lexical scoping ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ • •

booleans ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ • •

coroutines ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ • •

incremental garbage collection ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ •

module system ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ •

1.0 1.1 2.1 2.2 2.4 2.5 3.0 3.1 3.2 4.0 5.0 5.1

libraries 4 4 4 4 4 4 4 4 5 6 8 9

built-in functions 5 7 11 11 13 14 25 27 35 0 0 0

API functions 30 30 30 30 32 32 33 47 41 60 76 79

vm type (stack × register) S S S S S S S S S S R R

vm instructions 64 65 69 67 67 68 69 128 64 49 35 38

keywords 16 16 16 16 16 16 16 16 16 18 21 21

other tokens 21 21 23 23 23 23 24 25 25 25 24 26

Table 1. The evolution of features in Lua.

Lua was becoming a mature product and needed stability for

the beneﬁt of its growing community. Nevertheless, the need

for stability has not hindered progress. Major new versions

of Lua, such as Lua 4.0 and Lua 5.0, have been released since

then.

The long times between versions also reﬂects our release

model. Unlike other open-source projects, our alpha versions

are quite stable and beta versions are essentially ﬁnal, except

for uncovered bugs.

This release model has proved to be

good for Lua stability. Several products have been shipped

with alpha or beta versions of Lua and worked ﬁne. How-

ever, this release model did not give users much chance to

experiment with new versions; it also deprived us of timely

feedback on proposed changes. So, during the development

of Lua 5.0 we started to release “work” versions, which are

just snapshots of the current development of Lua. This move

brought our current release model closer to the “Release

Early, Release Often” motto of the open-source community.

The number of bugs found after ﬁnal versions were released has been

consistently small: only 10 in Lua 4.0, 17 in Lua 5.0, and 10 in Lua 5.1

so far, none of them critical bugs.

In the remainder of this section we discuss some mile-

stones in the evolution of Lua. Details on the evolution of

several speciﬁc features are given in §6. Table 1 summarizes

this evolution. It also contains statistics about the size of Lua,

which we now discuss brieﬂy.

The number of standard libraries has been kept small be-

cause we expect that most Lua functions will be provided by

the host application or by third-party libraries. Until Lua 3.1,

the only standard libraries were for input and output, string

manipulation, mathematical functions, and a special library

of built-in functions, which did not use the C API but directly

accessed the internal data structures. Since then, we have

added libraries for debugging (Lua 3.2), interfacing with the

operating system (Lua 4.0), tables and coroutines (Lua 5.0),

and modules (Lua 5.1).

The size of C API changed signiﬁcantly when it was re-

designed in Lua 4.0. Since then, it has moved slowly toward

completeness. As a consequence, there are no longer any

built-in functions: all standard libraries are implemented on

top the C API, without accessing the internals of Lua.

The virtual machine, which executes Lua programs, was

stack-based until Lua 4.0. In Lua 3.1 we added variants

剩余25页未读，继续阅读

XiZi

粉丝: 616
资源: 325

Lua语言的演变历程：从配置工具到广泛应用的脚本语言

lua & ngx_lua 的介绍与应用

lua实现机制

Lua脚本语言基本教程高清版

lua5.3 luaL_register

luac转lua工具

LuaDLL lua_gettop

lua源文件的lua.c和luac.c

lua编程之lua与C相互调用

lua5.3和lua5.4区别

C++怎么使用lua执行一段lua字符串代码

最新资源