lua编程第四版：从基础到实践

3星 · 超过75%的资源需积分: 31 99 浏览量更新于2024-07-16 收藏 895KB PDF 举报

《编程在Lua：第四版》(Programming in Lua, Fourth Edition)，作者是罗伯托·伊尔萨拉姆斯基(Roberto Ierusalimschy)，于2016年首次出版。这本书是针对Lua语言的专业教材，适合那些希望深入理解并学习这门轻量级脚本语言的开发者。Lua以其简洁的语法和强大的功能在游戏开发、嵌入式系统、Web应用等领域受到欢迎。本书分为多个章节，首先介绍了基础概念，包括如何开始编写Lua代码（Getting Started），以及Lua中的数据结构和基本语法。章节中涵盖了“块”(Chunks)的概念，以及一些关键的词汇约定，如全局变量和它们的数据类型。Lua中的特殊值，如-nil和布尔值，以及如何使用内置的解释器进行交互。第二章插入了一个插曲——八皇后问题，通过实际问题来帮助读者理解 Lua 的逻辑思维。接下来，数字处理部分详细阐述了数值表示法、算术运算符、比较运算符以及Lua数学库的功能，比如随机数生成和数值精度处理。字符串处理是编程的重要组成部分，书中讲解了字符串的两种形式（字面字符串和长字符串）、强制类型转换和Lua的字符串库，包括Unicode字符集的支持。了解如何处理和操作字符串是Lua编程的基础。表格（Tables）是Lua的核心数据结构，包括索引方式、构造方法、数组和列表的使用，以及遍历和安全访问表的方法。此外，还介绍了Lua函数的高级特性，如多返回值、可变参数函数和`table.unpack`函数的作用。深入到函数设计，书中探讨了如何实现多个结果返回、尾递归优化等技巧。而第7章则聚焦于Lua与外部环境的交互，包括其简单的输入/输出模型，这对于在不同环境中集成Lua脚本至关重要。《Programming in Lua, Fourth Edition》是一本全面而深入的教程，无论是初次接触Lua的初学者，还是已有一定经验的开发者，都能从中收获丰富的知识和实践经验。通过阅读这本书，读者可以掌握Lua语言的核心原理和实践应用，为自己的编程生涯增添新的工具和视角。

Chapter 1. Getting Started

To keep with tradition, our first program in Lua just prints "Hello World":

print("Hello World")

If you are using the stand-alone Lua interpreter, all you have to do to run your first program is to call the

interpreter —usually named lua or lua5.3— with the name of the text file that contains your program.

If you save the above program in a file hello.lua, the following command should run it:

% lua hello.lua

As a more complex example, the next program defines a function to compute the factorial of a given

number, asks the user for a number, and prints its factorial:

-- defines a factorial function

function fact (n)

if n == 0 then

return 1

else

return n * fact(n - 1)

end

print("enter a number:")

a = io.read("*n") -- reads a number

print(fact(a))

Chunks

We call each piece of code that Lua executes, such as a file or a single line in interactive mode, a chunk.

A chunk is simply a sequence of commands (or statements).

A chunk can be as simple as a single statement, such as in the “Hello World” example, or it can be composed

of a mix of statements and function definitions (which are actually assignments, as we will see later), such

as the factorial example. A chunk can be as large as we wish. Because Lua is used also as a data-description

language, chunks with several megabytes are not uncommon. The Lua interpreter has no problems at all

with large chunks.

Instead of writing your program to a file, you can run the stand-alone interpreter in interactive mode. If

you call lua without any arguments, you will get its prompt:

% lua

Thereafter, each command that you type (such as print "Hello World") executes immediately after

you enter it. To exit the interactive mode and the interpreter, just type the end-of-file control character

(ctrl-D in POSIX, ctrl-Z in Windows), or call the function os.exit, from the Operating System

library —you have to type os.exit().

Starting in version 5.3, we can enter expressions directly in the interactive mode, and Lua will print their

values:

Getting Started

% lua

> math.pi / 4 --> 0.78539816339745

> a = 15

> a^2 --> 225

> a + 2 --> 17

In older versions, we need to precede these expressions with an equals sign:

% lua5.2

> a = 15

> = a^2 --> 225

For compatibility, Lua 5.3 still accepts these equals signs.

To run that code as a chunk (not in interactive mode), we must enclose the expressions inside calls to

print:

print(math.pi / 4)

a = 15

print(a^2)

print(a + 2)

Lua usually interprets each line that we type in interactive mode as a complete chunk or expression. How-

ever, if it detects that the line is not complete, it waits for more input, until it has a complete chunk. This

way, we can enter a multi-line definition, such as the factorial function, directly in interactive mode. How-

ever, it is usually more convenient to put such definitions in a file and then call Lua to run the file.

We can use the -i option to instruct Lua to start an interactive session after running a given chunk:

% lua -i prog

A command line like this one will run the chunk in the file prog and then prompt for interaction. This is

especially useful for debugging and manual testing. At the end of this chapter, we will see other options

for the stand-alone interpreter.

Another way to run chunks is with the function dofile, which immediately executes a file. For instance,

suppose we have a file lib1.lua with the following code:

function norm (x, y)

return math.sqrt(x^2 + y^2)

end

function twice (x)

return 2.0 * x

