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

    网上有大量对 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 中还是很有用的。