Условия и циклы

Инструкции

Если вы используете when как инструкцию, охватывать все возможные случаи не нужно. В этом примере некоторые случаи не охвачены, поэтому ни одна ветвь не выполняется. При этом ошибки не возникает:

fun main() {
    //sampleStart
    val deliveryStatus = "OutForDelivery"
    when (deliveryStatus) {
        // Not all cases are covered
        "Pending" -> print("Your order is being prepared")
        "Shipped" -> print("Your order is on the way")
    }
    //sampleEnd
}

Как и в случае с if, каждая ветвь может быть блоком, а ее значение определяется последним выражением в блоке.

Выражения

Если вы используете when как выражение, вы должны охватить все возможные случаи. Значением всего выражения становится значение первой совпавшей ветви. Если охвачены не все случаи, компилятор выдает ошибку.

Если у выражения when есть проверяемое значение, можно использовать ветвь else, чтобы убедиться, что охвачены все возможные случаи, но это не обязательно. Например, если проверяемое значение имеет тип Boolean, классом enum, классом sealed или одним из их nullable-вариантов, все случаи можно охватить без ветви else:

import kotlin.random.Random
//sampleStart
enum class Bit {
    ZERO, ONE
}

fun getRandomBit(): Bit {
    return if (Random.nextBoolean()) Bit.ONE else Bit.ZERO
}

fun main() {
    val numericValue = when (getRandomBit()) {
        // No else branch is needed because all cases are covered
        Bit.ZERO -> 0
        Bit.ONE -> 1
    }

    println("Random bit as number: $numericValue")
    // Random bit as number: 0
    //sampleEnd
}

Если у выражения when нет проверяемого значения, у него должна быть ветвь else, иначе компилятор выдаст ошибку. Ветвь else выполняется, если ни одно из остальных условий ветвей не выполнено:

fun main() {
    //sampleStart
    val localFileSize = 1200
    val remoteFileSize = 1200

    val message = when {
        localFileSize > remoteFileSize -> "Local file is larger than remote file"
        localFileSize < remoteFileSize -> "Local file is smaller than remote file"
        else -> "Local and remote files are the same size"
    }

    println(message)
    // Local and remote files are the same size
    //sampleEnd
}

Другие способы использования when

Выражения и инструкции when позволяют упростить код, обработать несколько условий и выполнить проверки типов разными способами.

Объедините несколько условий в одной ветви с помощью запятых:

fun main() {
    val ticketPriority = "High"
    //sampleStart
    when (ticketPriority) {
        "Low", "Medium" -> print("Standard response time")
        else -> print("High-priority handling")
    }
    //sampleEnd
}

Используйте в качестве условий ветвей выражения, результатом которых является true или false:

fun main() {
    val storedPin = "1234"
    val enteredPin = 1234
  
    //sampleStart
    when (enteredPin) {
        // Expression
        storedPin.toInt() -> print("PIN is correct")
        else -> print("Incorrect PIN")
    }
    //sampleEnd
}

Проверьте, входит ли значение в диапазон или коллекцию, с помощью ключевых слов in или !in:

fun main() {
    val x = 7
    val validNumbers = setOf(15, 16, 17)

    //sampleStart
    when (x) {
        in 1..10 -> print("x is in the range")
        in validNumbers -> print("x is valid")
        !in 10..20 -> print("x is outside the range")
        else -> print("none of the above")
    }
    //sampleEnd
}

Проверьте тип значения с помощью ключевых слов is или !is. Благодаря умным приведениям типов можно обращаться непосредственно к функциям-членам и свойствам этого типа:

fun hasPrefix(input: Any): Boolean = when (input) {
    is String -> input.startsWith("ID-")
    else -> false
}

fun main() {
    val testInput = "ID-98345"
    println(hasPrefix(testInput))
    // true
}

Используйте when вместо традиционной цепочки if-else-if. Без проверяемого значения условия ветвей — это просто логические выражения. Выполняется первая ветвь с условием true:

fun Int.isOdd() = this % 2 != 0
fun Int.isEven() = this % 2 == 0

