Lua中文教程

第2章 值和类型

nil

一个全局变量没有被赋值以前默认值为nil；给全局变量负nil可以删除该变量

Booleans

两个取值false和true.

注：在控制结构的条件中除了false和nil为假，其他值都为真。所以Lua认为0和空串都是真。

Numbers

表示实数

Strings

Lua中字符串是不可以修改的,可以创建一个新的变量存放你要的字符串

a = "one string"
b = string.gsub(a, "one", "another") -- change string parts
print(a) --> one string
print(b) --> another string

可以使用单引号或者双引号表示字符串

a = "a line"
b = 'another line'

还可以在字符串中使用\ddd（ddd为三位十进制数字）方式表示字母。

"alo\n123\""和'\97lo\10\04923"'是相同的。

运行时，Lua会自动在string和numbers之间自动进行类型转换，当一个字符串使用算术操作符时，string就会被转成数字。

print("10" + 1) --> 11
print("10 + 1") --> 10 + 1
print("-5.3e - 10" * "2") --> -1.06e-09
print("hello" + 1) -- ERROR (cannot convert "hello")

print(10 .. 20) --> 1020

字符串和数字相互转换

print(tostring(10) == "10") --> true
print(10 .. "" == "10") --> true
print(10 == tonumber(10)) --> true

Functions

原文：函数是第一类值（和其他变量相同），意味着函数可以存储在变量中，可以作为函数的参数，也可以作为函数的返回值。这个特性给了语言很大的灵活性：一个程序可以重新定义函数增加新的功能或者为了避免运行不可靠代码创建安全运行环境而隐藏函数，此外这特性在Lua实现面向对象中也起了重要作用（在第16章详细讲述）。

Lua可以调用lua或者C实现的函数，Lua所有标准库都是用C实现的。标准库包括string库、table库、I/O库、OS库、算术库、debug库。

Userdata and Theads

原文：userdata可以将C数据存放在Lua变量中，userdata在Lua中除了赋值和相等比较外没有预定义的操作。userdata用来描述应用程序或者使用C实现的库创建的新类型。例如：用标准I/O库来描述文件。下面在C API章节中我们将详细讨论。

在第九章讨论协同操作的时候，我们介绍线程。

第3章 表达式

算数运算符

二元：+-*/^(加减乘除幂)

一元：-（负值）

操作数都是实数

关系运算符

< > <= >= == ~=

逻辑运算符

and or not

逻辑运算符认为false和nil是假（false），其他为真，0也是true.

a and b -- 如果a为false，则返回a，否则返回b
a or b -- 如果a为true，则返回a，否则返回b
and的优先级比or高。

print(4 and 5) --> 5
print(nil and 13) --> nil
print(false and 13) --> false
print(4 or 5) --> 4
print(false or 5) --> 5

C中的三目运算符
a ? b : c
在Lua中可以这样实现:
(a and b) or c

not运算符相当于C中的！（非）

连接运算符

.. --两个点

字符串连接，如果操作数为数字，Lua将数字转成字符串。

print("Hello " .. "World") --> Hello World
print(0 .. 1) --> 01

优先级

从高到低的顺序

^
not - (unary)
* /
+ -
..
< > <= >= ~= ==
and
or

表的构造

days = {}
days = {"Sunday", "Monday", "Tuesday", "Wednesday","Thursday", "Friday", "Saturday"}
print(days[4]) --> Wednesday
tab = {sin(1), sin(2), sin(3), sin(4),sin(5),sin(6), sin(7), sin(8)}
a = {x=0, y=0} <--> a = {}; a.x=0; a.y=0

w = {x=0, y=0, label="console"}
x = {sin(0), sin(1), sin(2)}
w[1] = "another field"
x.f = w
print(w["x"]) --> 0
print(w[1]) --> another field
print(x.f[1]) --> another field
w.x = nil -- remove field "x"

{x=0, y=0} <--> {["x"]=0, ["y"]=0}
{"red", "green", "blue"} <--> {[1]="red", [2]="green", [3]="blue"}
days = {[0]="Sunday", "Monday", "Tuesday", "Wednesday","Thursday", "Friday", "Saturday"}

注:不推荐数组下标从0开始，否则很多标准库不能使用。

a = {[1]="red", [2]="green", [3]="blue",} --最后的","可选，可以方便以后的扩展

