Lua语法基础(2)--基本语法、函数

上一篇编辑编辑着，发现，缩进出了问题。作为一个不是强迫症的人，实在是忍受不了同一级内容不同缩进方式的槽点，于是重开一篇吧。（万幸，这样的文章也只有我自己看。）

第四 基本语法

赋值语句，Lua可以对多个变量同时赋值，变量列表和值列表的各个元素用逗号分开，赋值语句右边的值会依次赋给左边的变量。

a, b = 10, 2*x <--> a=10; b=2*x

遇到赋值语句Lua会先计算右边所有的值然后再执行赋值操作，所以我们可以这样进行交换变量的值：

x, y = y, x -- swap 'x' for 'y'
a[i], a[j] = a[j], a[i] -- swap 'a[i]' for 'a[i]'

当变量个数和值的个数不一致时，Lua会一直以变量个数为基础采取以下策略：

a. 变量个数>值的个数按变量个数补足nil
b. 变量个数<值的个数多余的值会被忽略

控制结构语句

控制结构的条件表达式结果可以是任何值，Lua认为false和nil为假，其他值为真。
a、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;

b、while语句：

while condition do
    statements;
end;

c、repeat-until语句：

repeat
    statements;
until conditions;

d、for语句有两大类：
第一，数值for循环：

for var=exp1,exp2,exp3 do
    loop-part
end

有几点需要注意：
1. 三个表达式只会被计算一次，并且是在循环开始前。2、 控制变量var是局部变量自动被声明,并且只在循环内有效.

3、 循环过程中不要改变控制变量的值，那样做的结果是不可预知的。如果要退出循环，使用break语句。

第二，范型for循环：
前面已经见过一个例子：

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

范型for遍历迭代子函数返回的每一个值。
再看一个遍历表key的例子：

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

范型for和数值for有两点相同：
1. 控制变量是局部变量
2. 不要修改控制变量的值
再看一个例子，假定有一个表：

days = {"Sunday", "Monday", "Tuesday", "Wednesday",
"Thursday", "Friday", "Saturday"}

现在想把对应的名字转换成星期几，一个有效地解决问题的方式是构造一个反向表：

revDays = {["Sunday"] = 1, ["Monday"] = 2,
["Tuesday"] = 3, ["Wednesday"] = 4,
["Thursday"] = 5, ["Friday"] = 6,
["Saturday"] = 7}

下面就可以很容易获取问题的答案了:

x = "Tuesday"
print(revDays[x]) --> 3

我们不需要手工，可以自动构造反向表

revDays = {}
for i,v in ipairs(days) do
revDays[v] = i
end

e、break和return语句

break语句用来退出当前循环（for,repeat,while）。在循环外部不可以使用。
return用来从函数返回结果，当一个函数自然结束结尾会有一个默认的return。
Lua语法要求break和return只能出现在block的结尾一句（也就是说：作为chunk的最后一句，或者在end之前，或者else前，或者until前），例如：

local i = 1
while a[i] do
if a[i] == v then break end
i = i + 1
end

有时候为了调试或者其他目的需要在block的中间使用return或者break，可以显式的使用do..end来实现：

function foo ()
return --<< SYNTAX ERROR
-- 'return' is the last statement in the next block
do return end -- OK
... -- statements not reached
end

f、大家可以看出来，Lua内没有提供continue和switch语句。continue语句，可以用ifelse来实现，就是符合条件的执行部分代码，不符合条件的就else不执行功能代码。

而，switch用if elseif else end这样的语句来实现的话，就会让人恶心的不行不行的了。其中，有一种实现方法，可以借鉴。

Switch语句的替代语法（所有替代方案中觉得最好，最简洁，最高效，最能体现Lua特点的一种方案）

action = {
  [1] = function (x) print(x) end,
  [2] = function (x) print( 2 * x ) end,
  ["nop"] = function (x) print(math.random()) end,
  ["my name"] = function (x) print("fred") end,
}
while true do
    key = getChar()
    x = math.ramdon()
    action[key](x)
end

第五 函数

函数有两种用途：1.完成指定的任务，这种情况下函数作为调用语句使用；2.计算并返回值，这种情况下函数作为赋值语句的表达式使用。

