En Perl, hay una capacidad de romper un ciclo exterior como esto:¿Cómo romper el ciclo externo en Ruby?
AAA: for my $stuff (@otherstuff) {
for my $foo (@bar) {
last AAA if (somethingbad());
}
}
(sintaxis puede ser malo), que utiliza una etiqueta de bucle para romper el bucle exterior desde el interior del bucle interno. ¿Hay algo similar en Ruby?
Lo que queremos es no local de control de flujo, que Ruby tiene varias opciones para hacerlo:
throw/catchContinuaciones
Pros:
GOTO.Contras:
excepciones
Pros:
Contras:
throw/catch
Esta es (más o menos) lo que se vería así:
catch :aaa do
stuff.each do |otherstuff|
foo.each do |bar|
throw :aaa if somethingbad
end
end
end
Pros:
StopIteration para la terminación.Contras:
No, no lo hay.
Las opciones son:
Considere throw/catch. Normalmente, el ciclo externo del código siguiente se ejecutará cinco veces, pero con throw puedes cambiarlo a lo que quieras, rompiéndolo en el proceso. Considere este código ruby perfectamente válido:
catch (:done) do
5.times { |i|
5.times { |j|
puts "#{i} #{j}"
throw :done if i + j > 5
}
}
end
personalmente no me gusta el uso de elevación excepción para la ejecución normal código . Obliga a un programador a seguir múltiples flujos de lógica. –
No entiendo este comentario. En el fragmento de código anterior no hay excepciones planteadas en ningún lado. Solo se envían seis mensajes en todo el código: 'catch',' times', 'puts',' throw', '+' y '<=>'. No envío 'raise' a ninguna parte. –
Supongo que hay una confusión entre raise/rescue (excepciones) y throw/catch, se ven similares pero no lo son. – Kris
Sé que me arrepentiré de esto en la mañana, pero el simple hecho de usar un ciclo while podría hacer el truco.
x=0
until x==10
x+=1
y=0
until y==10
y+=1
if y==5 && x==3
x,y=10,10
end
end
break if x==10
puts x
end
El if y==5 && x==3 es sólo un ejemplo de una expresión girando cierto.
Ahora es de mañana: por favor, arrepiéntete. –
Quizás esto es lo que quieres? (No probado) método
stuff.find do |otherstuff|
foo.find do
somethingbad() && AAA
end
end
El hallazgo mantiene en bucle hasta que el bloque devuelve un valor no nulo o el final de la lista es golpeado.
while c1
while c2
do_break=true
end
next if do_break
end
o "descanso si do_break" dependiendo de lo que desee
Envolver un método interno en torno a los bucles podría hacer el truco Ejemplo:
test = [1,2,3]
test.each do |num|
def internalHelper
for i in 0..3
for j in 0..3
puts "this should happen only 3 times"
if true
return
end
end
end
end
internalHelper
end
Aquí puede hacer una verificación en el interior cualquiera de los bucles for y return del método interno una vez que se cumple una condición.
Puede considerar agregar un indicador, que se encuentra dentro del bucle interno, para controlar el bucle externo.
'siguiente' el bucle exterior
for i in (1 .. 5)
next_outer_loop = false
for j in (1 .. 5)
if j > i
next_outer_loop = true if j % 2 == 0
break
end
puts "i: #{i}, j: #{j}"
end
print "i: #{i} "
if next_outer_loop
puts "with 'next'"
next
end
puts "withOUT 'next'"
end
'break' el bucle exterior
for i in (1 .. 5)
break_outer_loop = false
for j in (1 .. 5)
if j > i
break_outer_loop = true if i > 3
break
end
puts "i: #{i}, j: #{j}"
end
break if break_outer_loop
puts "i: #{i}"
end
Para el beneficio de los lectores de 2011: http://www.coffeepowered.net/2011/06/17/jruby-performance-exceptions-are-not-flow-control/ indica que JRuby todavía es algo lento en Exceptions. –
Nunca he oído hablar de la comunidad ruby que odia 'throw' /' catch' (o incluso excepciones) para el flujo de control. ¿Prefieren las continuaciones? ¿Leíste sobre este sentimiento en ruby-talk o algo así? – Kelvin