网上有大量对 Lua 调优的推荐，我们应该如何看待？

Lua 的解析器有官方的 standard Lua 和 LuaJIT，需要明确的一点是目前大量的优化文章都比较陈旧，而且都是针对 standard Lua 解析器的，standard Lua 解析器在性能上需要书写者自己规避问题，才能写出高性能来。

需要各位看官注意的是，OpenResty 最新版默认已经绑定 LuaJIT，优化手段和方法已经略有不同。我们现在的做法是：代码易读是首位，目前还没有碰到同样代码换个写法就有质的提升，如果我们对某个单点功能有性能要求，那么建议用 LuaJIT 的 FFI 方法直接调用 C 接口更直接一点。

代码出处：http://www.cnblogs.com/lovevivi/p/3284643.html

  1. -- 3.0 避免使用 table.insert()
  3. -- 下面来看看 4 个实现表插入的方法。在 4 个方法之中 table.insert() 在效率上不如其他方法，是应该避免使用的。
  4. -- (1) 使用 table.insert()
  5. local a = {}
  6. local table_insert = table.insert
  7. for i = 1,100 do
  8.    table_insert( a, i )
  9. end
  11. -- (2) 使用循环的计数
  13. local a = {}
  14. for i = 1,100 do
  15.    a[i] = i
  16. end
  18. -- (3) 使用 table 的 size
  20. local a = {}
  21. for i = 1,100 do
  22.    a[#a+1] = i
  23. end
  25. -- (4) 使用计数器
  27. local a = {}
  28. local index = 1
  29. for i = 1,100 do
  30.    a[index] = i
  31.    index = index+1
  32. end
  34. -- 4.0 减少使用 unpack() 函数
  35. -- Lua 的 unpack() 函数不是一个效率很高的函数。你完全可以写一个循环来代替它的作用。
  37. -- (1) 使用 unpack()
  39. local a = { 100, 200, 300, 400 }
  40. for i = 1,100 do
  41.    print( unpack(a) )
  42. end
  44. -- (2) 代替方法
  46. local a = { 100, 200, 300, 400 }
  47. for i = 1,100 do
  48.    print( a[1],a[2],a[3],a[4] )
  49. end

针对这篇文章内容写了一些测试代码：

  1. local start = os.clock()
  3. local function sum( ... )
  4.     local args = {...}
  5.     local a = 0
  6.     for k,v in pairs(args) do
  7.         a = a + v
  8.     end
  9.     return a
  10. end
  12. local function test_unit()
  13.     -- t1: 0.340182 s
  14.     -- local a = {}
  15.     -- for i = 1,1000 do
  16.     --    table.insert( a, i )
  17.     -- end
  19.     -- t2: 0.332668 s
  20.     -- local a = {}
  21.     -- for i = 1,1000 do
  22.     --    a[#a+1] = i
  23.     -- end
  25.     -- t3: 0.054166 s
  26.     -- local a = {}
  27.     -- local index = 1
  28.     -- for i = 1,1000 do
  29.     --    a[index] = i
  30.     --    index = index+1
  31.     -- end
  33.     -- p1: 0.708012 s
  34.     -- local a = 0
  35.     -- for i=1,1000 do
  36.     --     local t = { 1, 2, 3, 4 }
  37.     --     for i,v in ipairs( t ) do
  38.     --        a = a + v
  39.     --     end
  40.     -- end
  42.     -- p2: 0.660426 s
  43.     -- local a = 0
  44.     -- for i=1,1000 do
  45.     --     local t = { 1, 2, 3, 4 }
  46.     --     for i = 1,#t do
  47.     --        a = a + t[i]
  48.     --     end
  49.     -- end
  51.     -- u1: 2.121722 s
  52.     -- local a = { 100, 200, 300, 400 }
  53.     -- local b = 1
  54.     -- for i = 1,1000 do
  55.     --    b = sum(unpack(a))
  56.     -- end
  58.     -- u2: 1.701365 s
  59.     -- local a = { 100, 200, 300, 400 }
  60.     -- local b = 1
  61.     -- for i = 1,1000 do
  62.     --    b = sum(a[1], a[2], a[3], a[4])
  63.     -- end
  65.     return b
  66. end
  68. for i=1,10 do
  69.     for j=1,1000 do
  70.         test_unit()
  71.     end
  72. end
  74. print(os.clock()-start)

从运行结果来看，除了 t3 有本质上的性能提升（六倍性能差距，但是 t3 写法相当丑陋），其他不同的写法都在一个数量级上。你是愿意让代码更易懂还是更牛逼，就看各位看官自己的抉择了。不要盲信，也不要不信，各位要睁开眼自己多做测试。

另外说明：文章提及的使用局部变量、缓存 table 元素，在 LuaJIT 中还是很有用的。