peliculas - groovy series

es posible salir de un cierre en groovy

Question

hay una manera de ''romper'' de un cierre maravilloso.

tal vez algo como esto:

[1, 2, 3].each { 
  println(it)
  if (it == 2)
    break 
}

Answer 1

A menudo olvido que Groovy implementa un "cualquiera" método.

[1, 2, 3].any
{   
   println it
   return (it == 2)
}​

Answer 2

Con rx-java puede transformar un iterable en un observable.

Luego puede reemplazar continuar con un filtro y romper con takeWhile

Aquí hay un ejemplo:

import rx.Observable

Observable.from(1..100000000000000000)
          .filter { it % 2 != 1} 
          .takeWhile { it<10 } 
          .forEach {println it}

Answer 3

Eche un vistazo al mejor patrón para simular continuar en un cierre maravilloso para una amplia discusión.

Answer 4

Esto es en apoyo de la respuesta de John Wagenleiter. La respuesta de Tigerizzy es completamente incorrecta. Se puede refutar fácilmente prácticamente ejecutando su primera muestra de código, o teóricamente leyendo la documentación de Groovy. Un retorno devuelve un valor (o nulo sin un argumento) de la iteración actual, pero no detiene la iteración. En un cierre se comporta más bien como continuar .

No podrás utilizar Inject sin entender esto.

No hay forma de ''romper el ciclo'' excepto lanzando una excepción. El uso de excepciones para este propósito se considera maloliente. Entonces, tal como lo sugiere Wagenleiter, la mejor práctica es filtrar los elementos sobre los que desea iterar antes de ejecutar cada uno o uno de sus primos.

Answer 5

Esto es lo que funcionó para mí en el editor de Groovy en Katalon Studio:

while (myTestObject.findProperty(''css'')!=null){
    try {
    WebUI.click(myTestObject)
    CustomKeywords.''com.at.util.ScreenshotHelper.catchNotyMessage''()
    } 
    catch (Exception e) {
    break;
    }
}

Answer 6

Hay otra solución. Aunque, esas cosas maravillosas como cada / find / any son bastante geniales: si no encajan, no las uses. Todavía puedes usar el viejo simple

for (def element : list)

Especialmente, si quieres abandonar el método, también. Ahora puede utilizar continue / break / return como lo desee. El código resultante puede no ser genial, pero es fácil y comprensible.

Answer 7

Intenta usar cualquiera en lugar de cada uno

def list = [1, 2, 3, 4, 5, -1, -2]
list.any { element ->
    if (element > 3)
    return true // break
    println element
}

El resultado: 1, 2, 3

Answer 8

Puedes lanzar una excepción:

try {
    [1, 2, 3].each { 
        println(it)
        if (it == 2)
            throw new Exception("return from closure") 
    }
} catch (Exception e) { }

El uso también podría usar "findAll" o "grep" para filtrar su lista y luego usar "each".

[1, 2, 3].findAll{ it < 3 }.each{ println it }

Answer 9

Solo usando un cierre especial

// declare and implement:
def eachWithBreak = { list, Closure c ->
  boolean bBreak = false
  list.each() { it ->
     if (bBreak) return
     bBreak = c(it)
  }
}

def list = [1,2,3,4,5,6]
eachWithBreak list, { it ->
  if (it > 3) return true // break ''eachWithBreak''
  println it
  return false // next it
}

Answer 10

12/05/2013 Muy editado.

Respondiendo la pregunta que se hizo.

¿Es posible salir de un cierre?

Usted " saldría " de un cierre emitiendo la palabra clave return . Sin embargo, eso no es útil en el ejemplo que se da. La razón de esto es que el método de cierre (piense en él como un método) es invocado por each método para cada elemento de la colección.

Si ejecuta este ejemplo, verá que imprimirá 1 y luego 3.

[1, 2, 3].each {
  if (it == 2) return
  println(it)
}

Por qué break en el contexto de each no tiene sentido.

Para entender por qué no puedes salir de each método como si pudieras salir de un bucle for , necesitas entender un poco de lo que realmente está sucediendo. Aquí hay una gran simplificación de lo que hace cada método en una colección.

myEach([0,1,3])

void myEach(List things) {
    for (i in things) {
        myEachMethod(i)
    }
}

void myEachMethod(Object it) { // this is your Closure
    if(it == 2) return
    println it
}

Como puede ver, el cierre es básicamente un método que puede transmitirse. Al igual que en Java, no se puede interrumpir desde el método call o closure.

Qué hacer en lugar de romper con each .

En Groovy se supone que debes expresar tu código usando abstracciones de alto nivel ya que ese bucle primitivo no es idiomático. Para el ejemplo que dio, consideraría utilizar FindAll. Por ejemplo:

[1,2,3].findAll { it < 2 }.each { println it }

Espero que esto te ayude a entender lo que está pasando.

Respondiendo la pregunta implícita.

¿Puedes salir de Collection.each iteración contra tu cierre provisto?

No se puede salir de each métodos sin lanzar y atrapar una excepción como ha dicho John Wagenleitner. Aunque yo diría que arrojar y atrapar una excepción en nombre del control de flujo es un olor a código y un compañero programador podría darle una palmada en las manos.