语法：

function func_name (arguments-list)
    statements-list;
end;

调用函数的时候，如果参数列表为空，必须使用()表明是函数调用。Lua也提供了面向对象方式调用函数的语法，比如o:foo(x)与o.foo(o, x)是等价的。在面向对象内这个比较容易让人搞混，下文会提到。

Lua使用的函数可以是Lua编写也可以是其他语言编写，对于Lua程序员来说用什么语言实现的函数使用起来都一样。
Lua函数实参和形参的匹配与赋值语句类似，多余部分被忽略，缺少部分用nil补足。

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)

a、返回多个结果值

Lua函数可以返回多个结果值，比如string.find，其返回匹配串“开始和结束的下标”（如果不存在匹配串返回nil）。

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

Lua函数中，在return后列出要返回的值得列表即可返回多值，如：

function maximum (a)
local mi = 1 -- maximum index
local m = a[mi] -- maximum value
for i,val in ipairs(a) do
if val > m then
mi = i
m = val
end
end
return m, mi
end
print(maximum({8,10,23,12,5})) --> 23 3

可以使用圆括号强制使调用返回一个值。一个return语句如果使用圆括号将返回值括起来也将导致返回一个值。

函数多值返回的特殊函数unpack，接受一个数组作为输入参数，返回数组的所有元素。unpack被用来实现范型调用机制，在C语言中可以使用函数指针调用可变的函数，可以声明参数可变的函数，但不能两者同时可变。在Lua中如果你想调用可变参数的可变函数只需要这样：

f(unpack(a))

unpack返回a所有的元素作为f()的参数

f = string.find
a = {"hello", "ll"}
print(f(unpack(a))) --> 3 4


预定义的unpack函数是用C语言实现的，我们也可以用Lua来完成：

function unpack(t, i)
    i = i or 1
    if t[i] then
        return t[i], unpack(t, i + 1)
    end
end    

b、可变参数

Lua将函数的参数放在一个叫arg的表中，除了参数以外，arg表中还有一个域n表示参数的个数。

例如，我们可以重写print函数：

printResult = ""
function print(...)
for i,v in ipairs(arg) do
printResult = printResult .. tostring(v) .. "\t"
end
printResult = printResult .. "\n"
end

有时候我们可能需要几个固定参数加上可变参数

function g (a, b, ...) end
CALL PARAMETERS
g(3) a=3, b=nil, arg={n=0}
g(3, 4) a=3, b=4, arg={n=0}
g(3, 4, 5, 8) a=3, b=4, arg={5, 8; n=2}

c、命名参数

lua的函数参数是和位置相关的，调用时实参会按顺序依次传给形参。当函数的参数很多的时候，用函数参数的传递方式很方便的。例如GUI库中创建窗体的函数有很多参数并且大部分参数是可选的，可以用下面这种方式：

w = Window {
x=0, y=0, width=300, height=200,
title = "Lua", background="blue",
border = true
}  -- 注意这里是传入的表，而不是括号()

function Window (options)
-- check mandatory options
if type(options.title) ~= "string" then
　　error("no title")
elseif type(options.width) ~= "number" then
　　error("no width")
elseif type(options.height) ~= "number" then
　　error("no height")
end
-- everything else is optional
_Window(options.title,
options.x or 0, -- default value
options.y or 0, -- default value
options.width, options.height,
options.background or "white", -- default
options.border -- default is false (nil)
)
end

 

D、函数更深一层

Lua中的函数是带有词法定界（lexical scoping）的第一类值（first-class values）。
第一类值指：在Lua中函数和其他值（数值、字符串）一样，函数可以被存放在变量中，也可以存放在表中，可以作为函数的参数，还可以作为函数的返回值。
词法定界指：被嵌套的函数可以访问他外部函数中的变量。这一特性给Lua提供了强大的编程能力。
Lua中关于函数稍微难以理解的是函数也可以没有名字，匿名的。当我们提到函数名（比如print），实际上是说一个指向函数的变量，像持有其他类型值的变量一样：

