ruby数组自带方法与自定义方法的性能测试集+1个循环问题

n=[1,2,3,nil,nil]
p n
n1=n.compact
p n1
n2=n.compact!
p n2
p n

主要是交流，水平有限，喜欢研究，多多包涵。

先说一个数组循环问题

arr=[1,2,3]
n=arr << arr
p n
输出：
[1, 2, 3, [...]]

 分析：
<< 传进去的是一个arr指针 # =>[1,2,3,arr]
其实这是一个循环，真实的值是:[1,2,3,[1,2,3,[1,2,3,[1,2,3,........]]]
arr[3]=arr
arr[3][3]=arr


ruby数组比较常用的方法：
1.at方法

arr=[1,2,3]
p arr.at(2)
p arr[2]

 其实：at比[]方法要效率一点，因为它不接受range参数
测试：

require 'benchmark'

n=(1..1000000).to_a
l=n.length
Benchmark.bm do |bm|
bm.report("at") do
i=0
while i< l
n.at(i)
i+=1
end
end

bm.report("[]") do
i=0
while i< l
n[i]
i+=1
end
end

end
输出：
user     system      total        real
at  0.610000   0.000000   0.610000 (  0.609000)
[]  0.625000   0.000000   0.625000 (  0.625000)

 结论：大数组的获取元素首选at
2.compact delete方法

n=[1,2,3,nil,nil]
p n
n1=n.compact
p n1
n2=n.compact!
p n2
p n

 删除数组中nil的元素，带!返回数组本身，如果数组中没有nil,不带!返回Nil,带!返回数组本身。

n=[1,2,3,nil,nil]
p n.delete(nil)
p n

 
delete方法也可以删除所有nil元素，比较下性能：

require 'benchmark'
n=Array.new(100000000,nil)
n1=Array.new(100000000,nil)
Benchmark.bm do |bm|
bm.report("delete") do
n.delete(nil)
end

bm.report("compact") do
n1.compact
end

end

user     system      total        real
delete  0.718000   0.016000   0.734000 (  0.735000)
compact  1.360000   0.062000   1.422000 (  1.453000)

 结论：删除元素首选 delete


3.比较下for each while

require 'benchmark'
n=(1..100000).to_a

Benchmark.bm do |bm|
bm.report("each") do
n.each do |d|
d
end
end

bm.report("for") do
for i in n
i
end
end
bm.report("while") do
i=0
while i< n.length
n[i]
i+=1
end
end
end
user     system      total        real
each  0.015000   0.000000   0.015000 (  0.015000)
for  0.016000   0.000000   0.016000 (  0.016000)
while  0.078000   0.000000   0.078000 (  0.078000)

 结论：each 很效率

4.flatten方法

n=[1,2,3]
n1=[4,5,6]
n2=[n1,n]
p n2
p n2.flatten
#
[[4, 5, 6], [1, 2, 3]]
[4, 5, 6, 1, 2, 3]

 5.sort与自定义方法比较

require 'benchmark'
n=(1..100).to_a
n1=(23..89).to_a
n2=(900..3003).to_a
n=n2+n1+n

#自定义方法是网上找的
def bubble_sort(arr)
1.upto(arr.length-1) do |i|
(arr.length-i).times do |j|
if arr[j]>arr[j+1]
arr[j],arr[j+1] = arr[j+1],arr[j]
end
end
end
arr
end

Benchmark.bm do |bm|
bm.report("sort") do
n.sort
end

bm.report("personal") do
bubble_sort(n)
end

end

user     system      total        real
sort  0.000000   0.000000   0.000000 (  0.000000)
personal  3.109000   0.109000   3.218000 (  3.220000)

 结论：坑爹啊，ruby自带方法还是很强大的，首选自带方法sort

6.uniq方法
删除数组的重复元素，测试就不测了，类似于上面的sort.

转载于:https://www.cnblogs.com/IAmBetter/archive/2013/03/16/2963687.html

• 点赞
• 收藏
• 分享
• 文章举报