如何快速学会一门编程语言之Lua：高级特性

内置数据结构 table

灵活的下标

a = {2, 4, 6, 8}
print(a[1], a[2]) --> 显示：2 4

p = {a=1, b=3, c=9}
print(a["b"]) --> 显示：3

p.d = 10
print(p.a) --> 显示：9
print(p["d"]) --> 显示：10

k = {}
k[2]="hello"
k["haha"]="world"
print(k[2],k["haha"]) --> 显示：hello world

遍历 table

a={}
a[1]="one"
a["second"]="two"
a[78]="three"
a["last"]="four"
for k,v in pairs(a) do
  print(k,v)
end

1       one
last    four
78      three
second  two

列表形 table

• 用 # 来获得长度。需要特别注意不要用赋值 nil 来删除列表里的元素，否则#的结果是不准确的。
• 用 for i,v in ipairs(...) do 来进行顺序遍历
• 用 table.insert(tb, pos, var) 来追加和插入元素
• 用 table.remove(tb, pos) 来删除元素
• 用 table.sort(tb) 来排序，这个尤其有用，甚至可以用来排序汉字（因为汉字的内码是按拼音顺序设计的）

一点小结

• 符号 # 在其他语言里常常是单行注释符号，Lua 用来作为长度运算符了。
• 符号 // 在其他语言里面也常常是单行注释符号，Lua 用来作为整除运算符了（Lua5.3之后支持）。所以 Lua 用了 -- 作为注释符号。
• Lua 也没有递增 ++ 和递减 -- 运算符。其实这两个运算符在 a = b++ 这种写法下，运行的结果比较反直觉，所以Python 也不支持。
• Lua 的 table 用起来和 PHP 的数组还挺像的，都是挺“万能”的。

面向对象

1. 封装：就是支持一种叫对象的变量，这个变量是可以同时携带属性值（成员变量）和方法（成员函数）的。开发者不但可以通过对象读写其携带的属性，还可以调用对象所携带的方法。很多语言还设置了类似 this 或者 self 这种关键字，以便在方法中调用携带此方法的对象变量。
2. 继承：支持对象的属性和方法定义可以被重用，可以让一类对象的定义，通过继承语法自动带上另外一类对象的定义，从而避免大量的重复而类似的定义。
3. 多态：支持多个不同类型（定义）的对象，只要它们都满足其中一种类型定义，就可以“作为”这类对象来使用。这种特性最常用于取代复杂的 switch...case 语法，做法就是为不同类型的对象，都定义同一个名字的方法，这些不同类型的对象，都可以被调用这个相同名字的方法，但执行的代码则会被自动调用那些应该属于那种类型的方法。等于自动以对象的类型为 switch 的选择，每个对象的方法为 case 的代码段。

通过原型获得属性

father = { last_name="Han", first_name="Da" } --> 被继承的父对象
son = {first_name="Xiao"} --> 子对象

meta_table = {__index=father} --> 建立去 father 查找成员的元表
setmetatable(son, meta_table) --> 设置 son 对象的元表，以便通过 father 查找未知属性

print(son.first_name, son.last_name) --> Xiao Han

方法：table 身上的函数

obj = {}
obj.method = function(a, b) 
              return a+b
           end
result = obj.method(1, 2)
print(result) --> 显示 3

obj = {a=1}
obj.method = function(my_obj, b)
                 return my_obj.a + b
             end
print(obj.method(obj, 2)) --> 显示 3          

obj = {a=1}
function obj:method(b) --> 定义方法用冒号 : 会自动加上 self 参数作为第一个参数
  return self.a + b
end
print(obj:method(2)) --> 调用方法用冒号 : 会自动传入本对象 obj 作为第一个参数

构造器

-- 定义 Person 原型对象（类）
Person = {
  Name = "default", 
  Age = 18
}

-- 构造器函数
function Person:New(name) 
  local new_obj = {}
  setmetatable(new_obj, {__index = self})
  new_obj.Name = name  --> 此处对 new_obj 插入了属性 Name，不再需要从元表查找此属性了
  return new_obj
end

function Person:Show()
  print(self.Name, self.Age)
end

me = Person:New("HanDa") --> 通过原型Person对象，构造一个使用对象
me:Show() --> 通过原型Person对象的Show()方法打印属性：HanDa 18

继承

-- Person 原型对象的定义 --
Person = {
  Name = "default", 
  Age = 18
}
function Person:New(name) 
  local new_obj = {}
  setmetatable(new_obj, {__index = self})
  new_obj.Name = name  --> 此处对 new_obj 插入了属性 Name，不再需要从元表查找此属性了
  return new_obj
