Gibt es eine Ruby-Version von for-loop, die der von Java/C++ ähnelt?

Question

Gibt es eine Ruby-Version von for-loop ähnlich der in Java/C (++)?

In Java:

for (int i=0; i<1000; i++) { 
    // do stuff 
} 

Der Grund ist, weil ich verschiedene Operationen basierend auf dem Index der Iteration tun müssen. Sieht so aus, als hätte Ruby nur eine for-each-Schleife?

Bin ich richtig?

Answer 1

Ja können Sie each_with_index

collection = ["element1", "element2"] 
collection.each_with_index {|item,index| puts item; puts index} 

die 'index' Variable gibt Ihnen die Element-Index während jeder Iteration

Answer 2

Sie können each with index Benutzer verwenden.

1000.times do |i| 
    # do stuff ... 
end 

Wenn Sie sowohl das Element wollen und den Index dann die each_with_index Syntax wahrscheinlich am besten ist:

Answer 3

In Ruby, die for Schleife als implementiert werden kann

collection.each_with_index do |element, index| 
    # do stuff ... 
end 

jedoch die each_with_index Schleife ist langsamer, da es die Objekte element und index für jede Iteration der Schleife bereitstellt.

Answer 4

Ruby neigt dazu, Iteratoren anstelle von Schleifen zu verwenden; Sie können die ganze Funktion von Schleifen mit den leistungsstarken Iteratoren von Ruby erhalten.

Es gibt mehrere Möglichkeiten, dies zu tun, nehmen wir an, Sie haben eine Reihe ‚arr‘ der Größe 1000.

1000.times {|i| puts arr[i]} 
0.upto(arr.size-1){|i| puts arr[i]} 
arr.each_index {|i| puts arr[i]} 
arr.each_with_index {|e,i| puts e} #i is the index of element e in arr 

Alle diese Beispiele bieten die gleiche Funktionalität

Answer 5

Wie wäre es step?

0.step(1000,2) { |i| puts i } 

entspricht:

for (int i=0; i<=1000; i=i+2) { 
    // do stuff 
} 

Answer 6

times über each_with_index empfohlen. times ist etwa 6 mal schneller. Führen Sie den folgenden Code aus.

require "benchmark" 

TESTS = 10_000_000 
array = (1..TESTS).map { rand } 
Benchmark.bmbm do |results| 
    results.report("times") do 
    TESTS.times do |i| 
     # do nothing 
    end 
    end 

    results.report("each_with_index") do 
    array.each_with_index do |element, index| 
     # Do nothing 
    end 
    end 
end 

Ich habe das Ergebnis wie folgt mit meinem MacBook (Intel Core2Duo).

Rehearsal --------------------------------------------------- 
times    1.130000 0.000000 1.130000 ( 1.141054) 
each_with_index 7.550000 0.210000 7.760000 ( 7.856737) 
------------------------------------------ total: 8.890000sec 

         user  system  total  real 
times    1.090000 0.000000 1.090000 ( 1.099561) 
each_with_index 7.600000 0.200000 7.800000 ( 7.888901) 

Answer 7

wenn ich brauche nur die Zahlen (und nicht wiederholen wollen) Ich ziehe diese:

(0..10000).each do |v| 
    puts v 
end 

Answer 8

Die while-Schleife führt seinen Körper null oder mehrere Male, so lange seine Bedingung wahr ist.

while <condition> 
    # do this 
end 

Die while-Schleife kann die 'for'-Schleife von Java ersetzen. In Java

for (initialization;, condition;, incrementation;){ 
    //code 
} 

folgend gleiche ist (außer in der zweiten Form, initialisiert Variablen for-Schleife nicht lokal).

Die Ruby While-Schleife kann in dieser Form geschrieben werden, um als For-Schleife von Java zu arbeiten. In Ruby

initialization; 
while(condition) 
    # code 
    incrementation; 
end 

Man beachte, dass die ‚während‘ (und ‚bis‘ und ‚für‘) Schleife einzuführen keinen neuen Rahmen; Bereits vorhandene Locals können in der Schleife verwendet werden, und neue Locals werden später verfügbar sein.

Answer 9

for i in 0..100 do 
    #bla bla 
end