fun main() {
    //sampleStart
    val x = 5
    val y = 8

    when {
        x.isOdd() -> print("x is odd")
        y.isEven() -> print("y is even")
        else -> print("x+y is odd")
    }
    // x is odd
    //sampleEnd
}

Наконец, сохраните проверяемое значение в переменной, используя следующий синтаксис:

fun main() {
    val message = when (val input = "yes") {
        "yes" -> "You said yes"
        "no" -> "You said no"
        else -> "Unrecognized input: $input"
    }

    println(message)
    // You said yes
}

Область видимости переменной, объявленной как проверяемое значение, ограничена телом выражения или инструкции when.

Условия-ограничители

Условия-ограничители позволяют добавить несколько условий к ветвям выражения или инструкции when, делая сложный поток выполнения более понятным и лаконичным. Условия-ограничители можно использовать с when, если у него есть проверяемое значение.

Разместите условие-ограничитель после основного условия в той же ветви, отделив его с помощью if:

sealed interface Animal {
    data class Cat(val mouseHunter: Boolean) : Animal
    data class Dog(val breed: String) : Animal
}

fun feedDog() = println("Feeding a dog")
fun feedCat() = println("Feeding a cat")

//sampleStart
fun feedAnimal(animal: Animal) {
    when (animal) {
        // Branch with only primary condition
        // Calls feedDog() when animal is Dog
        is Animal.Dog -> feedDog()
        // Branch with both primary and guard conditions
        // Calls feedCat() when animal is Cat and not mouseHunter
        is Animal.Cat if !animal.mouseHunter -> feedCat()
        // Prints "Unknown animal" if none of the above conditions match
        else -> println("Unknown animal")
    }
}

fun main() {
    val animals = listOf(
        Animal.Dog("Beagle"),
        Animal.Cat(mouseHunter = false),
        Animal.Cat(mouseHunter = true)
    )

    animals.forEach { feedAnimal(it) }
    // Feeding a dog
    // Feeding a cat
    // Unknown animal
}
//sampleEnd

Нельзя использовать условия-ограничители, если несколько условий разделены запятой. Например:

0, 1 -> print("x == 0 or x == 1")

В одном выражении или инструкции when можно сочетать ветви с условиями-ограничителями и без них. Код в ветви с условием-ограничителем выполняется, только если и основное условие, и условие-ограничитель принимают значение true. Если основное условие не совпадает, условие-ограничитель не проверяется.

Поскольку инструкции when не требуют охватывать все случаи, использование условий-ограничителей в инструкциях when без ветви else означает, что при отсутствии совпадений код не выполняется.

В отличие от инструкций, выражения when должны охватывать все случаи. Если в выражениях when используются условия-ограничители без ветви else, компилятор требует обработать каждый возможный случай, чтобы избежать ошибок во время выполнения.

Объедините несколько условий-ограничителей в одной ветви с помощью логических операторов && (И) или || (ИЛИ). Чтобы избежать неоднозначности, заключайте логические выражения в круглые скобки:

when (animal) {
    is Animal.Cat if (!animal.mouseHunter && animal.hungry) -> feedCat()
}

Условия-ограничители также поддерживают else if:

when (animal) {
    // Checks if `animal` is `Dog`
    is Animal.Dog -> feedDog()
    // Guard condition that checks if `animal` is `Cat` and not `mouseHunter`
    is Animal.Cat if !animal.mouseHunter -> feedCat()
    // Calls giveLettuce() if none of the above conditions match and animal.eatsPlants is true
    else if animal.eatsPlants -> giveLettuce()
    // Prints "Unknown animal" if none of the above conditions match
    else -> println("Unknown animal")
}

Генерация байт-кода для JVM

При компиляции кода Kotlin для JVM 21 или новее компилятор генерирует инструкцию invokedynamic для подходящих выражений when. В результате получается байт-код меньшего размера, похожий на байт-код, создаваемый инструкциями switch в Java.

Компилятор использует invokedynamic с методом SwitchBootstraps.typeSwitch(), если выполняются все следующие условия:

• Все условия, кроме else, представляют собой проверки is или null.

• Выражение when не содержит условий-ограничителей (if).

• Условия не включают типы, которые нельзя проверить непосредственно, например изменяемые коллекции Kotlin (MutableList) или функциональные типы (kotlin.Function1, kotlin.Function2 и т. д.).

• Выражение when содержит как минимум два условия, помимо else.

• Во всех ветвях проверяется одно и то же проверяемое значение выражения when.

Например:

open class Shape

class Circle : Shape()
class Rectangle : Shape()
class Triangle : Shape()

fun countCorners(shape: Shape) = when (shape) {
    is Circle -> 0
    is Rectangle -> 4
    is Triangle -> 3
    else -> -1
}

Приведенное здесь выражение when (shape) компилируется в одно переключение по типу invokedynamic вместо нескольких проверок instanceof в байт-коде.

Диапазоны

Чтобы перебрать диапазон чисел, используйте выражение диапазона с операторами .. и ..<:

fun main() {
//sampleStart
    println("Closed-ended range:")
    for (i in 1..6) {
        print(i)
    }
    // Closed-ended range:
    // 123456
  
    println("\nOpen-ended range:")
    for (i in 1..<6) {
        print(i)
    }
    // Open-ended range:
    // 12345
  
    println("\nReverse order in steps of 2:")
    for (i in 6 downTo 0 step 2) {
        print(i)
    }
    // Reverse order in steps of 2:
    // 6420
//sampleEnd
}

Массивы

Чтобы перебрать массив или список с индексом, можно использовать свойство indices:

fun main() {
    val routineSteps = arrayOf("Wake up", "Brush teeth", "Make coffee")
    //sampleStart
    for (i in routineSteps.indices) {
        println(routineSteps[i])
    }
    // Wake up
    // Brush teeth
    // Make coffee
    //sampleEnd
}

В качестве альтернативы можно использовать функцию .withIndex() из стандартной библиотеки:

fun main() {
    val routineSteps = arrayOf("Wake up", "Brush teeth", "Make coffee")
    //sampleStart
    for ((index, value) in routineSteps.withIndex()) {
        println("The step at $index is \"$value\"")
    }
    // The step at 0 is "Wake up"
    // The step at 1 is "Brush teeth"
    // The step at 2 is "Make coffee"
    //sampleEnd
}

Итераторы

Цикл for выполняет итерацию по любому объекту, предоставляющему итератор. Коллекции предоставляют итераторы по умолчанию, тогда как диапазоны и массивы компилируются в циклы с индексацией.

Вы можете создать собственный итератор, предоставив функцию-член или функцию-расширение с именем iterator(), которая возвращает Iterator<>. Функция iterator() должна иметь функцию next() и функцию hasNext(), возвращающую Boolean.

Проще всего создать собственный итератор для класса, унаследовав его от интерфейса Iterable<T> и переопределив уже имеющиеся функции iterator(), next() и hasNext(). Например:

class Booklet(val totalPages: Int) : Iterable<Int> {
    override fun iterator(): Iterator<Int> {
        return object : Iterator<Int> {
            var current = 1
            override fun hasNext() = current <= totalPages
            override fun next() = current++
        }
    }
}

fun main() {
    val booklet = Booklet(3)
    for (page in booklet) {
        println("Reading page $page")
    }
    // Reading page 1
    // Reading page 2
    // Reading page 3
}

В качестве альтернативы можно создать функции с нуля. В этом случае добавьте к функциям ключевое слово operator:

//sampleStart
class Booklet(val totalPages: Int) {
    operator fun iterator(): Iterator<Int> {
        return object {
            var current = 1

            operator fun hasNext() = current <= totalPages
            operator fun next() = current++
        }.let {
            object : Iterator<Int> {
                override fun hasNext() = it.hasNext()
                override fun next() = it.next()
            }
        }
    }
}
//sampleEnd

fun main() {
    val booklet = Booklet(3)
    for (page in booklet) {
        println("Reading page $page")
    }
    // Reading page 1
    // Reading page 2
    // Reading page 3
}