{x=10, y=45; "one", "two", "three"} --通常我们使用分号用来分割不同类型的表元素

第4章 基本语法

赋值语句

a = "hello" .. "world"
t.n = t.n + 1

a, b = 10, 2*x <--> a=10; b=2*x
x, y = y, x -- swap 'x' for 'y'
a[i], a[j] = a[j], a[i] -- swap 'a[i]' for 'a[i]'

当等号左右两边变量个数不一致时

a. 变量个数>值的个数按变量个数补足nil

b. 变量个数<值的个数多余的值会被忽略

局部变量与代码块（block）

使用local创建局部变量

local i = 1  --局部变量使用规则类似C

！！！注：如果是在交互模式下，local i=1是一个完整的chunk，在交互模式下执行完这一句后，Lua将开始一个新的chunk，这样第二句的i已经超出了他的有效范围。可以将这段代码放在do..end（相当于c/c++的{}）块中。

局部变量的好处：

1. 避免命名冲突

2. 访问局部变量的速度比全局变量更快.

do
local a2 = 2*a
local d = sqrt(b^2 - 4*a*c)
x1 = (-b + d)/a2
x2 = (-b - d)/a2
end         -- scope of 'a2' and 'd' ends here
print(x1, x2)

控制结构语句

if

if conditions then
then-part
end;

if conditions then
then-part
else
else-part
end;

if conditions then
then-part
elseif conditions then
elseif-part
.. --->多个elseif
else
else-part
end;

while

while condition do
statements;
end;

repeat-until

repeat
statements;
until conditions;

数值型for

for var=exp1,exp2,step do  --step可以省略，默认为1，这三个表达式之后在循环开始前计算一次
loop-part              --控制变量var是局部变量，在循环内有效
end                        --break退出循环

范型for

-- print all values of array 'a'
for i,v in ipairs(a) do
print(v)
end

-- print all keys of table 't'
for k in pairs(t) do
print(k)
end

break和return

与C中关键字用法相同

第5章 函数

lua中当函数只有一个参数并且这个参数是字符串或者表构造的时候，()是可选的：

print "Hello World"            <--> print("Hello World")
dofile 'a.lua'                 <--> dofile ('a.lua')
print [[a multi-line message]] <--> print([[a multi-line message]])
f{x=10, y=20}                  <--> f({x=10, y=20})
type{}                         <--> type({})

o:foo(x)  <--> o.foo(o, x)

function f(a, b) return a or b end
CALL            PARAMETERS
f(3)            a=3, b=nil
f(3, 4)         a=3, b=4
f(3, 4, 5)      a=3, b=4 (5 is discarded)

返回多个结果值

s, e = string.find("hello Lua users", "Lua")
print(s, e) --> 7 9

假设有如下三个函数:

function foo0 () end -- returns no results
function foo1 () return 'a' end -- returns 1 result
function foo2 () return 'a','b' end -- returns 2 results

1.当调用作为表达式最后一个参数或者仅有一个参数时，根据变量个数函数尽可能多地返回多个值，不足补nil，超出舍去。

x,y = foo2() -- x='a', y='b'
x = foo2() -- x='a', 'b' is discarded
x,y,z = 10,foo2() -- x=10, y='a', z='b'
x,y = foo0() -- x=nil, y=nil
x,y = foo1() -- x='a', y=nil
x,y,z = foo2() -- x='a', y='b', z=nil

2.其他情况下，函数调用仅返回第一个值（如果没有返回值为nil）

x,y = foo2(), 20 -- x='a', y=20
x,y = foo0(), 20, 30 -- x='nil', y=20, 30 is discarded

作为函数参数时，在表构造函数中初始化时，和多值赋值时相同

print(foo0()) -->
print(foo1()) --> a
print(foo2()) --> a b
print(foo2(), 1) --> a 1
print(foo2() .. "x") --> ax
a = {foo0()} -- a = {} (an empty table)
a = {foo1()} -- a = {'a'}
a = {foo2()} -- a = {'a', 'b'}
a = {foo0(), foo2(), 4} -- a[1] = nil, a[2] = 'a', a[3] = 4

可以使用圆括号强制使调用返回一个值。

print((foo0()))     --> nil
print((foo1()))     --> a
print((foo2()))     --> a

可变参数