回到Ruby系列文章


Ruby中的循环语句

times方法循环

times是Integer类的一个方法,它后面跟一个语句块,如果没有给定语句块则返回一个迭代器对象。

1
2
times {|i| block } → self
times → an_enumerator

当明确循环次数的时候,使用times方法进行循环将变得非常实用,代码可读性也非常强。

例如,要循环10次:

1
2
3
10.times {
puts "循环输出10次"
}

每次循环的时候,可以将次数作为语句块的变量使用(变量的值从0开始):

1
2
3
10.times do |i|
puts "这是第#{i}次循环"
end

for..in循环

这种for..in循环是迭代测试性循环,从一个容器中检测是否存在下一个元素,存在则迭代。for内部使用的是each方法,for是一个语法糖类型的语法式循环语句:

1
2
3
4
5
6
7
8
for i in 1..5
puts i
end

langs = %w(perl php shell python)
for lang in langs do
puts lang
end

for和while/until的关键字do可以替换为换行符或分号,例如下面是等价的:

1
2
3
4
5
6
7
8
9
10
for i in 1..5
puts i
end

for i in 1..5 do
puts i
end

for i in 1..5; puts i; end
for i in 1..5 do puts i; end

while和until循环

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# while循环
a = 0
while a < 10 do
p a
a += 1
end

p a # 输出10

# until循环
a=0
until a>10 do
p a # 输出0到10
a+=1
end

p a # 输出11

while和until作为修饰符的循环

将while和until作为修饰符,简化简单的循环代码:

1
2
3
4
5
6
7
a = 0
a += 1 while a < 10
p a # prints 10

a = 0
a += 1 until a > 10
p a # prints 11

如果while或until前面有多条语句,则可以使用begin…end语句块:

1
2
3
4
5
a=0
begin
p a
a+=1
end while a<10

只是需要注意的是,while和until作为修饰符的时候,当使用了begin...end语句块后,循环体一定会执行一次,然后才开始第一次的条件判断。但如果不使用begin...end,则不会出现这样的问题。

1
2
3
4
5
x = 10
puts "hello" while x < 10 # 不输出

y = 10
begin puts "world" end while y < 10 # 输出

loop无限循环

loop方法是Kernel模块中提供的一个用来做无限循环的方法:

1
2
3
loop {
p "hello world"
}

可以使用break来控制loop循环的退出。

each迭代循环

each方法用来迭代任何可迭代的对象,它的根在Enumerable模块,只要某个类实现了each方法用来yield元素,那么只要mix-in Enumerable之后就可以自动获得Enumerable中一大堆的each变体方法,如each_with_index迭代方法。

1
2
3
4
5
sum=0
(1..5).each do |i|
sum += i
end
p sum

break、next、redo

它们可以用在各种迭代、循环语句块中用来控制迭代、循环的流程。

  • break退出当前层次的迭代结构、循环结构
  • next立即进入下一轮迭代或循环(也可以认为是跳到当前循环的尾部从而进入下一轮循环)
  • redo立即回到当前迭代/循环的头部,再次执行一次迭代/循环语句块

几种循环的效率比较

只考虑速度不考虑内存的话。经过比较,while(until)是最快的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
# while条件循环
$ time ruby -e 'a=0;i=0;while(i<100000000) do a = a+1;i = i+1; end;p a'
100000000

real 0m1.770s
user 0m1.563s
sys 0m0.219s

# for i in range
$ time ruby -e 'a=0;for i in 1..100000000 do a = a+1 end;p a'
100000000

real 0m3.404s
user 0m3.395s
sys 0m0.012s

# N.times
$ time ruby -e 'a=0;100000000.times do a = a+1 end;p a'
100000000

real 0m3.230s
user 0m2.984s
sys 0m0.266s

# range.each
$ time ruby -e 'a=0;(1..100000000).each do a = a+1 end;p a'
100000000

real 0m3.180s
user 0m2.953s
sys 0m0.219s

Ruby中的循环优化

在循环次数多时,循环内部的代码优化对循环效率的提升是有益的。

1.循环中尽量不要重复创建重复的对象

在Ruby中,数值、Symbol、true、false、nil都是不可变对象,循环中使用它们的常量形式其实每次都在引用同一个对象。

1
2
3
4
5
6
$ ruby -e '5.times {puts 144444444423.__id__}'
288888888847
288888888847
288888888847
288888888847
288888888847

而Ruby中的字符串、数组、hash是可变对象,在循环中每次使用它们的常量形式都会重新创建新对象,这会使得效率降低。此时应将常量字符串、数组、hash定义成变量保存在循环的外部。

1
2
3
4
5
6
7
8
9
10
11
12
13
$ ruby -e '5.times {puts "a".__id__}'
70368305866240
70368305866120
70368305866060
70368305866000
70368305865940

$ ruby -e 'a="a"; 5.times {puts a.__id__}'
70368545646060
70368545646060
70368545646060
70368545646060
70368545646060

此外,正则表达式的常量形式在循环中默认是不会重新编译的对象(除非使用了变量内插方式来构建常量的正则表达式对象,此时它是动态的,但可以使用『o』修饰符来强制缓存第一次的编译结果从而不再重新编译),所以循环中也可以使用正则的常量形式。但如果是Regexp类方法构建的正则表达式对象,则每次都会重新构建。

例如,下面两种循环,实现的需求是一样的,但是用了两种不同的方法:

1
2
words.each {|w| next if w.include?("abc")}
words.each {|w| next if w =~ /abc/}

上面两个循环语句都是从一个words数组中匹配是否包含abc字符串。但是在第一个循环中,『abc』以常量的方式存在,每次迭代时都重新创建、销毁这个字符串对象,而第二个循环中只构建了一次正则表达式对象。所以,虽然include?()的检测比正则表达式的匹配性能更好,但是结果却是第二个循环表现更佳,特别是循环次数多的时候。