Unity开发中Lua的常用技巧
项目中使用 Lua 场景较多，有一些关于 Lua 编码的技巧或者常用操作，有时还会对 Lua 的一些API进行扩展，特此记录一下，随时会补充，另外不当的写法会导致性能问题，应该尽量避免，Roberto Ierusalimschy 的 《Lua Performance Tips》 这篇文章提供了一些非常有用的建议。关于如何让 Lua 变得更好用这个问题，逐步完善呗，遇到的优秀的 Lua 库我也会更新在这里～
Lua常用风格与技巧
Lua中实现三目运算符
A and B or C（ B 不能为 false ）
遍历table
在遍历 table 的时候，常用i表示 pairs 下的数组下标，k 表示 pairs 下的键值对的键，v 表示对应的值
1local map = {
2 k1 = "hello",
3 k2 = "world",
4 k3 = "lua"
5}
6
7for k, v in pairs(map) do
8 print(k, v)
9end
10
11local arr = {
12 "hello", "world", "lua"
13}
14
15for i, v in ipairs(arr) do
16 print(i, v)
17end
如果 index / key 不重要，使用 _ 代替
1local map = {
2 k1 = "hello",
3 k2 = "world",
4 k3 = "lua"
5}
6
7for _, v in pairs(map) do
8 print(v)
9end
给变量设置默认值
习惯给变量设置默认值，增加代码的健壮性！
向 table 中插入元素尽可能少使用 table.insert() 函数！
1local testTbl1, testTbl2 = {1, 2, 3}, {}
2
3for i, v in pairs(testTbl1) do
4 -- 使用table.insert()
5 table.insert(testTbl2, v)
6end
7
8for i, v in pairs(testTbl1) do
9 -- 使用[]和#，避免高层的函数调用开销
10 testTbl2[#testTbl2 + 1] = v
11end
交换变量的值
尽可能使用局部变量（ local ）
因为在 Lua 中访问局部变量比访问全局变量快很多！
可以参考这本书 《Lua Performance Tips》 ，下面会有其翻译。
Lua排序问题
table.sort 函数的本质是快排算法，当锚点的值与边界值相等，这时如果排序方法 sort_comp 返回 true，则会造成数组越界，而解决方案也很简单：当比较的两个值相等时，返回 false 即可，所以使用 table.sort 时要注意这一点，否则会报 invalid order function for sorting
1local sortRule = function(a, b)
2 if a.x > b.x then
3 return true
4 elseif a.x < b.x then
5 return false
6 else
7 if a.y < b。y then
8 return false
9 elseif a.y > b.y then
10 return true
11 else --- 在都相等时一定要返回 false
12 return false
13 end
14 end
15end
时间日期转换
时间戳转换日期+时间
1return os.date("%Y-%m-%d %H:%M:%S", os.time())
日期转时间戳
1os.time({day=12, month=12, year=2022, hour=14, minute=0, second=0})
当前时间戳(秒级别)
1os.time()
转成年月日接口
1function Tool.FormatUnixTime2Date(unixTime)
2 if unixTime and unixTime >= 0 then
3 local tb = {}
4 tb.year = tonumber(os.date("%Y",unixTime))
5 tb.month =tonumber(os.date("%m",unixTime))
6 tb.day = tonumber(os.date("%d",unixTime))
7 tb.hour = tonumber(os.date("%H",unixTime))
8 tb.minute = tonumber(os.date("%M",unixTime))
9 tb.second = tonumber(os.date("%S",unixTime))
10 return tb
11 end
12end
Lua方法扩展
string相关
1function string.trim(input)
2 input = string.gsub(input, "^[ \t\n\r]+", "")
3 return string.gsub(input, "[ \t\n\r]+$", "")
4end
5
6-- 截取指定长度
7function string.GetMaxLenString(s, maxLen)
8 local len = string.GetUTFLen(s)
9
10 local dstString = s
11 -- 超长，裁剪，加...
12 if len > maxLen then
13 dstString = string.sub(s, 1, string.GetUTFLenWithCount(s, maxLen))
14 dstString = dstString..""
15 end
16
17 return dstString
18end
19
20function string.StringToTable(s)
21 local tb = {}
22 for utfChar in string.gmatch(s, "[%z\1-\127\194-\244][\128-\191]*") do
23 table.insert(tb, utfChar)
24 end
25 return tb
26end
27
28function string.GetUTFLenWithCount(s, count)
29 local sTable = string.StringToTable(s)
30
31 local len = 0
32 local charLen = 0
33 local isLimited = (count >= 0)
34
35 for i=1,#sTable do
36 local utfCharLen = string.len(sTable[i])
37 if utfCharLen > 1 then -- 长度大于1的就认为是中文
38 charLen = 2
39 else
40 charLen = 1
41 end
42 len = len + utfCharLen
43 if isLimited then
44 count = count - charLen
45 if count <= 0 then
46 break
47 end
48 end
49 end
50 return len
51end
52
53function string.GetUTFLen(s)
54 local sTable = string.StringToTable(s)
55
56 local len = 0
57 local charLen = 0
58
59 for i=1, #sTable do
60 local utfCharLen = string.len(sTable[i])
61 if utfCharLen > 1 then -- 长度大于1的就认为是中文
62 charLen = 2
63 else
64 charLen = 1
65 end
66 len = len + charLen
67 end
68 return len
69end
70
71
72print(string.GetMaxLenString("中文名字超级长超级长", 8)) -- 中文名字
73
74function string.ltrim(input)
75 return string.gsub(input, "^[ \t\n\r]+", "")
76end
77
78
79function string.rtrim(input)
80 return string.gsub(input, "[ \t\n\r]+$", "")
81end
82
math相关
1--- 四舍五入
2function math.round(value)
3 value = tonumber(value) or 0
4 return math.floor(value + 0.5)
5end
遇到了会随时补充
Lua库开源库
面向对象 https://github.com/kikito/middleclass
JSON库 https://github.com/Tencent/rapidjson/ https://github.com/rxi/json.lua
网络库 https://github.com/lunarmodules/luasocket
文件工具库 https://github.com/lunarmodules/luafilesystem
工具扩展库（Python风格） https://github.com/lunarmodules/Penlight
包管理器 luarocks https://luarocks.org/
Lua Performance Tips 翻译
关于性能优化的两条格言：
规则 1：不要优化
规则 2：还是不要优化（仅限专家）
不要在缺乏恰当度量（measurements）时试图去优化软件。编程老手和菜鸟之间的区别不是说老手更善于洞察程序的性能瓶颈，而是老手知道他们并不善于此。
做性能优化离不开度量。优化前度量，可知何处需要优化。优化后度量，可知「优化」是否确实改进了代码。
基本事实
运行代码之前，Lua 会把源代码翻译（预编译）成一种内部格式，这种格式由一连串虚拟机的指令构成，与真实 CPU 的机器码很相似。接下来，这一内部格式交由 C 代码来解释，基本上就是一个 while 循环，里面有一个很大的 switch，一种指令对应一个 case。
也许你已从他处得知，自 5.0 版起，Lua 使用了一个基于寄存器的虚拟机。这些「寄存器」跟 CPU 中真实的寄存器并无关联，因为这种关联既无可移植性，也受限于可用的寄存器数量。Lua 使用一个栈（由一个数组加上一些索引实现）来存放它的寄存器。每个活动的（active）函数都有一份活动记录（activation record），活动记录占用栈的一小块，存放着这个函数对应的寄存器。因此，每个函数都有其自己的寄存器。由于每条指令只有 8 个 bit 用来指定寄存器，每个函数便可以使用多至 250 个寄存器。
Lua 的寄存器如此之多，预编译时便能将所有的局部变量存到寄存器中。所以，在 Lua 中访问局部变量是很快的。举个例子， 如果 a 和 b 是局部变量，语句 a = a + b 只生成一条指令：ADD 0 0 1（假设 a 和 b 分别在寄存器 0 和 1 中）。对比之下，如果 a 和 b 是全局变量，生成上述加法运算的指令便会如下：
所以，不难证明，要想改进 Lua 程序的性能，最重要的一条原则就是：使用局部变量（use locals）！
除了一些明显的地方外，另有几处也可使用局部变量，可以助你挤出更多的性能。比如，如果在很长的循环里调用函数，可以先将这个函数赋值给一个局部变量。这个代码：
比如下代码慢 30%：
访问外层局部变量（也就是外一层函数的局部变量）并没有访问局部变量快，但是仍然比访问全局变量快。考虑如下代码：
1function foo(x)
2 for i = 1, 1000000 do
3 x = x + math.sin(i)
4 end
5 return x
6end
7print(foo(10))
我们可以通过在 foo 函数外面定义一个 sin 来优化它:
1local sin = math.sin
2function foo(x)
3 for i = 1, 1000000 do
4 x = x + sin(i)
5 end
6 return x
7end
8print(foo(10))
第二段代码比第一段快 30%。
与其他语言的编译器相比，Lua 的编译器算是比较高效的，尽管如此，编译仍是一项繁重的任务。所以，应尽量避免在程序中编译代码（比如，使用 loadstring 函数）。除非需要真正动态地执行代码，比如代码是由用户输入的，其他情况则很少需要编译动态的代码。
举个例子，下面的代码创建一个包含 10000 个函数的表，表中的函数分别返回常量 1 到 10000：
1local lim = 10000
2local a = {}
3for i = 1, lim do
4 a[i] = loadstring(string.format("return %d", i))
5end
6print(a[10]()) --> 10
这段代码运行了 1.4 秒。
使用闭包，可以避免动态编译。下面的代码创建同样的 10000 个函数只用了 1/10 的时间（0.14秒）：
1function fk (k)
2 return function () return k end
3end
4local lim = 100000
5local a = {}
6for i = 1, lim do a[i] = fk(i) end
7print(a[10]()) --> 10
关于表
通常，使用表（table）时并不需要知道它的实现细节。事实上，Lua 尽力避免把实现细节暴露给用户。然而这些细节还是在表操作的性能中暴露出来了。所以，为了高效地使用表，了解一些 Lua 实现表的方法，不无益处。
Lua 实现表的算法颇为巧妙。每个表包含两部分：数组（array）部分和哈希（hash）部分，数组部分保存的项（entry）以整数为键（key），从 1 到某个特定的 n，（稍后会讨论 n 是怎么计算的。）所有其他的项（包括整数键超出范围的）则保存在哈希部分。
顾名思义，哈希部分使用哈希算法来保存和查找键值。它使用的是开放寻址（open address）的表，意味着所有的项都直接存在哈希数组里。键值的主索引由哈希函数给出；如果发生冲突（两个键值哈希到相同的位置），这些键值就串成一个链表，链表的每个元素占用数组的一项。
当 Lua 想在表中插入一个新的键值而哈希数组已满时，Lua 会做一次重新哈希（rehash）。重新哈希的第一步是决定新的数组部分和哈希部分的大小。所以 Lua 遍历所有的项，并加以计数和分类，然后取一个使数组部分用量过半的最大的 2 的指数值，作为数组部分的大小。而哈希部分的大小则是一个容得下剩余项（即那些不适合放在数组部分的项）的最小的 2 的指数值。
当 Lua 创建一个空表时，两部分的大小都是 0，因此也就没有为它们分配数组空间。看看如下代码运行时会发生些什么：
一开始创建一个空表。循环的第一次迭代时，赋值语句 a[1] = true 触发了一次重新哈希；Lua 将表中的数组部分大小设为 1，而哈希部分仍为空。循环的第二次迭代时，赋值语句 a[2] = true 又触发了一次重新哈希，现在，表中的数组部分大小为 2。最后，第三次迭代还是触发了一次重新哈希，数组部分的大小增至 4。
像下面这样的代码：
做的事情类似，大小增长的却是表的哈希部分。
对于大型的表，这些初始的开销将会被整个创建过程平摊：创建 3 个元素的表需要进行 3 次重新哈希，而创建一百万个元素的表只需要 20 次。但是当你创建几千个小表时，总开销就会很显著。
老版的 Lua 在创建空表时会预分配一些空位（如果没记错，是 4），来避免这种创建小表时的初始开销。不过，这样又有浪费内存之嫌。比如，以仅有两个项的表来表示点，每个点使用的内存就是真正所需内存的两倍，那么创建几百万个点将会使你付出高昂的代价。这就是现在 Lua 不为空表预分配空位的原因。
如果你用的是 C，可以通过 Lua 的 API 函数 lua_createtable 来避免这些重新哈希。这个函数除了司空见惯的参数 lua_State 外，另接受两个参数：新表数组部分的初始大小和哈希部分的初始大小。只要这两个参数给得恰当，就能避免初始时的重新哈希。不过需要注意的是，Lua 只在重新哈希时才有机会去收缩（shrink）表。所以，如果你指定的初始大小大于实际所需，空间的浪费 Lua 可能永远都不会为你纠正。
如果你用的是 Lua，可以通过构造器（constructors）来避免那些初始的重新哈希。当你写下 {true, true, true} 时，Lua 就会事先知道新表的数组部分需要 3 个空位，并创建一个相应大小的表。与此类似，当你写下 {x = 1, y = 2, z = 3} 时，Lua 就创建一个哈希部分包含 4 个空位的表。举例来说，下面的循环运行了 2.0 秒：
如果以正确的大小来创建这个表，运行时间就降到了 0.7 秒：
然而，当你写下形如 {[1] = true, [2] = true, [3] = true} 这样的语句时，Lua 并没有聪明到能够检测出给定的表达式（指那些字面数字）是在描述数组下标，所以它创建了一个哈希部分有 4 个空位的表，既浪费内存也浪费 CPU 时间。
表的两个部分的大小只在表重新哈希时计算，而重新哈希只在表已全满而又需要插入新元素时才会发生。因此，当你遍历一个表并把个中元素逐一删除时（即设它们为 nil），表并不会缩小。你得往表里插些新的元素，然后表才会真正去调整大小。通常这不是一个问题：当你持续地删除和插入元素时（很多程序的典型情况），表的大小将保持稳定。不过，你不该期望通过从一个大表里删除一些数据来回收内存，更好的做法是删除这个表本身。
有一则强制重新哈希的奇技淫巧，即往表里插入足够的 nil 元素。示例如下：
1a = {}
2lim = 10000000
3for i = 1, lim do a[i] = i end -- 创建一个巨大的表
4print(collectgarbage("count")) -->196626
5for i = 1, lim do a[i] = nil end -- 删除其所有的元素
6print(collectgarbage("count")) -->196626
7for i = lim + 1, 2*lim do a[i] = nil end -- 插入大量nil元素
8print(collectgarbage("count")) --> 17
除非特殊情况需要，我并不推荐这种手法，因为这样做很慢，而且要知道多少元素才算「足够」，也没有简单易行的方法。
你可能会想，Lua 为什么不在我们插入 nil 时收缩表的大小呢？首先，是为了避免对插入元素的检查；一条检查 nil 赋值的语句将会拖慢所有的赋值语句。其次，也是更重要的，是为了允许在遍历表时对元素赋 nil 值。考虑如下循环：
如果 Lua 在 nil 赋值后进行重新哈希，那么这个遍历就被破坏了。
如果你想删除表中的所有元素，正确的方法是使用一个简单的循环：
或者使用"聪明"一点的方法：
不过，这个循环在表很大时会很慢。调用函数 next 时，如果没有传入前一个键值，返回的便是表的「第一个」元素（以某种随机顺序）。（译：「第一个」之所以加引号，是指就表内部的数组结构而言的第一个元素，以某种随机顺序 则是从表的角度或用户使用表的角度来说。）为此，next 从头遍历表的数组空间（译：包含数组和哈希两部分），查找一个非 nil 元素。随着循环逐一将这些第一个元素设为 nil，查找第一个非 nil 元素变得越来越久。结果是，为了清除一个有 100000 个元素的表，这个“聪明”的循环用了 20 秒，而使用 pairs 遍历表的循环只用了 0.04 秒。
关于字符串
和表一样，了解 Lua 实现字符串的细节对高效地使用字符串也会有所帮助。
Lua 实现字符串的方式和大多数其他的脚本语言有两点重要的区别。其一，Lua 的字符串都是内化的（internalized）；这意味着字符串在 Lua 中都只有一份拷贝。每当一个新字符串出现时，Lua 会先检查这个字符串是否已经有一份拷贝，如果有，就重用这份拷贝。内化（internalization）使字符串比较及表索引这样的操作变得非常快，但是字符串的创建会变慢。
其二，Lua 的字符串变量从来不会包含字符串本身，包含的只是字符串的引用。这种实现加快了某些字符串操作。比如，对 Perl 来说，如果你写下这样的语句：$x = $y，$y 包含一个字符串，这个赋值语句将复制 $y 缓冲区里的字符串内容到 $x 的缓冲区中。如果字符串很长，这一操作代价将非常高。而对 Lua 来说，这样的赋值语句只不过复制了一个指向实际字符串的指针。
这种使用引用的实现，使某种特定形式的字符串连接变慢了。在 Perl 里，$s = $s . "x" 和 $s .= "x" 这两者是很不一样的。前一个语句，先得到一份 $s 的拷贝，然后往这份拷贝的末尾加上 “x”。后一个语句，只是简单地把 “x” 追加到变量 $s 所持有的内部缓冲区上。所以，第二种连接形式跟字符串大小是无关的（假设缓冲区有足够的空间来存放连接的字符串）。如果在循环中执行这两条语句，那么它们的区别就是算法复杂度的线性阶和平方阶的区别了。比如，以下循环读一个 5MB 的文件，几乎用了 5 分钟：
如果将 $x = $x . $_ 替换成 $x .= $_，则只要 0.1 秒！
Lua 并没有提供这第二种较快的方法，因为 Lua 的变量并没有与之关联的缓冲区。所以，我们必须使用一个显式的缓冲区：包含字符串片段的表就行。以下循环还是读 5MB 的文件，费时 0.28 秒。没 Perl 那么快，不过也不赖。
减少、重用、回收
当处理 Lua 资源时，我们应当遵守跟利用地球资源一样的 3R 原则。
减少（reduce）是最简单的一种途径。有几种方法可以避免创建对象。例如，如果你的程序使用了大量的表，或许可以考虑改变它的数据表示。举个简单的例子，假如你的程序需要处理折线（polyline）。在 Lua 里，折线最自然的表示是使用一个点的列表，像这样：
1polyline = {
2 { x = 10.3, y = 98.5 },
3 { x = 10.3, y = 18.3 },
4 { x = 15.0, y = 98.5 },
5 ...
6}
这种表示虽然自然，折线较大时却不经济，因为每个点都要用一个表。下面这种表示改用数组，内存略为节省：
对于一条有一百万个点的折线，这种改变使内存用量从 95KB 降到 65KB。当然，作为代价，程序的可读性有所损失：p[i].x 要比 p[i][4] 易懂得多。
还有一个更经济的方法，用两个列表，一个存 x 坐标的值，一个存 y 坐标的值：
之前的 p[i].x现在就是 p.x[i]。使用这种方式，一条有一百万个点的折线只需 24KB 的内存。
循环是寻找降低不必要资源创建的好地方。例如，如果在循环中创建了一个常量的（constant）表，便可以把表移到循环之外，或者甚至可以移到外围函数之外。比较如下两段代码：
1function foo (...)
2 for i = 1, n do
3 local t = {1, 2, 3, "hi"}
4 -- 做一些不改变 t 的操作
5 ...
6 end
7end
1local t = {1, 2, 3, "hi"} -- 一次性地创建 t
2function foo (...)
3 for i = 1, n do
4 -- 做一些不改变 t 的操作
5 ...
6 end
7end
同样的技巧也可以用于闭包，只要移动时不致越出闭包所需变量的作用域。例如，考虑以下函数：
1function changenumbers (limit, delta)
2 for linein io.lines() do
3 line = string.gsub(line, "%d+", function (num)
4 num = tonumber(num)
5 if num >= limit then return tostring(num + delta) end
6 -- else return nothing, keeping the original number
7 end)
8 io.write(line, "\n")
9 end
10end
只要将内部（inner）函数移到循环之外，就可避免为每一行都创建一个新的闭包：
1function changenumbers (limit, delta)
2 local function aux (num)
3 num = tonumber(num)
4 if num >= limit then return tostring(num + delta) end
5 end
6 for linein io.lines() do
7 line = string.gsub(line, "%d+", aux)
8 io.write(line, "\n")
9 end
10end
不过，不能将函数 aux 移到函数 changenumbers 之外，那样的话，函数 aux 就不能访问变量 limit 和 delta 了。
很多字符串的处理，都可以通过在现有字符串上使用下标，来避免创建不必要的新字符串。例如，函数 string.find 返回的是给定模式出现的位置，而不是一个与之匹配的字符串。返回下标，就避免了在成功匹配时创建一个新的（子）字符串。若有需要，可以再通过函数 string.sub 来获取匹配的子字符串。
即使不能避免使用新的对象，也可以通过 重用（reuse）来避免创建新的对象。对字符串来说，重用是没有必要的，因为 Lua 已经替我们这样做了：所有的字符串都是内化的（internalized），因此只要可能就会重用。对表来说，重用就显得卓有成效了。举一个常见的例子，让我们回到在循环内创建表的情况。不同的是，这次的表是可变的（not constant）。不过，往往只需简单的改变内容，还是可以在所有的迭代中重用同一个表的。考虑以下代码：
以下代码与之等价，但是重用了表：
1local t = {}
2local aux = {year = nil, month = 6, day = 14}
3for i = 1970, 2000 do
4 aux.year = i
5 t[i] = os.time(aux)
6end
实现重用的一种特别有效的方法是记忆化（memoizing）。基本想法非常简单：对于一个给定的输入，保存其计算结果，当遇到同样的输入时，程序只需重用之前保存的结果。
来看看 LPeg（Lua 中一个新的模式匹配的包），它使用记忆化的方式颇为有趣。LPeg 把每个模式都编译成一种内部表示，对负责匹配的分析器来说，这种表示就是一种「程序」。这种编译相对于匹配本身来说是比较费时的。因此为了重用，LPeg 便记住编译的结果，方式是用一个表，把描述模式的字符串和相应的内部表示关联起来。
记忆化方法的一个比较普遍的问题是，保存之前结果而在空间上的花费可能会甚于重用这些结果的好处。为了解决这个问题，我们可以使用弱表（weak table），这样，不用的结果最后就会从表中删除。
借助于高阶函数（higher-order functions），我们可以定义一个通用的记忆化函数：
1function memoize (f)
2 local mem = {} -- memoizing table
3 setmetatable(mem, {__mode = "kv"}) -- make it weak
4 return function (x) -- new version of 'f', with memoizing
5 local r = mem[x]
6 if r == nil then -- no previous result?
7 r = f(x) -- calls original function
8 mem[x] = r -- store result for reuse
9 end
10 return r
11 end
12end
对于一个给定的函数 f，memoize(f) 返回一个新的函数，这个函数会返回跟 f 一样的结果，但是会把结果记录下来。例如，我们可以重新定义 loadstring 函数的一个记忆化版本：
1loadstring = memoize(loadstring)
新函数的使用方式和老函数一样，但是如果我们加载的字符串中有很多重复的字符串，便会获得很大的性能提升。
如果你的程序创建和释放过多的协程（coroutines），也许可以通过 回收（recycle）来提高它的性能。目前协程的 API 并没有直接提供重用协程的方法，但是我们可以设法克服这一限制。考虑以下协程：
这个协程接受一个作业（job）（一个待执行的函数），执行这个作业，结束后等待下一个作业。
Lua 中的大多数回收都是由垃圾收集器自动完成的。Lua 使用一个增量（incremental）的垃圾收集器，逐步（in small steps）回收（增量地），跟程序一起交错执行。每一步回收多少，跟内存分配成正比：Lua 分配了多少内存，垃圾收集器就做多少相应比例的工作。程序消耗内存越快，收集器尝试回收内存也就越快。
如果我们在程序中遵守减少和重用的原则，收集器通常没有太多的事情可做。但是有时候我们不能避免创建大量的垃圾，这时收集器就可能变得任务繁重了。Lua 的垃圾收集器是为一般的程序而设的，对大多数应用来说，它的表现都是相当不错的。但是有时候，某些特殊的应用场景，适当地调整收集器还是可以提高性能的。
要控制垃圾收集器，可以调用 Lua 的函数 collectgarbage，或者 C 函数 lua_gc。尽管接口不同，这两个函数的功能基本一致。接下来的讨论我会使用 Lua 函数，虽然这种操作往往更适合在 C 里面做。
函数 collectgarbage 提供了这样几种功能：它可以停止和重启收集器，强制进行一次完整的收集，强制执行一步收集（collection step），得到当前内存使用总量，更改两个影响收集效率（pace）的参数。所有这些操作在缺乏内存的程序里都有其用武之地。
对于某些批处理程序（batch programs），可以考虑「永远」地停止收集器。这些批处理程序通常都是先创建一些数据结构，并根据那些结构体产生一些输出，然后就退出（比如编译器）。对于那些程序，试图去收集垃圾也许就比较浪费时间了，因为没什么垃圾可回收的，并且程序一旦退出，所有的内存就会得到释放。
对于非批处理的程序，永远停止收集器并不可取。不过，在一些关键的时间点，停止收集器对程序可能却是有益的。如有必要，还可以由程序来完全控制垃圾收集器，让它总是处于停止状态，只在程序显式地要求执行一个步骤或者执行一个完整的回收时，收集器才开始工作。例如，有些事件驱动的平台会提供一个 idle 函数，这个函数会在没有事件可以处理时被调用。这是执行垃圾收集的最佳时刻。（Lua5.1 中，在收集器停止时去强制执行一些收集操作，都会使收集器自动重启。所以为了保持它停止的状态，必须在强制执行一些收集操作之后马上调用 collectgarbage (“stop”)。）
最后一个方法，可以试着改变收集器的参数。收集器由两个参数控制其收集的步长（pace）。第一个是 pause，控制收集器在一轮回收结束后隔多久才开始下一轮的回收。第二个参数是 stepmul，控制收集器每一步要做多少工作。粗略地讲，pause 越小，stepmul 越大，收集器工作就越快。
这些参数对一个程序的总体性能的影响是很难预测的。收集器越快，其每秒耗费的 CPU 周期显然也就越多；但是另一方面，或许这样能减少程序的内存使用总量，从而减少换页（paging）。只有通过仔细的实验，才能为这些参数找到最佳的值。
其实，很多局部变量的优化仍然有另一个方案可以达到同样的效果甚至更快，那就是 LuaJIT： http://luajit.org/
这个其实目前坑还是没有填完的，可以参考 《用好Lua+Unity，让性能飞起来—LuaJIT性能坑详解》