loops - Manera elegante para hacer... mientras en groovy

do-while

Question

¿Cómo codificar algo así en groovy ?

do {

  x.doIt()

} while (!x.isFinished())

Porque no hay do ... while sintaxis está en groovy.

No ''do ... while (sintaxis) todavía.

Debido a la ambigüedad, todavía no hemos agregado soporte para hacer ... mientras que para Groovy

Referencias

• groovy - dev > do while
• Migración de sintaxis clásica a JSR
• Groovy Documentation > Control Estructuras > Looping
• Código de Rosetta > Loops / Do-while Groovy

Answer 1

Dependiendo de su caso de uso, hay opciones como esta: do .. while () en Groovy con inputStream?

O puedes hacer:

x.doIt()
while( !x.finished ) { x.doIt() }

O

while( true ) {
    x.doIt()
    if( x.finished ) break
}

Answer 2

Desde Groovy 2.6 on, do-while es compatible cuando se habilita el nuevo Parrot Parser, desde Groovy 3.0 en este es el predeterminado. Ver notas de la versión :

// classic Java-style do..while loop
def count = 5
def fact = 1
do {
    fact *= count--
} while(count > 1)
assert fact == 120

Answer 3

O puede implementarlo de una manera Groovier:

def loop(Closure g){
    def valueHolder = [:]
    g.delegate = valueHolder
    g.resolveStrategy = Closure.DELEGATE_FIRST
    g()
    [until:{Closure w ->
        w.delegate = valueHolder
        w.resolveStrategy = Closure.DELEGATE_FIRST
        while(!w()){
        g()
        }
        }]
}

Answer 4

Puede hacer su propio bucle que es casi lo que quiere. Aquí hay un ejemplo con loop { code } until { condition } No puede tener un loop { code } while { condition } porque while es una palabra clave. Pero podrías llamarlo de otra manera.

De todos modos, aquí hay un código difícil y listo para el ciclo hasta. Uno tiene que usar llaves para la condición hasta que sea un cierre. Puede haber otros problemas con eso.

class Looper {
   private Closure code

   static Looper loop( Closure code ) {
      new Looper(code:code)
   }

   void until( Closure test ) {
      code()
      while (!test()) {
         code()
      }
   }
}

Uso:

import static Looper.*

int i = 0
loop {
   println("Looping : "  + i)
   i += 1
} until { i == 5 }

Answer 5

Puede usar una variable de condición con el ciclo while normal:

def keepGoing = true
while( keepGoing ){
    doSomething()
    keepGoing = ... // evaluate the loop condition here
}

Answer 6

Tantas respuestas y ni una sola sin una llamada redundante (una antes del ciclo y el resto en el interior), vergüenza.

Esto es lo más cercano que puede llegar a la sintaxis puramente basada en el lenguaje do-while en Groovy:

while ({
    x.doIt()
    !x.isFinished()
}()) continue

La última instrucción dentro de llaves (dentro del cierre) se evalúa como una condición de salida de bucle.

En lugar de continue se puede usar un punto y coma.

Otra cosa agradable es que el lazo se puede parametrizar (tipo de), como:

Closure<Boolean> somethingToDo = { foo ->
    foo.doIt()
    !foo.isFinished()
}

y luego en otro lado

while (somethingToDo(x)) continue

Anteriormente, he propuesto esta respuesta aquí: do .. while () en Groovy con inputStream?