在Kotlin的`forEach`中的`break`和`continue`

Kotlin具有很好的迭代功能，例如forEach或repeat，但是我无法使breakand continue运算符与它们一起使用（本地和非本地）：

repeat(5) {
    break
}

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

目标是使用功能语法尽可能接近的方式模仿常规循环。在某些较旧的Kotlin版本中肯定是有可能的，但是我很难重现该语法。

问题可能是带有标签（M12）的错误，但是我认为第一个示例仍然可以工作。

在我看来，我已经阅读过有关特殊技巧/注释的内容，但是找不到关于该主题的任何参考资料。可能如下所示：

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

编辑：
根据Kotlin的文档，可以使用注释。

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

原始答案：
由于您提供了(Int) -> Unit，所以您无法中断它，因为编译器不知道它在循环中使用。

您有几种选择：

使用常规的for循环：

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

如果循环是方法中的最后一个代码，则
可以return用来退出方法（或者return value如果不是unit方法）。

使用方法
创建一个自定义重复方法方法，该方法返回Boolean以继续。

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

这将打印1到5。return@forEach行为类似于continueJava中的关键字，这意味着在这种情况下，它仍然执行每个循环，但如果该值大于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)
    }
}

这将打印1至10，但跳过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)
    }
}

在Kotlin Playground尝试一下。

可以使用以下方法实现休息：

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

并且可以通过以下方式实现继续：

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

正如这里的任何人所建议...阅读文档：P https://kotlinlang.org/docs/reference/returns.html#return-at-labels

您可以使用模拟或的lambda表达式返回值，具体取决于您的用法。continuebreak

相关问题涵盖了这一点： 在Kotlin的功能循环中，如何执行“中断”或“继续”？

正如Kotlin文档所说，使用return是必经之路。关于kotlin的好处是，如果您具有嵌套函数，则可以使用标签来显式地写出返回的来源：

功能范围返回

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

和 本地回报（不会停止通过forEach =连续）

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

查看文档，这真的很好:)

continue 输入行为 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
}

对于break类型行为，您必须使用for in until或for in根据列表是Nullable或Non-Nullable

1. 对于可空列表：

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

2. 对于非空列表：

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

嵌套循环forEach（）的break语句：

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

结果：

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

使用匿名函数继续语句：

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

结果：

1 2 4 5 

也许改变每个

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

它适用于哈希图

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

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