Идиоматическая работа с nullable значениями в Kotlin: преобразование и безопасный доступ

Question

js_student40 · 09.05.2026

Идиоматическая работа с nullable значениями в Kotlin: преобразование и безопасный доступ

Привет! Я недавно начал изучать Kotlin после Java и никак не могу привыкнуть к строгой системе nullable типов. У меня есть несколько сценариев, где я путаюсь, как правильно обрабатывать null. Например, у меня есть функция, которая возвращает nullable String? из базы данных. Мне нужно: 1. Проверить, не null ли значение 2. Если не null, преобразовать его в Int (парсинг) 3. Если парсинг не удался или значение null — вернуть 0 Я написал такой код, но он выглядит ужасно: ```kotlin fun parseNullableInt(value: String?): Int { if (value != null) { return try { value.toInt() } catch (e: NumberFormatException) { 0 } } else { return 0 } } ``` Это работает, но наверняка есть более лаконичный и идиоматичный способ. Ещё меня интересует: - Как безопасно вызывать методы на nullable объектах? - Как преобразовывать nullable типы в non-nullable с дефолтным значением? - Что такое оператор Элвиса и когда его использовать? Подскажите, пожалуйста, как в Kotlin принято работать с nullable значениями? Хочется писать чистый код без лишних if-else. <<>>

Идиоматическая работа с nullable в Kotlin

Вы на верном пути! Kotlin предоставляет элегантные инструменты для работы с nullable значениями. Давайте разберём ваш пример и основные приёмы.

1. Оператор Элвиса (?:)

Это базовый инструмент для замены null значением по умолчанию:

val name: String? = getUserName()
val displayName = name ?: "Гость"  // если name == null, то "Гость"

В вашем случае можно упростить проверку на null:

fun parseNullableInt(value: String?): Int {
    return (value ?: "0").toIntOrNull() ?: 0
}

2. Безопасный вызов (?.)

Позволяет вызывать методы на nullable объектах без риска NPE:

val length: Int? = text?.length  // если text == null, то null
val upper: String? = text?.uppercase()

Можно комбинировать с Элвисом:

val lengthOrDefault = text?.length ?: 0

3. toIntOrNull() — ваш лучший друг

Вместо try-catch используйте встроенную функцию:

fun parseNullableInt(value: String?): Int {
    return value?.toIntOrNull() ?: 0
}

Разбор по шагам:

value?.toIntOrNull() — если value не null, пытается парсить; если парсинг не удался — возвращает null
?: 0 — если результат null (из-за исходного null или неудачного парсинга), возвращаем 0

4. let, run, apply — скоуп-функции

Для выполнения действий только при не-null значении:

value?.let { nonNullValue ->
    println("Значение не null: $nonNullValue")
    // работаем с nonNullValue как с non-nullable
}

Пример с преобразованием:

fun processNullable(value: String?): Int {
    return value?.let { 
        it.toIntOrNull() ?: 0 
    } ?: 0
}

5. Полный рефакторинг вашего примера

// Ваш исходный код (6 строк)
fun parseNullableInt(value: String?): Int {
    if (value != null) {
        return try { value.toInt() } catch (e: NumberFormatException) { 0 }
    } else { return 0 }
}

// Идиоматичный вариант (1 строка)
fun parseNullableInt(value: String?): Int = value?.toIntOrNull() ?: 0

6. Дополнительные приёмы

requireNotNull — если null — исключение с сообщением:

val nonNullValue = requireNotNull(value) { "value не должен быть null" }

filterNotNull — для коллекций:

val list: List<String?> = listOf("a", null, "b")
val nonNullList: List<String> = list.filterNotNull()

Правило большого пальца:

Нужно значение по умолчанию — ?:
Нужно выполнить действие только при не-null — ?.let { }
Нужно преобразовать nullable в non-nullable с проверкой — ?: throw или requireNotNull
Нужно безопасно получить свойство — ?.property

7. Проверка на null с умными приведениями

fun printLength(text: String?) {
    if (text != null) {
        // Здесь Kotlin автоматически приводит text к String (non-nullable)
        println(text.length)  // безопасно без ?.
    }
}

Это работает и с when:

when (text) {
    null -> println("null")
    else -> println(text.length)  // умное приведение
}

Используйте эти инструменты, и ваш код станет лаконичным, безопасным и читаемым. Kotlin спроектирован так, чтобы вы писали меньше шаблонного кода для работы с null!

<<>>

Альтернативный подход: использование sealed классов для более сложной логики

Если у вас много сценариев обработки nullable значений, рассмотрите моделирование состояний через sealed классы. Это даёт более строгую типизацию:

sealed class ParseResult<out T> {
    data class Success<T>(val value: T) : ParseResult<T>()
    data class Error(val message: String) : ParseResult<Nothing>()
    object Empty : ParseResult<Nothing>()
}

fun parseNullableInt(value: String?): ParseResult<Int> {
    return when {
        value == null -> ParseResult.Empty
        value.toIntOrNull() != null -> ParseResult.Success(value.toInt())
        else -> ParseResult.Error("Не удалось распарсить '$value'")
    }
}

// Использование
when (val result = parseNullableInt(userInput)) {
    is ParseResult.Success -> println("Число: ${result.value}")
    is ParseResult.Error -> println("Ошибка: ${result.message}")
    is ParseResult.Empty -> println("Ввод отсутствовал")
}

Плюсы этого подхода: