Lua编程4-5章(V5.0)

第四章   基本语法
4.1赋值语句
赋值是改变一个变量的值和改变表域的最基本的方法。 
a = "hello" .. "world" 
t.n = t.n + 1 
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. 变量个数<值的个数      多余的值会被忽略 


例如： 
a, b, c = 0, 1  
print(a,b,c)     --> 0   1   nil 
 
a, b = a+1, b+1, b+2   -- value of b+2 is ignored 
print(a,b)       --> 1   2 
 
a, b, c = 0 
print(a,b,c)     --> 0   nil   nil 
上面最后一个例子是一个常见的错误情况，注意：如果要对多个变量赋值必须依次
对每个变量赋值。 
a, b, c = 0, 0, 0 
print(a,b,c)     --> 0   0   0 
多值赋值经常用来交换变量，或将函数调用返回给变量： 
a, b = f() 
f()返回两个值，第一个赋给 a，第二个赋给 b。 


4.2局部变量与代码块(block)
使用 local 创建一个局部变量，与全局变量不同，局部变量只在被声明的那个代码块
内有效。代码块：指一个控制结构内，一个函数体，或者一个 chunk（变量被声明的那
个文件或者文本串）。 
x = 10 
local i = 1     -- local to the chunk 
 
while i<=x do 
  local x = i*2    -- local to the while body 
 print(x)     --> 2, 4, 6, 8, ... 
 i = i + 1 
end 


if i > 20 then 
  local x     -- local to the "then" body
 x = 20 
 print(x + 2) 
else 
 print(x)     --> 10  (the global one) 
end 
 
print(x)      --> 10  (the global one) 
注意，如果在交互模式下上面的例子可能不能输出期望的结果，因为第二句 local i=1
是一个完整的 chunk，在交互模式下执行完这一句后，Lua 将开始一个新的 chunk，这样
第二句的 i 已经超出了他的有效范围。可以将这段代码放在 do..end（相当于 c/c++的{}）
块中。 


应该尽可能的使用局部变量，有两个好处： 
1.  避免命名冲突 
2.  访问局部变量的速度比全局变量更快. 
我们给 block 划定一个明确的界限：do..end 内的部分。当你想更好的控制局部变量
的作用范围的时候这是很有用的。 
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) 


4.3控制结构语句
控制结构的条件表达式结果可以是任何值，Lua认为 false 和nil 为假，其他值为真。
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循环： 
for var=exp1,exp2,exp3 do 
 loop-part 
end 
for 将用 exp3 作为 step 从 exp1（初始值）到 exp2（终止值），执行 loop-part。其中
exp3 可以省略，默认 step=1 


有几点需要注意： 
1.  三个表达式只会被计算一次，并且是在循环开始前。 
for i=1,f(x) do 
 print(i) 
end 
 
for i=10,1,-1 do 
 print(i) 
end 
第一个例子 f(x)只会在循环前被调用一次。 
2.控制变量var是局部变量自动被声明，并且只在循环内有效
for i=1,10 do 
 print(i) 
end 
max = i   -- probably wrong! 'i' here is global 


如果需要保留控制变量的值，需要在循环中将其保存 
-- find a value in a list 
local found = nil 
for i=1,a.n do 
  if a[i] == value then 
  found = i    -- save value of 'i' 
   break 
  end 
end 
print(found) 


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])


我们不需要手工，可以自动构造反向表 
revDays = {}
for i, v in ipairs(days) do
revDays[v] = i
end


如果你对范型 for还有些不清楚在后面的章节我们会继续来学习。 


4.4 break 和return语句
break 语句用来退出当前循环（for,repeat,while）。在循环外部不可以使用。 
return 用来从函数返回结果，当一个函数自然结束结尾会有一个默认的 return。（这
种函数类似 pascal 的过程） 


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 


