`break` und` continue` in` forEach` in Kotlin

Kotlin hat sehr schöner Iterieren Funktionen, wie forEachoder repeat, aber ich bin nicht in der Lage das zu machen breakund continuemit ihnen Operatoren arbeiten (sowohl lokale als auch nicht-lokal):

repeat(5) {
    break
}

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

Das Ziel ist es, übliche Schleifen mit der funktionalen Syntax so nah wie möglich nachzuahmen. In einigen älteren Versionen von Kotlin war dies definitiv möglich, aber ich habe Schwierigkeiten, die Syntax zu reproduzieren.

Das Problem könnte ein Fehler mit Labels (M12) sein, aber ich denke, dass das erste Beispiel trotzdem funktionieren sollte.

Es scheint mir, dass ich irgendwo über einen speziellen Trick / eine spezielle Anmerkung gelesen habe, aber ich konnte keine Referenz zu diesem Thema finden. Könnte wie folgt aussehen:

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

Bearbeiten :
Laut Kotlins Dokumentation ist es möglich, Anmerkungen zu verwenden.

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")
}

Ursprüngliche Antwort :
Da Sie a angeben (Int) -> Unit, können Sie nicht davon abbrechen, da der Compiler nicht weiß, dass es in einer Schleife verwendet wird.

Sie haben wenige Möglichkeiten:

Verwenden Sie eine reguläre for-Schleife:

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

Wenn die Schleife der letzte Code in der Methode ist
, können Sie returndie Methode verlassen (oder return valuewenn es sich nicht um eine unitMethode handelt).

Verwenden einer Methode
Erstellen Sie eine benutzerdefinierte Methode Booleanfür Wiederholungsmethoden, die zum Fortfahren zurückgegeben wird.

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

Dies gibt 1 bis 5 aus. Das return@forEachVerhalten verhält sich wie das Schlüsselwort continuein Java, was in diesem Fall bedeutet, dass immer noch jede Schleife ausgeführt wird, aber zur nächsten Iteration gesprungen wird, wenn der Wert größer als 5 ist.

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)
    }
}

Dies gibt 1 bis 10 aus, überspringt jedoch 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)
    }
}

Probieren Sie sie auf dem Kotlin Playground aus .

Eine Pause kann erreicht werden mit:

//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")
}

Und eine Fortsetzung kann erreicht werden mit:

//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")
}

Wie hier jeder empfiehlt ... lesen Sie die Dokumente: P https://kotlinlang.org/docs/reference/returns.html#return-at-labels

Sie können den Ausdruck return from lambda verwenden, der a continueoder breakabhängig von Ihrer Verwendung nachahmt .

Dies wird in der entsprechenden Frage behandelt: Wie mache ich eine "Pause" oder "Fortsetzung", wenn ich mich in einer Funktionsschleife innerhalb von Kotlin befinde?

Wie in der Kotlin-Dokumentation angegeben , returnist die Verwendung der richtige Weg. Das Gute an Kotlin ist, dass Sie, wenn Sie verschachtelte Funktionen haben, Labels verwenden können, um explizit zu schreiben, woher Ihre Rückkehr stammt:

Rückgabe des Funktionsumfangs

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")
}

und Local Return (es hört nicht auf, forEach = Fortsetzung durchzugehen)

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")
}

Kasse die Dokumentation, es ist wirklich gut :)

continue Verhalten eingeben 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
}

Für das breakTypverhalten müssen Sie verwenden for in untiloder for ingemäß der Liste ist NullableoderNon-Nullable

1. Für nullbare Liste:

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

2. Für nicht nullbare Liste:

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

Break-Anweisung für verschachtelte Schleifen forEach ():

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

Ergebnis:

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

Fortsetzung der Anweisung mit anonymer Funktion:

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

Ergebnis:

1 2 4 5 

vielleicht für jeden ändern

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

Es funktioniert für Hashmaps

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

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