end
function Person:Show()
  print(self.Name, self.Age)
end

-- Student 原型对象继承于 Person --
Student = Person:New("default student")
Student.School = "211or985" -->添加自己的属性
function Student:New(name, school)
  local new_obj = {}
  setmetatable(new_obj, {__index = self})
  new_obj.School = school
  new_obj.Name = name --> 覆盖掉Student原型的默认值,此处无法通过调用 Persion:New() 来进行覆盖
  return new_obj
end
function Student:Show()
  print(self.Name, self.Age, self.School)
end

me = Student:New("HanDa","三本") --> 通过原型Student对象，构造一个使用对象
me:Show() --> 通过原型Person对象的Show()方法打印属性：HanDa 18 三本

function Person:Init(name)
  self.Name = name
end

me = Student:New("Anything", "大专")
me:Init("HanDa") <--此处调用父类原型对象的 Init() 方法来设置自己
me:Show() --> HanDa 18 大专

反思

模板和泛型

内存管理/垃圾收集

a = 10
function f()
  a = 11
  b = 20
end

f()
print(a,b)

a = 10
function f()
  local a = 11
  local b = 20
end

f()
print(a,b) -- 打印结果：10 nil

1. 所有的全局变量都不会被回收
2. 所有的非 Table 类型的 local 变量，都会被回收。
3. 正在被使用的 Table 变量，包括全局变量和局部变量——其内容的 key 和 value 都不会被回收，除非这个 Table 被声明为 weak 弱引用的。
4. 如果有一个变量，所有包含它的 Table 的引用（包括 key 和 value）都是弱引用，那么它就会被回收。

1. 尽量使用 local 局部变量
2. 不要往一个全局的 Table 变量里面无限制的加入内容
3. 如果一个变量，明确已经在某个 Table 里面包含了，那么其他使用这个变量的其他 Table，可以考虑作为 weak 弱引用 Table 来包含它。这样有助于减少泄漏的可能性，如果使用大量 Table 包含一个变量，这里面任何一个 Table 不小心放到某个全局变量或者全局 Table 里面去了，就会泄漏了。

错误处理

1. 发现“错误”后，生成一个错误信息，让调用代码知道这个情况。对于 C 语言我们常见的有返回错误码，设置一个全局的 errno 变量等法子；Java 语言则设计了异常，可以通过throw关键字作为一种特殊的返回值抛给上层。
2. 调用代码在发生“错误”后，编写一段特别的代码来处理它。C 语言的代码通常通过 if 判断返回值是否为 0，来发现函数中是否发生了错误；Java 代码则被要求必须编写 try...catch 代码来捕获和处理抛出的异常（或者继续抛出这些异常）。

• 你可以通过 assert(expr, "err msg") 函数来进行判断，如果表达式为 false，则会“抛出”一个 Lua 定义的错误；你也可以直接调用 error("err msg") 来抛出一个 Lua 错误。只要抛出了错误，Lua 程序在默认情况下，就会中断执行，并且打印你定义的错误消息内容，以及错误发生的源码位置，函数调用（栈）信息等等。
• 你可以通过使用 pcall(func_name, ...) 的方式来发起对一个函数的调用，如果这个函数会抛出错误，Lua 程序将不会中断运行；而是让 pcall() 返回两个返回值：false 和 errinfo，其中 errinfo 返回值是你通过 error() 函数传入的参数，不必是一个字符串，可以是一个 table，这样你可以设计任意的内容以便上层调用者进行处理。如果 pcall() 调用的函数没有抛出错误，那么它返回的一个返回值会是 true，而后面的返回值则是具体调用函数的返回值。

-- 此函数会抛出错误
function add(a,b)
        assert(type(a) == "number", "a is not a number")
        if type(b) ~= "number" then
                error("b is not a number")
        end
        return a+b
end

-- 通过 pcall() 捕获错误
rs, err = pcall(add, 1, "kk")
print(rs, err)

rs, err = pcall(add, "ww", 2)
print(rs, err)

rs, err = pcall(add, 1, 2)
print(rs, err)

false   test.lua:4: b is not a number
false   test.lua:2: a is not a number
true    3

多任务支持

1. 同时运行的多个函数，对于可以读写的同一块堆内存（或者叫变量），可能造成不可预期的结果。因此诞生了很多种类的“锁”，来试图解决多个程序同时修改、读取同一组变量造成的故障。

