break и continue в forEach Kotlin: как это работает под капотом

Онлайн-тренажер Python для начинающих

Изучайте Python легко и без перегрузки теорией. Решайте практические задачи с автоматической проверкой, получайте подсказки на русском языке и пишите код прямо в браузере — без необходимости что-либо устанавливать.

Начать курс

Почему `break` и `continue` не работают в `forEach` Kotlin (и как это исправить)

Если вы когда-нибудь писали на Kotlin и пытались досрочно выйти из цикла forEach с помощью break, то, скорее всего, столкнулись с красным подчеркиванием в IDE и ошибкой компиляции. Знакомо? Вы не одиноки — это один из самых популярных вопросов на Stack Overflow по Kotlin, набравший тысячи просмотров. В этой статье мы не просто покажем, как обойти ограничение, но и заглянем под капот: почему так сделано, как работает return внутри лямбды и какие альтернативы существуют. Поехали!

Классический пример: ошибка новичка

Представьте, что у вас есть список чисел, и вам нужно вывести на экран только первые три элемента. Интуитивно хочется написать так:

val numbers = listOf(1, 2, 3, 4, 5)
numbers.forEach {
    println(it)
    if (it == 3) break // Ошибка компиляции!
}

Компилятор выдаст ошибку: ‘break’ and ‘continue’ are only allowed inside a loop. Почему? Ведь forEach — это вроде бы цикл? Ответ кроется в том, как устроен forEach на самом деле.

Анатомия `forEach`: это не цикл, а вызов функции

Давайте откроем стандартную библиотеку Kotlin и посмотрим на сигнатуру forEach:

public inline fun <T> Iterable<T>.forEach(action: (T) -> Unit): Unit {
    for (element in this) action(element)
}

Ключевое слово здесь — inline. Это означает, что на этапе компиляции тело функции вставляется прямо в место вызова. Но всё равно forEach — это функция высшего порядка, которая принимает другую функцию (лямбду) в качестве аргумента. А лямбда — это не блок кода цикла, это обычный объект-функция. break и continue имеют смысл только внутри конструкций for, while или do-while, а не внутри произвольной функции.

Другими словами, когда вы пишете numbers.forEach { ... }, вы не создаёте цикл — вы вызываете метод, который сам внутри себя использует цикл for. Компилятор не может «прокинуть» break из вашей лямбды во внешний цикл, потому что лямбда — это отдельная сущность. Это не баг, это дизайн.

Как работает `return` в `forEach` (неожиданный поворот)

А вот return внутри forEach работает... но не так, как вы ожидаете. Смотрите:

fun main() {
    val numbers = listOf(1, 2, 3, 4, 5)
    numbers.forEach {
        if (it == 3) return // Выход из main()!
        println(it)
    }
    println("Эта строка не выполнится")
}

Вывод будет: 1 2. return здесь — это non-local return (нелокальный возврат). Он завершает не только лямбду, но и всю внешнюю функцию (main). Это работает благодаря тому, что forEach объявлен как inline. Компилятор встраивает код лямбды прямо в тело main, и return начинает относиться к ближайшей объявленной fun, то есть к main.

Если вы хотите выйти только из forEach, а не из всей функции, используйте метку (label):

fun main() {
    val numbers = listOf(1, 2, 3, 4, 5)
    numbers.forEach loop@{
        if (it == 3) return@loop
        println(it)
    }
    println("Эта строка выполнится")
}

Вывод: 1 2 и Эта строка выполнится. Метка loop@ говорит компилятору: «выйди из лямбды, но не из main». По сути, это аналог continue — мы пропускаем текущую итерацию и переходим к следующему элементу.

Как эмулировать `break` и `continue` в `forEach`

Теперь, когда мы понимаем механику, давайте посмотрим на все способы обойти ограничение. У каждого подхода есть свои плюсы и минусы.

1. Использование `return@label` как `continue`

Мы уже видели этот способ. Если нужно пропустить итерацию, просто используйте return@label:

val numbers = listOf(1, 2, 3, 4, 5)
numbers.forEach { value ->
    if (value % 2 == 0) return@forEach
    println(value)
}
// Вывод: 1 3 5

Здесь return@forEach — это встроенное имя метки, совпадающее с именем функции. Можно переименовать, но так читаемее.

2. Использование внешнего флага для `break`

Для имитации break можно завести переменную-флаг:

val numbers = listOf(1, 2, 3, 4, 5)
var shouldStop = false
numbers.forEach {
    if (shouldStop) return@forEach
    println(it)
    if (it == 3) shouldStop = true
}
// Вывод: 1 2 3

Минус: код становится грязным, флаг нужно проверять на каждой итерации. Работает, но некрасиво.

3. Использование `takeWhile` или `first`

Часто задачу можно решить без forEach вообще. Например, если нужно обработать элементы до первого совпадения с условием, используйте takeWhile:

val numbers = listOf(1, 2, 3, 4, 5)
numbers.takeWhile { it != 3 }.forEach { println(it) }
// Вывод: 1 2

Или если нужно найти первый элемент и остановиться — first или firstOrNull.

4. Превращаем `forEach` в обычный `for`

Самый прямолинейный способ — просто использовать старый добрый for:

for (number in numbers) {
    if (number == 3) break
    println(number)
}

Никакой магии, полный контроль. Kotlin — мультипарадигмальный язык, и никто не заставляет вас всегда использовать функциональный стиль. Если логика требует break или continue, просто переходите на императивный for.