`break` и` continue` в `forEach` в Котлине

Котлин имеет очень хорошие функции перебора, как forEachили repeat, но я не в состоянии сделать breakи 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")
}

Исходный ответ :
поскольку вы указываете a (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Действует как ключевое слово continueв Java, что означает, что в этом случае он по-прежнему выполняет каждый цикл, но переходит к следующей итерации, если значение больше 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

Вы можете использовать выражение return из лямбда, которое имитирует continueили в breakзависимости от вашего использования.

Это рассматривается в соответствующем вопросе: как мне выполнить «прерывание» или «продолжение» в функциональном цикле внутри Kotlin?

Как говорится в документации Kotlin , использование return- это правильный выбор. В kotlin хорошо то, что если у вас есть вложенные функции, вы можете использовать метки, чтобы явно указать, откуда происходит ваш возврат:

Функция 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")
}

и местный возврат (не прекращается forEach = continue)

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. Для списка, допускающего значение NULL :

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

2. Для списка, не допускающего значения NULL :

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

Оператор Break для вложенных циклов 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

Оператор продолжения с анонимной функцией:

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

Я знаю, что это может быть не совсем связано с break continue for forEach, но так как 1.3.70у нас есть, scanчтобы мы могли получить хотя бы промежуточные результаты.

    fun charValue(c: Char) : Int {
      return if (c == '(') 1 else -1
    }

    val all = s.scan(0) { acc, c -> acc + charValue(c) }
    return all.indexOf(-1)

Итак, теперь, если вы можете собрать все результаты (аналогичные map), которые могут вам не понадобиться, однако, если вы позволите ему закончить, вы можете пропустить разрыв и просто проверить окончательный массив.

IMHO, базовое функциональное программирование на самом деле не учитывает transformоперацию, которая должна выпрыгнуть посередине, не завершив ее. Чтобы действительно решить эту проблему, нам нужно создать функцию, которая учитывает условие возврата, например.

  reduceReturnIf(acc, value, returnIf: func)