escapar de la .Cada {} iteración temprana en Ruby

Question

código:

c = 0 
items.each { |i| 
    puts i.to_s  
    # if c > 9 escape the each iteration early - and do not repeat 
    c++ 
} 

Quiero agarrar los primeros 10 elementos entonces salen de la "cada" bucle.

¿Con qué reemplazo la línea comentada? hay un mejor enfoque? algo más Ruby idiomático?

Answer 1

Si bien la solución break funciona, creo que un enfoque más funcional realmente se adapta a este problema. ¿Quieres take los primeros 10 elementos e imprimirlos a fin de tratar

items.take(10).each { |i| puts i.to_s } 

Answer 2

¿Esto se parece a lo que quieres?

10.times { |i| 
    puts items[i].to_s 
} 

Answer 3

No hay operador ++ en Ruby. También es convencional utilizar do y end para bloques de varias líneas. Modificación de los rendimientos de solución:

c = 0 
items.each do |i| 
    puts i.to_s  
    break if c > 9 
    c += 1 
end 

O también:

items.each_with_index do |i, c| 
    puts i.to_s  
    break if c > 9 
end 

Ver each_with_index y también Programming Ruby Break, Redo, and Next.

Actualización:Chuck's answer con rangos es más Rubí-como, y nimrodm's answer usando take es aún mejor.

Answer 4

items.each_with_index { |i, c| puts i and break if c <= 9 } 

Answer 5

break obras para escapar temprano de un bucle, pero es más idiomático sólo para hacer items[0..9].each {|i| puts i}. (Y si todo lo que hace es, literalmente, imprimir los elementos sin ningún cambio, puede hacer puts items[0..9]).

Answer 6

Otra variante:

puts items.first(10) 

Tenga en cuenta que esto funciona bien con matrices de menos de 10 unidades:

>> nums = (1..5).to_a 
=> [1, 2, 3, 4, 5] 
>> puts nums.first(10) 
1 
2 
3 
4 
5 

(Otra nota, mucha gente está ofreciendo alguna forma de puts i.to_s, pero en tal caso, ¿no es .to_s redundante? puts automáticamente llame al .to_s en una cadena para imprimirlo, pensé. Usted sólo necesita .to_s si quería decir puts 'A' + i.to_s o similares.)

Answer 7

Otra opción sería

items.first(10).each do |i| 
    puts i.to_s 
end 

que lee un poco más fácil para mí que se rompe en un iterador, y el primer devolverá solamente tantos elementos como estén disponibles si no hay suficientes.

Answer 8

Se preguntó:

Quiero agarrar los primeros 10 elementos entonces salen de la "cada" bucle.

Uso throw y catch para lograr esto, con pocos cambios en el ejemplo:

catch(:done) do 
    c = 0 
    collected = [] 
    items.each do |item| 
     collected << item 
     throw(:done, collected) if c == 9 # started at 0 
     c += 1 
    end 
    collected # if the list is less than 10 long, return what was collected 
end 

Simplemente throw la etiqueta :done con collected y la catch que está a la espera de :done volverá collected.

Y para "Ruby" esto un poco:

catch(:done) do 
    items.inject([]) do |collected, item| 
     throw(:done, collected) if collected.size == 10 
     collected << item # collected gets returned here and populates the first argument of this block 
    end 
end 

No sé por qué algunas personas se niegan a usar inject y utilizar reduce lugar (que son equivalentes) cuando claramente la matriz vacía dado a inject([]) es siendo inyectado con item s! De todos modos, el inject devolverá collected si hay menos de 10 elementos.

La mayoría de las respuestas intentan responder cuál podría ser el objetivo de la pregunta en lugar de lo que se solicitó y items.take(10) tiene perfecto sentido en ese caso. Pero me imagino que quiero tomar los primeros artículos que encajan dentro de mi presupuesto de $ 100. A continuación, puede:

catch(:done) do 
    items.inject({items: [], budget: 100}) do |ledger, item| 
     remainder = ledger[:budget] - item.price 
     if remainder < 0 
      throw(:done, ledger) 
     else 
      ledger.tap do |this| 
       this[:items] << item 
       this[:budget] = remainder 
      end # tap just returns what is being tapped into, in this case, ledger 
     end 
    end 
end