1.函数function
function本身也是一种变量，可以作为函数参数使用，还可以作为返回值使用。
function func_name (arguments-list)
statements-list;
end;
Lua语言的一大特色。
-------------------------------------------------------------------------------------------------------------------------------
2.Userdata
userdata专门和Lua的宿主机打交道。userdata 可以将 C 数据存放在 Lua 变量中， userdata 在 Lua 中除了赋值和相等比较外
没有预定义的操作。userdata 用来描述应用程序或者使用 C 实现的库创建的新类型。
例如：用标准 I/O 库来描述文件。
Unity中的GameObject或者组件类。
-------------------------------------------------------------------------------------------------------------------------------
3.表结构 table
table 是 Lua 的一种数据结构用来帮助我们创建不同的数据类型，如：数组、字典等。
Lua table 使用关联型数组，你可以用任意类型的值来作数组的索引，但这个值不能是 nil。
Lua table 是不固定大小的，你可以根据自己需要进行扩容。
Lua也是通过table来解决模块（module）、包（package）和对象（Object）的。
-------------------------------------------------------------------------------------------------------------------------------
4.闭包
当一个函数内部嵌套另一个函数定义时，内部的函数体可以访问外部的函数的局部变量，这种特征我们称作词法定界。很少语言提供这种支持。
简单的说闭包是一个函数加上它可以正确访问的 upvalues。
4.1实例
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
-------------------------------------------------------------------------------------------------------------------------------
5.函数作为table域
函数作为 table 的域（大部分 Lua 标准库使用这种机制来实现的比如 io.read、math.sin） 。这种情况下，必须注意函数和表语法：
-------------------------------------------------------------------------------------------------------------------------------
6.Lua 模块与包
模块类似于一个封装库，从 Lua 5.1 开始，Lua 加入了标准的模块管理机制，可以把一些公用的代码放在一个文件里，以 API 接口的形式在其他地方调用，有利于代码的重用和降低代码耦合度。
-------------------------------------------------------------------------------------------------------------------------------
6.1模块声明
Lua 的模块是由变量、函数等已知元素组成的 table，因此创建一个模块很简单，就是创建一个 table，然后把需要导出的常量、函数放入其中，最后返回这个 table 就行。以下为创建自定义模块 module.lua，文件代码格式如下：
-- 文件名为 module.lua
-- 定义一个名为 module 的模块
module = {}
-- 定义一个常量
module.constant = "这是一个常量"
-- 定义一个函数
function module.func1()
io.write("这是一个公有函数！\n")
end
local function func2()
print("这是一个私有函数！")
end
function module.func3()
func2()
end
--返回这个模块
return module
由上可知，模块的结构就是一个 table 的结构，因此可以像操作调用 table 里的元素那样来操作调用模块里的常量或函数。
上面的 func2 声明为程序块的局部变量，即表示一个私有函数，因此是不能从外部访问模块里的这个私有函数，必须通过模块里的公有函数来调用.
-------------------------------------------------------------------------------------------------------------------------------
6.2引入模块
require 函数：
Lua提供了一个名为require的函数用来加载模块。要加载一个模块，只需要简单地调用就可以了。例如：
require("模块名")
或者
require "模块名"
执行 require 后会返回一个由模块常量或函数组成的 table，并且还会定义一个包含该 table 的全局变量。
-- module 模块为上文提到到 module.lua
require("module")
print(module.constant)
module.func3()
module.func2() --报错
或者给加载的模块定义一个别名变量，方便调用：
local m = require("module")
print(m.constant)
m.func3()
加载机制
对于自定义的模块，模块文件不是放在哪个文件目录都行，函数 require 有它自己的文件路径加载策略，它会尝试从 Lua 文件或 C 程序库中加载模块。
require 用于搜索 Lua 文件的路径是存放在全局变量 package.path 中，当 Lua 启动后，会以环境变量 LUA_PATH 的值来初始这个环境变量。如果没有找到该环境变量，则使用一个编译时定义的默认路径来初始化。
-------------------------------------------------------------------------------------------------------------------------------
7.Lua 元表(Metatable)
元表对应的英文是metatable，元方法是metamethod。我们都知道，在C++中，两个类是无法直接相加的，但是，如果你重载了“+”符号，就可以进行类的加法运算。在Lua中也有这个道理，两个table类型的变量，你是无法直接进行“+”操作的，如果你定义了一个指定的函数，就可以进行了。
Lua是怎么做的？
通常，Lua中的每个值都有一套预定义的操作集合，比如数字是可以相加的，字符串是可以连接的，但是对于两个table类型，则不能直接进行“+”操作。这需要我们进行一些操作。在Lua中有一个元表，也就是上面说的metatable，我们可以通过元表来修改一个值得行为，使其在面对一个非预定义的操作时执行一个指定的操作。比如，现在有两个table类型的变量a和b，我们可以通过metatable定义如何计算表达式a+b，具体的在Lua中是按照以下步骤进行的：
1.先判断a和b两者之一是否有元表；
2.检查该元表中是否有一个叫__add的字段；
3.如果找到了该字段，就调用该字段对应的值，这个值对应的是一个metamethod；（Lua中方法是可以放在一个字段中的）
4.调用__add对应的metamethod计算a和b的值。
上述四个步骤就是计算table类型变量a+b的过程。在Lua中，每个值都有一个元表，table和userdata类型的每个变量都可以有各自独立的元表，而其他类型的值则共享其类型所属的单一元表。
现在就说说最基本的metatable内容。Lua在创建新的table时不会创建元表，比如以下代码就可以演示：
代码如下:
local t = {1, 2}
print(getmetatable(t)) -- nil
我们是使用getmetatable来获取一个table或userdata类型变量的元表，当创建新的table变量时，使用getmetatable去获得元表，将返回nil；同理，我们也可以使用setmetatable去设置一个table或userdata类型变量的元表，
例如代码如下:
local t = {}
print(getmetatable(t)) -->nil
local t1 = {}
setmetatable(t, t1)
assert(getmetatable(t) == t1)
任何table都可以作为任何值得元表，而一组相关的table又可以共享一个通用的元表，此元表描述了它们共同的行为。一个table甚至可以作为它自己的元表，用于描述其特有的行为。总之，任何搭配形式都是合法的。
在Lua代码中，只能设置table的元表。若要设置其它类型的值得元表，则必须通过C代码来完成。还存在一个特例，对于字符串，标准的字符串程序库为所有的字符串都设置了一个元表，而其它类型在默认情况下都没有元表。
查看两句代码的打印值，就可以看出来：
代码如下:
print(getmetatable("Hello World"))
print(getmetatable(10))
在table中，我可以重新定义的元方法有以下几个：
代码如下:
__add(a, b) --加法
__sub(a, b) --减法
__mul(a, b) --乘法
__div(a, b) --除法
__mod(a, b) --取模
__pow(a, b) --乘幂
__unm(a) --相反数
__concat(a, b) --连接
__len(a) --长度
__eq(a, b) --相等
__lt(a, b) --小于
__le(a, b) --小于等于
__index(a, b) --索引查询
__newindex(a, b, c) --索引更新
__call(a, ...) --执行方法调用
__tostring(a) --字符串输出
__metatable --保护元表
接下来就介绍介绍如果去重新定义这些算术类的元方法
我们先定义一些对集合的操作方法，所有的方法都放入Set这个table中，
代码如下:
Set = {}
-- 并集操作
function Set.union(a, b)
local retSet = Set.new{} -- 此处相当于Set.new({})
for v in pairs(a) do retSet[v] = true end
for v in pairs(b) do retSet[v] = true end
return retSet
end
-- 打印集合的操作
function Set.toString(set)
local tb = {}
for e in pairs(set) do
tb[#tb + 1] = e
end
return "{" .. table.concat(tb, ", ") .. "}"
end
现在，我定义“+”来计算两个集合的并集，那么就需要让所有用于表示集合的table共享一个元表，并且在该元表中定义如何执行一个加法操作。首先创建一个常规的table，准备用作集合的元表，然后修改Set.new函数，在每次创建集合的时候，都为新的集合设置一个元表。
代码如下:
Set = {}
local mt = {} -- 集合的元表
-- 根据参数列表中的值创建一个新的集合
function Set.new(l)
local set = {}
setmetatable(set, mt)
for _, v in pairs(l) do set[v] = true end
return set
end
在此之后，所有由Set.new创建的集合都具有一个相同的元表，例如：
代码如下:
local set1 = Set.new({10, 20, 30})
local set2 = Set.new({1, 2})
print(getmetatable(set1))
print(getmetatable(set2))
assert(getmetatable(set1) == getmetatable(set2))
最后，我们需要把元方法加入元表中，
代码如下：
mt.__add = Set.union
这以后，只要我们使用“+”符号求两个集合的并集，它就会自动的调用Set.union函数，并将两个操作数作为参数传入。
比如以下代码：
local set1 = Set.new({10, 20, 30})
local set2 = Set.new({1, 2})
local set3 = set1 + set2
Set.print(set3)
在上面列举的那些可以重定义的元方法都可以使用上面的方法进行重定义。
现在就出现了一个新的问题，set1和set2都有元表，那我们要用谁的元表啊？虽然我们这里的示例代码使用的都是一个元表，但是实际coding中，会遇到我这里说的问题，对于这种问题，
Lua是按照以下步骤进行解决的：
1.对于二元操作符，如果第一个操作数有元表，并且元表中有所需要的字段定义，比如我们这里的__add元方法定义，那么Lua就以这个字段为元方法，而与第二个值无关；
2.对于二元操作符，如果第一个操作数有元表，但是元表中没有所需要的字段定义，比如我们这里的__add元方法定义，那么Lua就去查找第二个操作数的元表；
3.如果两个操作数都没有元表，或者都没有对应的元方法定义，Lua就引发一个错误。
以上就是Lua处理这个问题的规则，那么我们在实际编程中该如何做呢？比如set3 = set1 + 8这样的代码，就会打印出以下的错误提示：
lua: test.lua:16: bad argument #1 to 'pairs' (table expected, got number)
但是，我们在实际编码中，可以按照以下方法，弹出我们定义的错误消息，
代码如下:
function Set.union(a, b)
if getmetatable(a) ~= mt or getmetatable(b) ~= mt then
error("metatable error.")
end
local retSet = Set.new{}
for v in pairs(a) do retSet[v] = true end
for v in pairs(b) do retSet[v] = true end
return retSet
end
当两个操作数的元表不是同一个元表时，就表示二者进行并集操作时就会出现问题，那么我们就可以打印出我们需要的错误消息。
上面总结了算术类的元方法的定义，关系类的元方法和算术类的元方法的定义是类似的，这里不做累述。
__tostring元方法
写过Java或者C#的人都知道，Object类中都有一个tostring的方法，程序员可以重写该方法，以实现自己的需求。在Lua中，也是这样的，当我们直接print(a)（a是一个table）时，是不可以的。那怎么办，这个时候，我们就需要自己重新定义__tostring元方法，让print可以格式化打印出table类型的数据。
函数print总是调用tostring来进行格式化输出，当格式化任意值时，tostring会检查该值是否有一个__tostring的元方法，如果有这个元方法，tostring就用该值作为参数来调用这个元方法，剩下实际的格式化操作就由__tostring元方法引用的函数去完成，该函数最终返回一个格式化完成的字符串。
例如以下代码：
mt.__tostring = Set.toString
如何保护我们的“奶酪”——元表
我们会发现，使用getmetatable就可以很轻易的得到元表，使用setmetatable就可以很容易的修改元表，那这样做的风险是不是太大了，那么如何保护我们的元表不被篡改呢？
在Lua中，函数setmetatable和getmetatable函数会用到元表中的一个字段，用于保护元表，该字段是__metatable。当我们想要保护集合的元表，是用户既不能看也不能修改集合的元表，那么就需要使用__metatable字段了；当设置了该字段时，getmetatable就会返回这个字段的值，而setmetatable则会引发一个错误；
如以下演示代码：
function Set.new(l)
local set = {}
setmetatable(set, mt)
for _, v in pairs(l) do set[v] = true end
mt.__metatable = "You cannot get the metatable"
-- 设置完我的元表以后，不让其他人再设置
return set
end
local tb = Set.new({1, 2})
print(tb)
print(getmetatable(tb))
setmetatable(tb, {})
上述代码就会打印以下内容：
代码如下:
{1, 2}
You cannot get the metatable
lua: test.lua:56: cannot change a protected metatable
-----------------------------------------------------------------------------------------
7.1示例
mytable = {} -- 普通表
mt = {} -- 元表
setmetatable(mytable,mt) -- 把 mt 设为 mytable 的元表
以上代码也可以直接写成一行：
mytable = setmetatable({},{})
以下为返回对象元表：
getmetatable(mytable) -- 这回返回mymetatable
测试：
print(mytable)
print(mt);
print(getmetatable(mytable)) -- 这回返回mymetatable
-------------------------------------------------------------------------------------------------------------------------------
7.2__index 元方法
__index元方法
是否还记得当我们访问一个table中不存在的字段时，会返回什么值？默认情况下，当我们访问一个table中不存在的字段时，得到的结果是nil。但是这种状况很容易被改变；
Lua是按照以下的步骤决定是返回nil还是其它值得：
1.当访问一个table的字段时，如果table有这个字段，则直接返回对应的值；
2.当table没有这个字段，则会促使解释器去查找一个叫__index的元方法，接下来就就会调用对应的元方法，返回元方法返回的值；
3.如果没有这个元方法，那么就返回nil结果。
下面通过一个实际的例子来说明__index的使用。假设要创建一些描述窗口，每个table中都必须描述一些窗口参数，位置和大小，这些参数都是有默认值，因此，我们在创建窗口对象时可以指定那些不同于默认值得参数。
代码如下:
-- 创建默认值表
default = {x = 0, y = 0, width = 100, height = 100}
mt = {} -- 创建元表
-- 声明构造函数
function new(o)
setmetatable(o, Windows.mt)
return o
end
-- 定义__index元方法
mt.__index = function (table, key)
return default[key]
end
local win = new({x = 10, y = 10})
print(win.x) -- >10 访问自身已经拥有的值
print(win.width) -- >100 访问default表中的值
print(win.color.r) -- >255 访问default表中的值
print(win.x)时，由于win变量本身就拥有x字段，所以就直接打印了其自身拥有的字段的值；
print(win.width)，由于win变量本身没有width字段，那么就去查找是否拥有元表，元表中是否有__index对应的元方法，由于存在__index元方法，返回了default表中的width字段的值，
在实际编程中，__index元方法不必一定是一个函数，它还可以是一个table。
当它是一个函数时，Lua以table和key作为参数来调用该函数，这就和上面的代码一样；当它是一个table时，Lua就以相同的方式来重新访问这个table，所以上面的代码也可以是这样的：
代码如下:
-- 定义__index元方法
Windows.mt.__index = Windows.default
-------------------------------------------------------------------------------------------------------------------------------
7.3__newindex方法
__newindex元方法
__newindex元方法与__index类似，__newindex用于更新table中的数据，而__index用于查询table中的数据。当对一个table中不存在的索引赋值时，在Lua中是按照以下步骤进行的：
1.Lua解释器先判断这个table是否有元表；
2.如果有了元表，就查找元表中是否有__newindex元方法；如果没有元表，就直接添加这个索引，然后对应的赋值；
3.如果有这个__newindex元方法，Lua解释器就执行它，而不是执行赋值；
4.如果这个__newindex对应的不是一个函数，而是一个table时，Lua解释器就在这个table中执行赋值，而不是对原来的table。
default = {x = 0, y = 0, width = 100, height = 100}
local mt = {
__newindex = function(table, key, value)
print(key .. "字段是不存在的，不要试图给它赋值！");
end
}
local t1 = {};
setmetatable(t1, mt);
t1.sayHello = function()
print("你好lua");
end;
t1.sayHello();
注：当__newindex对应的不是一个函数，而是一个table时。
那么这里就出现了一个问题，
看以下代码：
local tb1 = {}
local tb2 = {}
tb1.__newindex = tb2
tb2.__newindex = tb1
setmetatable(tb1, tb2)
setmetatable(tb2, tb1)
tb1.x = 10
发现什么问题了么？是不是循环了，在Lua解释器中，对这个问题，就会弹出错误消息，错误消息如下：
复制代码 代码如下:
loop in settable
-------------------------------------------------------------------------------------------------------------------------------
function本身也是一种变量，可以作为函数参数使用，还可以作为返回值使用。
function func_name (arguments-list)
statements-list;
end;
Lua语言的一大特色。
-------------------------------------------------------------------------------------------------------------------------------
2.Userdata
userdata专门和Lua的宿主机打交道。userdata 可以将 C 数据存放在 Lua 变量中， userdata 在 Lua 中除了赋值和相等比较外
没有预定义的操作。userdata 用来描述应用程序或者使用 C 实现的库创建的新类型。
例如：用标准 I/O 库来描述文件。
Unity中的GameObject或者组件类。
-------------------------------------------------------------------------------------------------------------------------------
3.表结构 table
table 是 Lua 的一种数据结构用来帮助我们创建不同的数据类型，如：数组、字典等。
Lua table 使用关联型数组，你可以用任意类型的值来作数组的索引，但这个值不能是 nil。
Lua table 是不固定大小的，你可以根据自己需要进行扩容。
Lua也是通过table来解决模块（module）、包（package）和对象（Object）的。
-------------------------------------------------------------------------------------------------------------------------------
4.闭包
当一个函数内部嵌套另一个函数定义时，内部的函数体可以访问外部的函数的局部变量，这种特征我们称作词法定界。很少语言提供这种支持。
简单的说闭包是一个函数加上它可以正确访问的 upvalues。
4.1实例
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
-------------------------------------------------------------------------------------------------------------------------------
5.函数作为table域
函数作为 table 的域（大部分 Lua 标准库使用这种机制来实现的比如 io.read、math.sin） 。这种情况下，必须注意函数和表语法：
-------------------------------------------------------------------------------------------------------------------------------
6.Lua 模块与包
模块类似于一个封装库，从 Lua 5.1 开始，Lua 加入了标准的模块管理机制，可以把一些公用的代码放在一个文件里，以 API 接口的形式在其他地方调用，有利于代码的重用和降低代码耦合度。
-------------------------------------------------------------------------------------------------------------------------------
6.1模块声明
Lua 的模块是由变量、函数等已知元素组成的 table，因此创建一个模块很简单，就是创建一个 table，然后把需要导出的常量、函数放入其中，最后返回这个 table 就行。以下为创建自定义模块 module.lua，文件代码格式如下：
-- 文件名为 module.lua
-- 定义一个名为 module 的模块
module = {}
-- 定义一个常量
module.constant = "这是一个常量"
-- 定义一个函数
function module.func1()
io.write("这是一个公有函数！\n")
end
local function func2()
print("这是一个私有函数！")
end
function module.func3()
func2()
end
--返回这个模块
return module
由上可知，模块的结构就是一个 table 的结构，因此可以像操作调用 table 里的元素那样来操作调用模块里的常量或函数。
上面的 func2 声明为程序块的局部变量，即表示一个私有函数，因此是不能从外部访问模块里的这个私有函数，必须通过模块里的公有函数来调用.
-------------------------------------------------------------------------------------------------------------------------------
6.2引入模块
require 函数：
Lua提供了一个名为require的函数用来加载模块。要加载一个模块，只需要简单地调用就可以了。例如：
require("模块名")
或者
require "模块名"
执行 require 后会返回一个由模块常量或函数组成的 table，并且还会定义一个包含该 table 的全局变量。
-- module 模块为上文提到到 module.lua
require("module")
print(module.constant)
module.func3()
module.func2() --报错
或者给加载的模块定义一个别名变量，方便调用：
local m = require("module")
print(m.constant)
m.func3()
加载机制
对于自定义的模块，模块文件不是放在哪个文件目录都行，函数 require 有它自己的文件路径加载策略，它会尝试从 Lua 文件或 C 程序库中加载模块。
require 用于搜索 Lua 文件的路径是存放在全局变量 package.path 中，当 Lua 启动后，会以环境变量 LUA_PATH 的值来初始这个环境变量。如果没有找到该环境变量，则使用一个编译时定义的默认路径来初始化。
-------------------------------------------------------------------------------------------------------------------------------
7.Lua 元表(Metatable)
元表对应的英文是metatable，元方法是metamethod。我们都知道，在C++中，两个类是无法直接相加的，但是，如果你重载了“+”符号，就可以进行类的加法运算。在Lua中也有这个道理，两个table类型的变量，你是无法直接进行“+”操作的，如果你定义了一个指定的函数，就可以进行了。
Lua是怎么做的？
通常，Lua中的每个值都有一套预定义的操作集合，比如数字是可以相加的，字符串是可以连接的，但是对于两个table类型，则不能直接进行“+”操作。这需要我们进行一些操作。在Lua中有一个元表，也就是上面说的metatable，我们可以通过元表来修改一个值得行为，使其在面对一个非预定义的操作时执行一个指定的操作。比如，现在有两个table类型的变量a和b，我们可以通过metatable定义如何计算表达式a+b，具体的在Lua中是按照以下步骤进行的：
1.先判断a和b两者之一是否有元表；
2.检查该元表中是否有一个叫__add的字段；
3.如果找到了该字段，就调用该字段对应的值，这个值对应的是一个metamethod；（Lua中方法是可以放在一个字段中的）
4.调用__add对应的metamethod计算a和b的值。
上述四个步骤就是计算table类型变量a+b的过程。在Lua中，每个值都有一个元表，table和userdata类型的每个变量都可以有各自独立的元表，而其他类型的值则共享其类型所属的单一元表。
现在就说说最基本的metatable内容。Lua在创建新的table时不会创建元表，比如以下代码就可以演示：
代码如下:
local t = {1, 2}
print(getmetatable(t)) -- nil
我们是使用getmetatable来获取一个table或userdata类型变量的元表，当创建新的table变量时，使用getmetatable去获得元表，将返回nil；同理，我们也可以使用setmetatable去设置一个table或userdata类型变量的元表，
例如代码如下:
local t = {}
print(getmetatable(t)) -->nil
local t1 = {}
setmetatable(t, t1)
assert(getmetatable(t) == t1)
任何table都可以作为任何值得元表，而一组相关的table又可以共享一个通用的元表，此元表描述了它们共同的行为。一个table甚至可以作为它自己的元表，用于描述其特有的行为。总之，任何搭配形式都是合法的。
在Lua代码中，只能设置table的元表。若要设置其它类型的值得元表，则必须通过C代码来完成。还存在一个特例，对于字符串，标准的字符串程序库为所有的字符串都设置了一个元表，而其它类型在默认情况下都没有元表。
查看两句代码的打印值，就可以看出来：
代码如下:
print(getmetatable("Hello World"))
print(getmetatable(10))
在table中，我可以重新定义的元方法有以下几个：
代码如下:
__add(a, b) --加法
__sub(a, b) --减法
__mul(a, b) --乘法
__div(a, b) --除法
__mod(a, b) --取模
__pow(a, b) --乘幂
__unm(a) --相反数
__concat(a, b) --连接
__len(a) --长度
__eq(a, b) --相等
__lt(a, b) --小于
__le(a, b) --小于等于
__index(a, b) --索引查询
__newindex(a, b, c) --索引更新
__call(a, ...) --执行方法调用
__tostring(a) --字符串输出
__metatable --保护元表
接下来就介绍介绍如果去重新定义这些算术类的元方法
我们先定义一些对集合的操作方法，所有的方法都放入Set这个table中，
代码如下:
Set = {}
-- 并集操作
function Set.union(a, b)
local retSet = Set.new{} -- 此处相当于Set.new({})
for v in pairs(a) do retSet[v] = true end
for v in pairs(b) do retSet[v] = true end
return retSet
end
-- 打印集合的操作
function Set.toString(set)
local tb = {}
for e in pairs(set) do
tb[#tb + 1] = e
end
return "{" .. table.concat(tb, ", ") .. "}"
end
现在，我定义“+”来计算两个集合的并集，那么就需要让所有用于表示集合的table共享一个元表，并且在该元表中定义如何执行一个加法操作。首先创建一个常规的table，准备用作集合的元表，然后修改Set.new函数，在每次创建集合的时候，都为新的集合设置一个元表。
代码如下:
Set = {}
local mt = {} -- 集合的元表
-- 根据参数列表中的值创建一个新的集合
function Set.new(l)
local set = {}
setmetatable(set, mt)
for _, v in pairs(l) do set[v] = true end
return set
end
在此之后，所有由Set.new创建的集合都具有一个相同的元表，例如：
代码如下:
local set1 = Set.new({10, 20, 30})
local set2 = Set.new({1, 2})
print(getmetatable(set1))
print(getmetatable(set2))
assert(getmetatable(set1) == getmetatable(set2))
最后，我们需要把元方法加入元表中，
代码如下：
mt.__add = Set.union
这以后，只要我们使用“+”符号求两个集合的并集，它就会自动的调用Set.union函数，并将两个操作数作为参数传入。
比如以下代码：
local set1 = Set.new({10, 20, 30})
local set2 = Set.new({1, 2})
local set3 = set1 + set2
Set.print(set3)
在上面列举的那些可以重定义的元方法都可以使用上面的方法进行重定义。
现在就出现了一个新的问题，set1和set2都有元表，那我们要用谁的元表啊？虽然我们这里的示例代码使用的都是一个元表，但是实际coding中，会遇到我这里说的问题，对于这种问题，
Lua是按照以下步骤进行解决的：
1.对于二元操作符，如果第一个操作数有元表，并且元表中有所需要的字段定义，比如我们这里的__add元方法定义，那么Lua就以这个字段为元方法，而与第二个值无关；
2.对于二元操作符，如果第一个操作数有元表，但是元表中没有所需要的字段定义，比如我们这里的__add元方法定义，那么Lua就去查找第二个操作数的元表；
3.如果两个操作数都没有元表，或者都没有对应的元方法定义，Lua就引发一个错误。
以上就是Lua处理这个问题的规则，那么我们在实际编程中该如何做呢？比如set3 = set1 + 8这样的代码，就会打印出以下的错误提示：
lua: test.lua:16: bad argument #1 to 'pairs' (table expected, got number)
但是，我们在实际编码中，可以按照以下方法，弹出我们定义的错误消息，
代码如下:
function Set.union(a, b)
if getmetatable(a) ~= mt or getmetatable(b) ~= mt then
error("metatable error.")
end
local retSet = Set.new{}
for v in pairs(a) do retSet[v] = true end
for v in pairs(b) do retSet[v] = true end
return retSet
end
当两个操作数的元表不是同一个元表时，就表示二者进行并集操作时就会出现问题，那么我们就可以打印出我们需要的错误消息。
上面总结了算术类的元方法的定义，关系类的元方法和算术类的元方法的定义是类似的，这里不做累述。
__tostring元方法
写过Java或者C#的人都知道，Object类中都有一个tostring的方法，程序员可以重写该方法，以实现自己的需求。在Lua中，也是这样的，当我们直接print(a)（a是一个table）时，是不可以的。那怎么办，这个时候，我们就需要自己重新定义__tostring元方法，让print可以格式化打印出table类型的数据。
函数print总是调用tostring来进行格式化输出，当格式化任意值时，tostring会检查该值是否有一个__tostring的元方法，如果有这个元方法，tostring就用该值作为参数来调用这个元方法，剩下实际的格式化操作就由__tostring元方法引用的函数去完成，该函数最终返回一个格式化完成的字符串。
例如以下代码：
mt.__tostring = Set.toString
如何保护我们的“奶酪”——元表
我们会发现，使用getmetatable就可以很轻易的得到元表，使用setmetatable就可以很容易的修改元表，那这样做的风险是不是太大了，那么如何保护我们的元表不被篡改呢？
在Lua中，函数setmetatable和getmetatable函数会用到元表中的一个字段，用于保护元表，该字段是__metatable。当我们想要保护集合的元表，是用户既不能看也不能修改集合的元表，那么就需要使用__metatable字段了；当设置了该字段时，getmetatable就会返回这个字段的值，而setmetatable则会引发一个错误；
如以下演示代码：
function Set.new(l)
local set = {}
setmetatable(set, mt)
for _, v in pairs(l) do set[v] = true end
mt.__metatable = "You cannot get the metatable"
-- 设置完我的元表以后，不让其他人再设置
return set
end
local tb = Set.new({1, 2})
print(tb)
print(getmetatable(tb))
setmetatable(tb, {})
上述代码就会打印以下内容：
代码如下:
{1, 2}
You cannot get the metatable
lua: test.lua:56: cannot change a protected metatable
-----------------------------------------------------------------------------------------
7.1示例
mytable = {} -- 普通表
mt = {} -- 元表
setmetatable(mytable,mt) -- 把 mt 设为 mytable 的元表
以上代码也可以直接写成一行：
mytable = setmetatable({},{})
以下为返回对象元表：
getmetatable(mytable) -- 这回返回mymetatable
测试：
print(mytable)
print(mt);
print(getmetatable(mytable)) -- 这回返回mymetatable
-------------------------------------------------------------------------------------------------------------------------------
7.2__index 元方法
__index元方法
是否还记得当我们访问一个table中不存在的字段时，会返回什么值？默认情况下，当我们访问一个table中不存在的字段时，得到的结果是nil。但是这种状况很容易被改变；
Lua是按照以下的步骤决定是返回nil还是其它值得：
1.当访问一个table的字段时，如果table有这个字段，则直接返回对应的值；
2.当table没有这个字段，则会促使解释器去查找一个叫__index的元方法，接下来就就会调用对应的元方法，返回元方法返回的值；
3.如果没有这个元方法，那么就返回nil结果。
下面通过一个实际的例子来说明__index的使用。假设要创建一些描述窗口，每个table中都必须描述一些窗口参数，位置和大小，这些参数都是有默认值，因此，我们在创建窗口对象时可以指定那些不同于默认值得参数。
代码如下:
-- 创建默认值表
default = {x = 0, y = 0, width = 100, height = 100}
mt = {} -- 创建元表
-- 声明构造函数
function new(o)
setmetatable(o, Windows.mt)
return o
end
-- 定义__index元方法
mt.__index = function (table, key)
return default[key]
end
local win = new({x = 10, y = 10})
print(win.x) -- >10 访问自身已经拥有的值
print(win.width) -- >100 访问default表中的值
print(win.color.r) -- >255 访问default表中的值
根据上面代码的输出，
print(win.width)，由于win变量本身没有width字段，那么就去查找是否拥有元表，元表中是否有__index对应的元方法，由于存在__index元方法，返回了default表中的width字段的值，
在实际编程中，__index元方法不必一定是一个函数，它还可以是一个table。
当它是一个函数时，Lua以table和key作为参数来调用该函数，这就和上面的代码一样；当它是一个table时，Lua就以相同的方式来重新访问这个table，所以上面的代码也可以是这样的：
代码如下:
-- 定义__index元方法
Windows.mt.__index = Windows.default
-------------------------------------------------------------------------------------------------------------------------------
7.3__newindex方法
__newindex元方法
__newindex元方法与__index类似，__newindex用于更新table中的数据，而__index用于查询table中的数据。当对一个table中不存在的索引赋值时，在Lua中是按照以下步骤进行的：
1.Lua解释器先判断这个table是否有元表；
2.如果有了元表，就查找元表中是否有__newindex元方法；如果没有元表，就直接添加这个索引，然后对应的赋值；
3.如果有这个__newindex元方法，Lua解释器就执行它，而不是执行赋值；
4.如果这个__newindex对应的不是一个函数，而是一个table时，Lua解释器就在这个table中执行赋值，而不是对原来的table。
default = {x = 0, y = 0, width = 100, height = 100}
local mt = {
__newindex = function(table, key, value)
print(key .. "字段是不存在的，不要试图给它赋值！");
end
}
local t1 = {};
setmetatable(t1, mt);
t1.sayHello = function()
print("你好lua");
end;
t1.sayHello();
注：当__newindex对应的不是一个函数，而是一个table时。
那么这里就出现了一个问题，
看以下代码：
local tb1 = {}
local tb2 = {}
tb1.__newindex = tb2
tb2.__newindex = tb1
setmetatable(tb1, tb2)
setmetatable(tb2, tb1)
tb1.x = 10
发现什么问题了么？是不是循环了，在Lua解释器中，对这个问题，就会弹出错误消息，错误消息如下：
复制代码 代码如下:
loop in settable
-------------------------------------------------------------------------------------------------------------------------------