"break" e "continue" in "forEach" in Kotlin

Kotlin ha funzioni di iterazione molto carine, come forEacho repeat, ma non sono in grado di far funzionare gli operatori breake continue(sia locali che non locali):

repeat(5) {
    break
}

(1..5).forEach {
    continue@forEach
}

L'obiettivo è imitare i soliti loop con la sintassi funzionale il più vicino possibile. Era sicuramente possibile in alcune versioni precedenti di Kotlin, ma faccio fatica a riprodurre la sintassi.

Il problema potrebbe essere un bug con le etichette (M12), ma penso che il primo esempio dovrebbe funzionare comunque.

Mi sembra di aver letto da qualche parte su uno speciale trucco / annotazione, ma non sono riuscito a trovare alcun riferimento sull'argomento. Potrebbe assomigliare al seguente:

public inline fun repeat(times: Int, @loop body: (Int) -> Unit) {
    for (index in 0..times - 1) {
        body(index)
    }
}

Modifica :
secondo la documentazione di Kotlin , è possibile utilizzare le annotazioni.

fun foo() {
    listOf(1, 2, 3, 4, 5).forEach lit@{
        if (it == 3) return@lit // local return to the caller of the lambda, i.e. the forEach loop
        print(it)
    }
    print(" done with explicit label")
}

Risposta originale :
poiché fornisci a (Int) -> Unit, non puoi interromperlo, poiché il compilatore non sa che viene utilizzato in un ciclo.

Hai poche opzioni:

Usa un ciclo for regolare:

for (index in 0 until times) {
    // your code here
}

Se il ciclo è l'ultimo codice nel metodo
che puoi usare returnper uscire dal metodo (o return valuese non è unitmetodo).

Usa un metodo
Crea un metodo di ripetizione personalizzato che ritorni Booleanper continuare.

public inline fun repeatUntil(times: Int, body: (Int) -> Boolean) {
    for (index in 0 until times) {
        if (!body(index)) break
    }
}

Verrà stampato da 1 a 5. return@forEachAgisce come la parola chiave continuein Java, il che significa che in questo caso esegue ancora ogni ciclo ma salta all'iterazione successiva se il valore è maggiore di 5.

fun main(args: Array<String>) {
    val nums = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
    nums.forEach {
       if (it > 5) return@forEach
       println(it)
    }
}

Questo stamperà da 1 a 10 ma salterà 5.

fun main(args: Array<String>) {
    val nums = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
    nums.forEach {
       if (it == 5) return@forEach
       println(it)
    }
}

Provali al Kotlin Playground .

Una pausa può essere ottenuta utilizzando:

//Will produce"12 done with nested loop"
//Using "run" and a tag will prevent the loop from running again. Using return@forEach if I>=3 may look simpler, but it will keep running the loop and checking if i>=3 for values >=3 which is a waste of time.
fun foo() {
    run loop@{
        listOf(1, 2, 3, 4, 5).forEach {
            if (it == 3) return@loop // non-local return from the lambda passed to run
            print(it)
        }
    }
    print(" done with nested loop")
}

E si può ottenere una continuazione con:

//Will produce: "1245 done with implicit label"
fun foo() {
    listOf(1, 2, 3, 4, 5).forEach {
        if (it == 3) return@forEach // local return to the caller of the lambda, i.e. the forEach loop
        print(it)
    }
    print(" done with implicit label")
}

Come chiunque qui consiglia ... leggi i documenti: P https://kotlinlang.org/docs/reference/returns.html#return-at-labels

È possibile utilizzare l' espressione return from lambda che imita continueao a breakseconda dell'utilizzo.

Questo è trattato nella domanda correlata: come faccio a fare una "pausa" o "continuare" quando sono in un ciclo funzionale all'interno di Kotlin?

Come dice la documentazione di Kotlin , l'utilizzo returnè la strada da percorrere. La cosa buona di kotlin è che se hai funzioni annidate, puoi usare le etichette per scrivere esplicitamente da dove proviene il tuo ritorno:

Funzione Scope Return

fun foo() {
  listOf(1, 2, 3, 4, 5).forEach {
    if (it == 3) return // non-local return directly to the caller of foo()
    print(it)
  }
  println("this point is unreachable")
}

e Local Return (non smette di andare avanti per ogni = continuazione)

fun foo() {
  listOf(1, 2, 3, 4, 5).forEach lit@{
    if (it == 3) return@lit // local return to the caller of the lambda, i.e. the forEach loop
    print(it)
  }
  print(" done with explicit label")
}

Controlla la documentazione, è davvero buona :)

continue digitare il comportamento in forEach

list.forEach { item -> // here forEach give you data item and you can use it 
    if () {
        // your code
        return@forEach // Same as continue
    }

    // your code
}

per il breaktipo di comportamento che devi usare for in untilo for insecondo l'elenco è NullableoNon-Nullable

1. Per l' elenco nullable :

   for (index in 0 until list.size) {
       val item = list[index] // you can use data item now
       if () {
           // your code
           break
       }
   
       // your code
   }

2. Per l' elenco non annullabile :

   for (item in list) { // data item will available right away
       if () {
           // your code
           break
       }
   
       // your code
   }

Istruzione Break per cicli annidati forEach ():

listOf("a", "b", "c").forEach find@{ i ->
    listOf("b", "d").forEach { j ->
        if (i == j) return@find
        println("i = $i, j = $j")
    }
}

Risultato:

i = a, j = b
i = a, j = d
i = c, j = b
i = c, j = d

Continua istruzione con funzione anonima:

listOf(1, 2, 3, 4, 5).forEach(fun(value: Int) {
    if (value == 3) return
    print("$value ")
})

Risultato:

1 2 4 5 

forse cambiare per ciascuno

for(it in myList){
   if(condition){
     doSomething()
   }else{
     break //or continue
    }
} 

funziona per hashmap

 for(it in myMap){
     val k = it.key
     val v = it.value

       if(condition){
         doSomething()
       }else{
         break //or continue
        }
    }