网上有大量对 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. 使用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. 使用循环的计数
  13. local a = {}
  14. for i = 1,100 do
  15.    a[i] = i
  16. end
  17. 使用table的size
  19. local a = {}
  20. for i = 1,100 do
  21.    a[#a+1] = i
  22. end
  23. 使用计数器
  25. local a = {}
  26. local index = 1
  27. for i = 1,100 do
  28.    a[index] = i
  29.    index = index+1
  30. end
  32. 4.0 减少使用 unpack()函数
  33. Lua的unpack()函数不是一个效率很高的函数。你完全可以写一个循环来代替它的作用。
  35. 使用unpack()
  37. local a = { 100, 200, 300, 400 }
  38. for i = 1,100 do
  39.    print( unpack(a) )
  40. end
  41. 代替方法
  43. local a = { 100, 200, 300, 400 }
  44. for i = 1,100 do
  45.    print( a[1],a[2],a[3],a[4] )
  46. 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 中还是很有用的。