a = {p = print}
a.p("Hello World") --> Hello World
print = math.sin -- `print' now refers to the sine function
a.p(print(1)) --> 0.841470
sin = a.p -- `sin' now refers to the print function
sin(10, 20) --> 10 20

函数定义实际上是一个赋值语句，将类型为function的变量赋给一个变量。我们使用function (x) ... end来定义一个函数和使用{}创建一个表一样。

foo = function (x) return 2*x end

原本函数是上面这种，但是可以利用Lua提供的“语法上的甜头”（syntactic sugar），用下面这种写法进行替代

function foo (x) return 2*x end

以其他函数作为参数的函数在Lua中被称作高级函数，高级函数在Lua中并没有特权，只是Lua把函数当作第一类函数处理的一个简单的结果。

table标准库提供一个排序函数，接受一个表作为输入参数并且排序表中的元素。这个函数必须能够对不同类型的值（字符串或者数值）按升序或者降序进行排序。Lua不是尽可能多地提供参数来满足这些情况的需要，而是接受一个排序函数作为参数（类似C++的函数对象），排序函数接受两个排序元素作为输入参数，并且返回两者的大小关系，例如：

network = {
{name = "grauna", IP = "210.26.30.34"},
{name = "arraial", IP = "210.26.30.23"},
{name = "lua", IP = "210.26.23.12"},
{name = "derain", IP = "210.26.23.20"},
}

table.sort(network, function (a,b)
return (a.name > b.name)
end)

值得注意的是，Lua在进行排序时，对不稳定排序可能会抛出错误哦。这个问题，在本博客的另一篇中有提到。

i、闭包

当一个函数内部嵌套另一个函数定义时，内部的函数体可以访问外部的函数的局部变量，这种特征我们称作词法定界。虽然这看起来很清楚，事实并非如此，词法定界加上第一类函数在编程语言里是一个功能强大的概念，很少语言提供这种支持。

下面看一个简单的例子，假定有一个学生姓名的列表和一个学生名和成绩对应的表；现在想根据学生的成绩从高到低对学生进行排序，可以这样做：

names = {"Peter", "Paul", "Mary"}
grades = {Mary = 10, Paul = 7, Peter = 8}
table.sort(names, function (n1, n2)
　　return grades[n1] > grades[n2] -- compare the grades
end)

假定创建一个函数实现此功能：

function sortbygrade (names, grades)
　　table.sort(names, function (n1, n2)
　　　　return grades[n1] > grades[n2] -- compare the grades
　　end)
end

例子中包含在sortbygrade函数内部的sort中的匿名函数可以访问sortbygrade的参数grades，在匿名函数内部grades不是全局变量也不是局部变量，我们称作外部的局部变量（external local variable）或者upvalue。（upvalue意思有些误导，然而在Lua中他的存在有历史的根源，还有他比起external local variable简短）。
看下面的代码：

function newCounter()
　　local i = 0
　　　　return function() -- anonymous function
　　　　　　　　i = i + 1
　　　　　　　　return i
　　　　end
end
c1 = newCounter()
print(c1()) --> 1
print(c1()) --> 2

匿名函数使用upvalue i保存他的计数，当我们调用匿名函数的时候i已经超出了作用范围，因为创建i的函数newCounter已经返回了。然而Lua用闭包的思想正确处理了这种情况。简单的说闭包是一个函数加上它可以正确访问的upvalues。如果我们再次调用newCounter，将创建一个新的局部变量i，因此我们得到了一个作用在新的变量i上的新闭包。

c2 = newCounter()
print(c2()) --> 1
print(c1()) --> 3
print(c2()) --> 2

c1、c2是建立在同一个函数上，但作用在同一个局部变量的不同实例上的两个不同的闭包。
技术上来讲，闭包指值而不是指函数，函数仅仅是闭包的一个原型声明；尽管如此，在不会导致混淆的情况下我们继续使用术语函数代指闭包。
闭包在上下文环境中提供很有用的功能，如前面我们见到的可以作为高级函数（sort）的参数；作为函数嵌套的函数（newCounter）。这一机制使得我们可以在Lua的函数世界里组合出奇幻的编程技术。闭包也可用在回调函数中，比如在GUI环境中你需要创建一系列button，但用户按下button时回调函数被调用，可能不同的按钮被按下时需要处理的任务有点区别。具体来讲，一个十进制计算器需要10个相似的按钮，每个按钮对应一个数字，可以使用下面的函数创建他们：

