Какие плюсы и минусы null safety?

Какие плюсы и минусы null safety?

Null safety — это система типов в Kotlin, которая различает nullable и non-nullable типы на уровне компилятора. Это один из главных плюсов Kotlin, но как у любого подхода, у него есть как преимущества, так и недостатки.

Плюсы null safety

1. Предотвращение NullPointerException

Это главное преимущество. Kotlin не позволит присвоить null обычной переменной:

var name: String = "Alice"  // non-nullable
name = null  // ОШИБКА КОМПИЛЯЦИИ!

var nickname: String? = null  // nullable, OK

Вместо runtime краша приложения ошибка обнаруживается на этапе компиляции.

2. Ясность намерения

Тип String? явно говорит, что переменная может быть null:

fun getUserName(user: User?): String {
    // Сразу видно, что user может быть null
    // Нужно обработать этот случай
    return user?.name ?: "Unknown"
}

Это делает код более понятным и самодокументирующимся.

3. Меньше проверок

Для non-nullable типов не нужны постоянные проверки на null:

// Kotlin
fun process(name: String) {
    println(name.length)  // Безопасно, null исключён типом
}

// Java
public void process(String name) {
    if (name == null) throw new NullPointerException();
    System.out.println(name.length());
}

4. Безопасные операторы

Котлин предоставляет удобные операторы для работы с nullable типами:

val user: User? = getUser()

// Safe call operator
val age = user?.age  // null, если user null

// Elvis operator
val name = user?.name ?: "Unknown"  // default значение

// Not-null assertion
val id = user!!.id  // crash, если null

// Safe cast
val admin = user as? Admin  // null, если неверный тип

5. Упрощение рефакторинга

При изменении типа с nullable на non-nullable (или наоборот) компилятор укажет все места, где нужны изменения:

// Было
fun getUserName(user: User?): String? = user?.name

// Меняем на non-nullable
fun getUserName(user: User): String = user.name

// Компилятор найдёт все места, где нужно обновить код

6. Производительность

Нет необходимости проверять каждое обращение к объекту:

// Kotlin компилирует это без проверок null
val length = name.length

// Java может требовать проверок
if (name != null) {
    int length = name.length();
}

Минусы null safety

1. Изучение кривой

Новичкам нужно привыкнуть к различию между String и String?:

// Начинающие часто пишут неправильно
val user: User? = getUser()
val name = user.name  // ОШИБКА: может быть null

// Нужно исправить
val name = user?.name  // Правильно

2. Многословность при работе с nullable

Когда много nullable параметров, код становится многословным:

fun createUser(
    firstName: String?,
    lastName: String?,
    email: String?
): User? {
    return if (firstName != null && lastName != null && email != null) {
        User(firstName, lastName, email)
    } else {
        null
    }
}

// Много проверок и условий

Это сложнее, чем в языках без null safety.

**3. Несовместимость с Java

Когда Kotlin вызывает Java код, он теряет информацию о null safety:

// Java код
public String getName(User user) {
    return user.name;  // Может быть null
}

// Kotlin видит это как String! (platform type)
val name = javaObject.getName(user)  // String или String??

Это создаёт потенциальные баги на границе Java-Kotlin.

4. Not-null assertion (!!) — двойной меч

Оператор !! позволяет обойти type safety:

val user: User? = getUser()
val id = user!!.id  // Если user null, crash!

// Это возвращает нас к проблемам Java

Программисты иногда используют !! избыточно, теряя безопасность.

5. Сложность с generics

Nullable типы усложняют работу с generic типами:

fun <T> processItem(item: T?) {  // Что это означает?
    // T может быть User? или сам nullable?
}

// Нужно быть явным
fun <T : Any> processItem(item: T?) {  // T non-nullable
fun <T> processItem(item: T) {  // T может быть любой, включая nullable

6. Производительность null checks

Для очень критичных по производительности участков кода даже проверки null могут быть косвенной нагрузкой:

// Kotlin всё равно должна помнить о возможности null
val items: List<String>? = getItems()
for (item in items ?: emptyList()) {  // Дополнительная работа
    println(item)
}

7. Boilerplate код

Для обработки множественных nullable значений требуется много кода:

val result = optionalA?.let { a ->
    optionalB?.let { b ->
        optionalC?.let { c ->
            combine(a, b, c)
        }
    }
}  // Пирамида doom!

// Лучший вариант
val result = combine(
    optionalA ?: return null,
    optionalB ?: return null,
    optionalC ?: return null
)

Сравнение с другими подходами

Best practices

1. Минимизируй nullable типы

// Плохо
fun getUserName(user: User?): String? = user?.name

// Хорошо: требуй non-null параметр
fun getUserName(user: User): String = user.name

2. Используй scope функции

val user: User? = getUser()

user?.let { u ->
    println(u.name)
    updateUI(u)
}

3. Избегай !! кроме очевидных случаев

// OK: явно знаем, что это не null
val items = arrayListOf<String>()
val first = items[0]!!  // Явная ошибка разработчика

// Плохо: скрытая ошибка
val user: User? = getUser()
val id = user!!.id  // Может упасть

Заключение

Null safety в Kotlin — это огромный шаг вперёд в безопасности разработки. Он предотвращает целый класс ошибок, которые плагуют Java разработчиков. Однако это требует дополнительного мышления и может привести к многословности в некоторых случаях. При правильном использовании null safety значительно улучшает качество кода и уменьшает баги.