Kotlin中的' forEach '中的' break '和' continue '

Kotlin有非常好的迭代函数，如forEach或repeat，但我不能使中断和继续操作符与它们一起工作(本地和非本地):

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

当前回答

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

这将输出1到4，当达到5时中断。

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

链接到ashuges的代码片段。

2017-12-04 18:27:54

其他回答

forEach():

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

带有匿名函数的Continue语句:

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

结果:

1 2 4 5

2020-03-16 23:36:46

我有一个完美的解决方案(:

list.apply{ forEach{ item ->
    if (willContinue(item)) return@forEach
    if (willBreak(item)) return@apply
}}

2020-10-09 11:08:46

也许把forEach改成这样:

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

它适用于HashMap的:

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

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

2020-06-18 20:28:52

正如Kotlin文档所说，使用return是正确的方法。Kotlin的好处是，如果你有嵌套函数，你可以使用标签显式地写你的返回值来自哪里:

函数范围

fun foo() {
    listOf(1, 2, 3, 4, 5).forEach {
        /** Non-local return directly to the caller of foo(). */
        if (it == 3) return
        print(it)
    }

    println("this point is unreachable")
}

当地的回报

它不会在forEach循环中停止(它就像for循环中的continue)。

fun foo() {
    listOf(1, 2, 3, 4, 5).forEach lit@{
        /** Local return to the caller of the lambda, i.e. the forEach loop. */
        if (it == 3) return@lit
        print(it)
    }

    print(" done with explicit label")
}

看看文档，它真的很好:)

2018-07-06 15:20:21