1. 同时运行的多个函数，也许不是性能最好的做法，因为计算机需要在这多个函数的运行环境之间反复切换，这种切换本身也需要成本。

1. 对于同时读写变量的问题。由于协程是可以自己写代码进行切换的，所以把可能出现同时操作的代码，有意识的不要用 yield 断开。由于始终只有一个线程在运行，只要别切换出去，变量就不会被其他程序修改。——这样也不需要什么锁了。
2. 由于只有一个线程在运行，协程之间切换的代价会大大降低，而且切换的代码是手工编写的，也提供了更细致的调优的手段。

function foo()
    print("协同程序 foo 开始执行")
    local value = coroutine.yield("暂停 foo 的执行")
    print("协同程序 foo 恢复执行，传入的值为: " .. tostring(value))
    return "协同程序 foo 结束执行"
end

-- 创建协同程序
local co = coroutine.create(foo)

-- 启动协同程序
local status, result = coroutine.resume(co)
print(result) 

-- 恢复协同程序的执行，并传入一个值
status, result = coroutine.resume(co, 42)
print(result) 

• coroutine.resume() 用来进入一个协程函数，输入参数会成为协程函数的入参，或者 coroutine.yield() 的返回值。Lua 支持多返回值的好处这里就看见了，多个 resume() 参数可以自然的成为 yield() 的多个返回值。
• coroutine.yield() 用来以一种特殊的 return 切出函数，其参数是 coroutine.resume() 的返回值。如果协程函数结束，return 的返回值也会以 resume() 的返回值形式提供给调用者。

框架支持

回调函数

-- 回调函数
add = function(a, b) return a+b end
sub = function(a, b) return a-b end

-- 框架代码，主要功能是打印计算结果
function cal(cal_fun, a, b)
  print(cal_fun(a,b))
end

--使用框架
cal(add, 3, 2) --> 5
cal(sub, 3, 2) --> 1

反射

-- 框架代码：从命令行参数执行命令
function run_cmd()
  -- arg 是一个全局 table 变量，记录了全部的命令行参数
  if not arg[1] or not arg[2] or not arg[3] then
    print("Usage: cmd arg1 arg2")
    return
  end
  local f=load("return "..arg[1].."("..arg[2]..","..arg[3]..")")
  print(f())
end

-- 回调函数
function add(a, b) return a+b end
function sub(a, b) return a-b end

-- 运行框架
run_cmd()

$ lua test.lua add 1 3
4
$ lua test.lua sub 1 3
-2

-- local f=load("return ".."add".."(".."1"..",".."3"..")")
local f = function(...)
            return add(1,3)
          end

tb = {a=1, b=2}
pirnt(tb["a"]) --> 1

a = 100
print(_G["a"]) --> 100

所谓反射，就是可以在运行时，通过在字符串变量名中的函数名字来调用这个函数；通过字符串变量中的变量名字来读写变量。

注解

模块管理

1. 定义模块：怎样写代码，怎样命名文件才能成为一个合法的“模块”
2. 引用模块：怎样写代码才能调用另外一个模块里面的功能，譬如调用函数或者构造类对象
3. 编译或运行的方法：怎样操作才能让各个模块的代码一起运行

• 建立一个以模块名为文件名的源码，譬如 aaa.lua，就代表了你想要设计一个叫 aaa 的模块
• 在模块源文件内，定义一个 table，如 tb = {}，然后把你希望提供给使用者的变量、函数，都存放到这个 table 变量（tb）里面，最后在源文件末尾写上 return tb 来返回这个 table

module = {}
 
-- 定义一个常量
module.constant = "这是一个常量"
 
-- 定义一个函数
function module.func1()
    io.write("这是一个公有函数！\n")
end
 
local function func2()
    print("这是一个私有函数！")
end
 
function module.func3()
    func2()
end
 
return module

-- module 模块为上文提到到 module.lua
require("module")
print(module.constant)
module.func3()

这是一个常量
这是一个私有函数！

export LUA_PATH="./?.lua;/usr/local/share/lua/5.1/?.lua;/usr/local/share/lua/5.1/?/init.lua;/usr/local/lib/lua/5.1/?.lua;/usr/local/lib/lua/5.1/?/init.lua"

./module.lua
/usr/local/share/lua/5.1/module.lua
/usr/local/share/lua/5.1/module/init.lua
/usr/local/lib/lua/5.1/module.lua
/usr/local/lib/lua/5.1/module/init.lua

小结

下一篇介绍 Lua 为数不多但灵活好用的库函数