第五章  函数
函数有两种用途：1.完成指定的任务，这种情况下函数作为调用语句使用；2.计算并
返回值，这种情况下函数作为赋值语句的表达式使用。 
语法： 
function func_name (arguments-list) 
 statements-list; 
end; 
调用函数的时候，如果参数列表为空，必须使用()表明是函数调用。 
print(8*9, 9/8) 
a = math.sin(3) + math.cos(10) 
print(os.date()) 


上述规则有一个例外，当函数只有一个参数并且这个参数是字符串或者表构造的时
候，()是可选的： 
print "Hello World"  <-->  print("Hello World") 
dofile 'a.lua'   <-->  dofile ('a.lua') 
print [[a multi-line  <-->  print([[a multi-line 
   message]]        message]]) 
f{x=10, y=20}    <-->  f({x=10, y=20}) 
type{}      <-->  type({}) 


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) 


5.1返回多个结果值
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
local m = a[mi]
for i, val in ipairs(a) do 
if val > m then 
mi = i
m = val
end
end
end


print(maximum({8, 10, 23, 12, 5})) -->23  3


Lua总是调整函数返回值的个数去适用调用环境，当作为一个语句调用函数时，所有返回值被忽略。假设有如下三个函数：
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，超出舍去。 
2.  其他情况下，函数调用仅返回第一个值（如果没有返回值为 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 
end


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 
另外，return f()这种类型的返回 f()返回的所有值 
function foo (i) 
  if i == 0 then return foo0() 
  elseif i == 1 then return foo1() 
  elseif i == 2 then return foo2() 
  end 
end 
 
print(foo(1))    --> a 
print(foo(2))    --> a  b 
print(foo(0))    -- (no results) 
print(foo(3))    -- (no results) 


可以使用圆括号强制使调用返回一个值。 
print((foo0()))   --> nil 
print((foo1()))   --> a 
print((foo2()))   --> a 


一个 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 


5.2可变参数
Lua 函数可以接受可变数目的参数，和 C 语言类似在函数参数列表中使用三点（...）
表示函数有可变的参数。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, 8, 5} a = 3, b = 4, arg = {5, 8 ,n = 2}


如上面所示，Lua 会将前面的实参传给函数的固定参数，后面的实参放在 arg 表中。
举个具体的例子，如果我们只想要 string.find 返回的第二个值： 
一个典型的方法是使用虚变量（下划线） 
local _, x = string.find(s, p) 
-- now use `x' 
... 
还可以利用可变参数声明一个select函数：
function select (n, ...) 
  return arg[n] 
end 
 
print(string.find("hello hello", " hel"))    --> 6  9 
print(select(1, string.find("hello hello", " hel"))) --> 6 
print(select(2, string.find("hello hello", " hel"))) --> 9 


有时候需要将函数的可变参数传递给另外的函数调用，可以使用前面我们说过的
unpack(arg)返回 arg 表所有的可变参数，Lua 提供了一个文本格式化的函数 string.format
（类似 C 语言的 sprintf函数）： 
function fwrite(fmt, ...) 
  return io.write(string.format(fmt, unpack(arg))) 
end 
这个例子将文本格式化操作和写操作组合为一个函数。 


5.3命名参数
Lua 的函数参数是和位置相关的，调用时实参会按顺序依次传给形参。有时候用名
字指定参数是很有用的，比如 rename 函数用来给一个文件重命名，有时候我们我们记不
清命名前后两个参数的顺序了： 


-- invalid code 
rename(old="temp.lua", new="temp1.lua") 
上面这段代码是无效的，Lua 可以通过将所有的参数放在一个表中，把表作为函数
的唯一参数来实现上面这段伪代码的功能。因为 Lua 语法支持函数调用时实参可以是表
的构造。 
rename{old="temp.lua", new="temp1.lua"} 
根据这个想法我们重定义了 rename： 
function　rename (arg)
{
return os.rename(arg.old, arg.new)
}


当函数的参数很多的时候，这种函数参数的传递方式很方便的。例如 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