> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Kotlin Continue
The `continue` keyword in Kotlin is a structural jump expression that immediately terminates the execution of the current iteration within a loop (`for`, `while`, or `do-while`). Control flow is transferred directly to the loop's next iteration phase, bypassing any remaining statements in the current loop body.
Depending on the loop type, the exact control flow transfer behaves as follows:
* **`for` loop:** Control jumps to the retrieval of the next element from the underlying iterator.
* **`while` and `do-while` loops:** Control jumps directly to the evaluation of the loop's boolean condition.
In Kotlin's type system, `continue` evaluates to the `Nothing` type, signifying an expression that never completes normally.
## Unlabeled `continue`
By default, an unqualified `continue` statement applies to the innermost enclosing loop.
```kotlin theme={"dark"}
for (i in 1..5) {
if (i % 2 == 0) {
continue
}
println(i)
}
```
## Labeled `continue`
Kotlin supports loop labeling, allowing developers to explicitly define the target loop for the jump expression. While frequently applied within nested loop architectures to bypass the innermost loop default, a labeled `continue` is syntactically valid on any labeled loop, including single, non-nested loops.
A label is defined using an identifier followed by the `@` symbol (e.g., `target@`). The `continue` expression invokes the label by appending the `@` symbol and the identifier (e.g., `continue@target`).
```kotlin theme={"dark"}
outerLoop@ for (i in 1..5) {
for (j in 1..5) {
if (j == 3) {
continue@outerLoop
}
println("i = $i, j = $j")
}
}
```
## Lexical Scoping Constraints
The `continue` expression is strictly lexically scoped. It cannot be used to jump across function boundaries, including lambda expressions and anonymous objects. If a loop contains a higher-order function taking a lambda, a `continue` statement cannot be placed inside that lambda to affect the outer loop. Unlike the `return` keyword, which can perform non-local returns when used inside a lambda passed to an `inline` function, Kotlin does not support non-local `continue` (or `break`) statements under any circumstances.
However, within the valid lexical scope of the loop, `continue` can be deeply nested inside any block or expression. Because `continue` evaluates to `Nothing`, it satisfies any type requirement. This allows it to be used idiomatically on the right-hand side of the Elvis operator (`?:`), within `try-catch` blocks, or inside deeply nested conditional statements, provided no function or lambda boundaries are crossed.
```kotlin theme={"dark"}
for (item in listOf("A", null, "B")) {
// Valid use of continue nested within an expression
val nonNullItem = item ?: continue
try {
if (nonNullItem == "Skip") {
continue
}
println(nonNullItem)
} catch (e: Exception) {
continue
}
}
```
Tired of Poor Kotlin Skills? Fix That With Deep Grasping!
Learn More