end

Then, in interactive mode, we can type this code:

> dofile("lib1.lua") -- load our library

> n = norm(3.4, 1.0)

> twice(n) --> 7.0880180586677

The function dofile is useful also when we are testing a piece of code. We can work with two windows:

one is a text editor with our program (in a file prog.lua, say) and the other is a console running Lua

Getting Started

in interactive mode. After saving a modification in our program, we execute dofile("prog.lua")

in the Lua console to load the new code; then we can exercise the new code, calling its functions and

printing the results.

Some Lexical Conventions

Identifiers (or names) in Lua can be any string of letters, digits, and underscores, not beginning with a

digit; for instance

i j i10 _ij

aSomewhatLongName _INPUT

You should avoid identifiers starting with an underscore followed by one or more upper-case letters (e.g.,

_VERSION); they are reserved for special uses in Lua. Usually, I reserve the identifier _ (a single under-

score) for dummy variables.

The following words are reserved; we cannot use them as identifiers:

and break do else elseif

end false for function goto

if in local nil not

or repeat return then true

until while

Lua is case-sensitive: and is a reserved word, but And and AND are two different identifiers.

A comment starts anywhere with two consecutive hyphens (--) and runs until the end of the line. Lua

also offers long comments, which start with two hyphens followed by two opening square brackets and

run until the first occurrence of two consecutive closing square brackets, like here:

--[[A multi-line

long comment

]]

A common trick that we use to comment out a piece of code is to enclose the code between --[[ and

--]], like here:

--[[

print(10) -- no action (commented out)

--]]

To reactivate the code, we add a single hyphen to the first line:

---[[

print(10) --> 10

--]]

In the first example, the --[[ in the first line starts a long comment, and the two hyphens in the last line

are still inside that comment. In the second example, the sequence ---[[ starts an ordinary, single-line

comment, so that the first and the last lines become independent comments. In this case, the print is

outside comments.

Lua needs no separator between consecutive statements, but we can use a semicolon if we wish. Line

breaks play no role in Lua's syntax; for instance, the following four chunks are all valid and equivalent:

Long comments can be more complex than that, as we will see in the section called “Long strings”.

Getting Started

Variables have no predefined types; any variable can contain values of any type:

> type(a) --> nil ('a' is not initialized)

> a = 10

> type(a) --> number

> a = "a string!!"

> type(a) --> string

> a = nil

> type(a) --> nil

Usually, when we use a single variable for different types, the result is messy code. However, sometimes

the judicious use of this facility is helpful, for instance in the use of nil to differentiate a normal return

value from an abnormal condition.

We will discuss now the simple types nil and Boolean. In the following chapters, we will discuss in detail

the types number (Chapter 3, Numbers), string (Chapter 4, Strings), table (Chapter 5, Tables), and function

(Chapter 6, Functions). We will explain the thread type in Chapter 24, Coroutines, where we discuss

coroutines.

Nil

Nil is a type with a single value, nil, whose main property is to be different from any other value. Lua uses

nil as a kind of non-value, to represent the absence of a useful value. As we have seen, a global variable

has a nil value by default, before its first assignment, and we can assign nil to a global variable to delete it.

Booleans

The Boolean type has two values, @false{} and @true{}, which represent the traditional Boolean values.

However, Booleans do not hold a monopoly of condition values: in Lua, any value can represent a con-

dition. Conditional tests (e.g., conditions in control structures) consider both the Boolean false and nil

as false and anything else as true. In particular, Lua considers both zero and the empty string as true in

conditional tests.

Throughout this book, I will write “false” to mean any false value, that is, the Boolean false or nil. When

I mean specifically the Boolean value, I will write “false”. The same holds for “true” and “true”.

Lua supports a conventional set of logical operators: and, or, and not. Like control structures, all logical

operators consider both the Boolean false and nil as false, and anything else as true. The result of the and

operator is its first operand if that operand is false; otherwise, the result is its second operand. The result

of the or operator is its first operand if it is not false; otherwise, the result is its second operand:

> 4 and 5 --> 5

> nil and 13 --> nil

> false and 13 --> false

> 0 or 5 --> 0

> false or "hi" --> "hi"

> nil or false --> false

Both and and or use short-circuit evaluation, that is, they evaluate their second operand only when nec-

essary. Short-circuit evaluation ensures that expressions like (i ~= 0 and a/i > b) do not cause

run-time errors: Lua will not try to evaluate a / i when i is zero.

A useful Lua idiom is x = x or v, which is equivalent to

if not x then x = v end

剩余307页未读，继续阅读

antyrao2

粉丝: 0
资源: 2

lua编程第四版：从基础到实践

Lua程序设计（第四版）

lua程序设计.pdf

Lua程序设计.pdf_lua_nginx_

Programming_In_Lua.pdf

Programming.in.Lua.4th.Edition.Lua程序设计.第4版

cjson.rar_LUA JSON_cjson_cjson.lua_lua_piledxg

Programming.in.Lua.4th.Edition.2016.8.epub

Lua_5.3_manual.pdf与Programming in Lua.pdf

LUA-JS.zip_js lua.js_js调用 lua_lua JavaScript_lua调用js_lua转js

use_Lua.rar_c++ lua_lua_lua C++ 嵌入_lua vc

最新资源