Ruby - 每个起始偏移量

Question

如何在ruby中为each循环设置起始偏移量？ 我希望循环从a[3]而不是a[0]开始。我该怎么设置？

a = [ab, cd, ef, gh, hi, jk]

a.each do |i|
#some stuff
end

Answer 1

另一种可能更直接和可读的可能性是使用Array#drop：

a.drop(3).each do |i|
  # do something with item i
end

现在，如果与从Enumerable继承的其他方法结合使用，这真的很有吸引力，因此有可能是你的命令式each循环的更好替代方案。假设您要过滤提取的切片并在之后对其进行转换：

a = [0,1,2,3,4,5,6,7]
a.drop(3).select(&:even?).map { |x| x * 2 }
# => [8, 12]

或者说您要打印所有值的列表：

a = ["1", "2", "3", "4", "5"]
puts a.drop(3).join("\n")

输出：

4
5

从函数式编程继承的这些特性使Ruby如此强大：）

Answer 2

在阵列的subpart上使用each。在下面的示例中，从第四个元素到结尾：

a[3..-1].each do |i|
  #some stuff
end

Answer 3

这会对你有所帮助

a[3..-1].each do |i|
  #your logic
end

Answer 4

大多数Rubyist都忘记了旧的for循环：

n = 3
for i in n...a.size
  puts a[i]
end

Answer 5

基准

对于那些对这些方法的基准比较感兴趣的人：）

require 'benchmark/ips'

a = Array.new(1000) { |i| i } 
drop_point = 500

Benchmark.ips do |x|
  x.report('drop(x)') do
    a.drop(drop_point).each { |el| el + 1 }
  end

  x.report('[x...-1]') do 
    a[drop_point..-1].each { |el| el + 1 }
  end

  x.report('for in') do
    n = drop_point
    size = a.size
    for i in n...size
      a[i] + 1
    end
  end

  x.report('while') do
    size = a.size
    i = drop_point
    while i < size
      a[i] + 1
      i += 1
    end
  end

  x.compare!
end

---

结果

Warming up --------------------------------------
             drop(x)     4.142k i/100ms
            [x...-1]     4.125k i/100ms
              for in     3.239k i/100ms
               while     5.391k i/100ms
Calculating -------------------------------------
             drop(x)     42.485k (± 2.3%) i/s -    215.384k in   5.072524s
            [x...-1]     42.533k (± 2.3%) i/s -    214.500k in   5.045832s
              for in     32.855k (± 2.5%) i/s -    165.189k in   5.030958s
               while     53.489k (± 4.5%) i/s -    269.550k in   5.049793s

Comparison:
               while:    53489.3 i/s
            [x...-1]:    42532.8 i/s - 1.26x  slower
             drop(x):    42484.7 i/s - 1.26x  slower
              for in:    32855.4 i/s - 1.63x  slower

结论

正如预期的那样，良好的旧while是最快的，因为它没有block分配，但是我更喜欢[x...-1]或drop(x)，因为它们更易读< / p>