lua与c的效率 lua运行效率

前言：

1、以下测试结果均基于大量循环得来，少量使用次数的情况未知；

2、测试用例有限，文中所有结论只基于我当前的认知得出，正确性无法确保，如有问题欢迎一起探讨，也期待有人告知更多的优化方法；

3、只有前两条在采用luajit的情况下额外测试过，由于在iOS平台无法使用luajit，所以平时写代码还是以采用官方解释器的情况为准；

4、不想看正文测试结果的，可以直接看最后的结论；

5、如果想自己测试验证的，建议不同情况用不同文件分开测试，避免因为内存占用等原因第一种情况的代码执行完之后影响第二种情况。

正文：

1、table.insert(tab, 1, a)的效率远远低于table.insert(tab, a)，luagit下情况相同；
2、tab[#tab + 1] = a比table.insert(tab, a)的效率提升15~25%，luagit下效率几乎相同；

3、以下4种循环方式对比：（分别为正序数值for循环、反序数值for循环、ipairs泛型for循环、pairs泛型for循环）

local tab = {}
for i = 1, 20000000 do
	tab[#tab + 1] = true
end

local time1 = os.clock()
for i = 1, #tab do
	tab[i] = true
end
print('1====================', os.clock() - time1)

local time2 = os.clock()
for i = #tab, 1, -1 do
	tab[i] = true
end
print('2====================', os.clock() - time2)

local time3 = os.clock()
for k, v in ipairs(tab) do
	v = true
end
print('3====================', os.clock() - time3)

local time4 = os.clock()
for k, v in pairs(tab) do
	v = true
end
print('4====================', os.clock() - time4)

效率比约为：0.285：0.26：0.922：0.87

将循环体替换为：

tab[i] = true
tab[i] = 1
tab[i] = {true}
tab[i] = nil
tab[i] = true

v = true
v = 1
v = {true}
v = nil
v = true

效率比约为：3.65：4.66：4.86：4.805

循环体内的代码加倍后：

效率比约为：8.57：9.6：9.15：9.15

循环体内的代码加两倍后：

效率比约为：12.95：13.9：12.2：12.25

在循环体后添加下列代码后：

local a, b, c = 1, 2, 3
c = a * b + c

效率比同上。

将循环次数缩小100倍后：

效率比接近1，且不太稳定（偶尔某种循环稍微快一点）。

结论：循环体内很简单时，2的效率最高，table为纯数组的情况建议用2；但实际情况循环体内一般操作不会过于简单，随着复杂度的增加，两个泛型for循环的效率接近，且逐渐优于两个数值for循环；循环次数减少后，效率比接近1。建议平时写代码时根据习惯选择就好。

4、（1）循环内创建变量比循环外创建变量的效率提升随着次数增加逐渐提高（猜想可能因为循环外创建的变量在循环体使用时需要跨域，代价比创建变量大）；

local tab = {}
for i = 1, 2000000 do
	tab[#tab + 1] = true
end

local time1 = os.clock()
for k, v in ipairs(tab) do
	local a = true
	local b = 1
	local c = {true}
	local d = nil
	local e = 'a'
end
print('1====================', os.clock() - time1)

local time2 = os.clock()
local a, b, c, d, e = nil, nil, nil, nil, nil
for k, v in ipairs(tab) do
	a = true
    b = 1
	c = {true}
	d = nil
	e = 'a'
end
print('2====================', os.clock() - time2)

     （2）循环内创建闭包和循环外创建闭包的效率差不多（当闭包数量较多时，在循环外创建闭包会稍微快一点，几乎可以忽略）；

local tab = {}
for i = 1, 2000000 do
	tab[#tab + 1] = true
end

local time1 = os.clock()
for k, v in ipairs(tab) do
	local a = function ()
		local n = 'n'
		local m = 'm'
		local str = ''
		for i = 1, 10 do
            str = str .. n .. m
		end
		return str 
	end

	local b = a() .. 'a'
end
print('1====================', os.clock() - time1)

local time2 = os.clock()
local a = function ()
	local n = 'n'
	local m = 'm'
	local str = ''
	for i = 1, 10 do
        str = str .. n .. m
	end
	return str 
end
for k, v in ipairs(tab) do
	local b = a() .. 'a'
end
print('2====================', os.clock() - time2)

     （3）循环外创建长表比循环内创建长表的效率提升随着次数增加逐渐提高。

local tab = {}
for i = 1, 2000000 do
	tab[#tab + 1] = true
end

local time1 = os.clock()
for k, v in ipairs(tab) do
	local a = {1, 1, 1, 1, 1}

	local num = a[1]
end
print('1====================', os.clock() - time1)

local time2 = os.clock()
local a = {1, 1, 1, 1, 1}
for k, v in ipairs(tab) do
	local num = a[1]
end
print('2====================', os.clock() - time2)

结论：在循环内创建变量和循环外创建变量的效率取决于创建代价和跨域代价的对比，根据经验选择最合适的处理。

5、以局部变量代替多次使用的外部变量（xx.xx之类）比直接使用外部变量的效率提升随着次数增加逐渐提高；

local tab = {}
for i = 1, 2000000 do
	tab[#tab + 1] = true
end

local publicTab = {a = true, b = 1, c = {true}, d = nil, e = 'a'}

local time1 = os.clock()
for k, v in ipairs(tab) do
	if publicTab.a then
		local n = publicTab.b * 2 / 3 + 4 - 5 + #publicTab.c
	end
	if not publicTab.d then
		local m = publicTab.e .. publicTab.e .. publicTab.e
	end
end
print('1====================', os.clock() - time1)

local time2 = os.clock()
for k, v in ipairs(tab) do
	local a = publicTab.a
    local b = publicTab.b
	local c = publicTab.c
	local d = publicTab.d
	local e = publicTab.e

	if a then
		local n = b * 2 / 3 + 4 - 5 + #c
	end
	if not d then
		local m = e .. e .. e
	end
end
print('2====================', os.clock() - time2)

6、减少函数调用可以很大提高效率；

local tab = {}
for i = 1, 2000000 do
	tab[#tab + 1] = true
end

local time1 = os.clock()
local func = function (a, b)
    a = a * b + a / b - a + b
    return a
end

for k, v in ipairs(tab) do
    local a = func(1, 2)
end
print('1====================', os.clock() - time1)

local time2 = os.clock()
for k, v in ipairs(tab) do
    local a = 1 * 2 + 1 / 2 - 1 + 2
end
print('2====================', os.clock() - time2)

7、提前声明table大小可以很大提高效率；

local tab = {}
for i = 1, 2000000 do
	tab[#tab + 1] = true
end

local time1 = os.clock()
for k, v in ipairs(tab) do
	local changeTab = {}
	for i = 1, 5 do
        changeTab[#changeTab + 1] = true
	end
end
print('1====================', os.clock() - time1)

local time2 = os.clock()
for k, v in ipairs(tab) do
	local changeTab = {nil, nil, nil, nil, nil}
	for i = 1, 5 do
        changeTab[#changeTab + 1] = true
	end
end
print('2====================', os.clock() - time2)

8、string.format比..效率低很多；

local tab = {}
for i = 1, 2000000 do
	tab[#tab + 1] = true
end

local time1 = os.clock()
for k, v in ipairs(tab) do
	local a = 'a' .. 'n' .. 'b' .. 'm' .. 'c'
end
print('1====================', os.clock() - time1)

local time2 = os.clock()
for k, v in ipairs(tab) do
	local a = string.format('%sn%sm%s', 'a', 'b', 'c')
end
print('2====================', os.clock() - time2)

9、乘法和除法效率一样；

local tab = {}
for i = 1, 20000000 do
	tab[#tab + 1] = true
end

local time1 = os.clock()
for k, v in ipairs(tab) do
	local a = 1 * 0.5 * 0.25 * 0.2 * 0.1
end
print('1====================', os.clock() - time1)

local time2 = os.clock()
for k, v in ipairs(tab) do
	local a = 1 / 2 / 4 / 5 / 10
end
print('2====================', os.clock() - time2)

10、判断数组表是否为空时用#tab>0随着tab的长度增加所花时间逐渐增加，而用next(tab)时所花时间固定不变，但只有当tab长度很长时，#tab>0的效率才会低于next(tab)。

总结：

1、给table添加元素时，tab[#tab + 1] = a比table.insert(tab, a)效率高，远比table.insert(tab, 1, a)效率高；

2、4种循环方式根据习惯选择就好，效率差别不大；

3、在循环内创建变量和循环外创建变量的效率取决于创建代价和跨域代价的对比，根据经验选择最合适的处理；

4、以局部变量代替多次使用的外部变量（xx.xx之类）；

5、减少函数调用可以很大提高效率，但会降低代码的可读性，按需选择；

6、提前声明table大小可以很大提高效率，可以做到的情况尽量做到；

7、string.format比..效率低很多，但可读性大大提高，按需选择；

8、判断数组表是否为空时，一般情况用#tab>0即可，除非tab长度特别大，用next(tab)的效率才会更高。