function digitButton (digit)
    return Button{ label = digit,
    action = function ()
    add_to_display(digit)
    end
}

end

这个例子中我们假定Button是一个用来创建新按钮的工具， label是按钮的标签，action是按钮被按下时调用的回调函数。（实际上是一个闭包，因为他访问upvalue digit）。digitButton完成任务返回后，局部变量digit超出范围，回调函数仍然可以被调用并且可以访问局部变量digit。

ii、非全局函数

当我们将函数保存在一个局部变量内时，我们得到一个局部函数，也就是说局部函数像局部变量一样在一定范围内有效。下面是声明局部函数的两种方式：

local f = function (...)
...
end
local g = function (...)
...
f() -- external local `f' is visible here
...
end

local function f (...)
...
end

有一点需要注意的是在声明递归局部函数的方式：

local fact = function (n)
　　if n == 0 then
　　　　return 1
　　else
　　　　return n*fact(n-1) -- buggy
　　end
end

上面这种方式导致Lua编译时遇到fact(n-1)并不知道他是局部函数fact，Lua会去查找是否有这样的全局函数fact。为了解决这个问题我们必须在定义函数以前先声明：

local fact
fact = function (n)
　　if n == 0 then
　　　　return 1
　　else
　　　　return n*fact(n-1)
　　end
end

iii、正确的尾调用

Lua中函数的另一个有趣的特征是可以正确的处理尾调用（proper tail recursion，一些书使用术语“尾递归”，虽然并未涉及到递归的概念）。
尾调用是一种类似在函数结尾的goto调用，当函数最后一个动作是调用另外一个函数时，我们称这种调用尾调用。例如：

function f(x)
    return g(x)
end

Lua中类似return g(...)这种格式的调用是尾调用。但是g和g的参数都可以是复杂表达式，因为Lua会在调用之前计算表达式的值。例如下面的调用是尾调用：

return x[i].foo(x[j] + a*b, i + j)

而下面的就不是尾调用

function f (x)
    g(x)
    return
end

return g(x) + 1 -- must do the addition
return x or g(x) -- must adjust to 1 result
return (g(x)) -- must adjust to 1 result

可以将尾调用理解成一种goto，在状态机的编程领域尾调用是非常有用的。状态机的应用要求函数记住每一个状态，改变状态只需要goto(or call)一个特定的函数。

我们考虑一个迷宫游戏作为例子：迷宫有很多个房间，每个房间有东西南北四个门，每一步输入一个移动的方向，如果该方向存在即到达该方向对应的房间，否则程序打印警告信息。目标是：从开始的房间到达目的房间。
这个迷宫游戏是典型的状态机，每个当前的房间是一个状态。我们可以对每个房间写一个函数实现这个迷宫游戏，我们使用尾调用从一个房间移动到另外一个房间。一个四个房间的迷宫代码如下：

function room1 ()
    local move = io.read()
    if move == "south" then
        return room3()
    elseif move == "east" then
        return room2()        
    else
        print("invalid move")
        return room1() -- stay in the same room
　　end
end
function room2 ()
　　local move = io.read()
　　if move == "south" then
　　　　return room4()
　　elseif move == "west" then
　　　　return room1()
　　else
　　　　print("invalid move")
　　　　return room2()
　　end
end
function room3 ()
　　local move = io.read()
　　if move == "north" then
　　　　return room1()
　　elseif move == "east" then
　　　　return room4()
　　else
　　　　print("invalid move")
　　　　return room3()
　　end
end
function room4 ()
　　print("congratilations!")
end    

我们可以调用room1()开始这个游戏。
如果没有正确的尾调用，每次移动都要创建一个栈，多次移动后可能导致栈溢出。但正确的尾调用可以无限制的尾调用，因为每次尾调用只是一个goto到另外一个函数并不是传统的函数调用。