Безопасность от ссылок на null

Типы, допускающие null, и типы, не допускающие null

Система типов Kotlin направлена на устранение опасности ссылок на null, также известной как Ошибка в миллиард долларов.

Одна из наиболее распространенных ошибок во многих языках программирования, включая Java, заключается в том, что обращение к члену ссылки на null приводит к исключению NullPointerException. В Java это эквивалентно NullPointerException, или вкратце NPE.

Единственными возможными причинами возникновения NPE в Kotlin являются:

• Явное обращение к throw NullPointerException().

• Использование оператора !!, описание которого приведено ниже.

• Несоответствие данных в отношении инициализации, например, когда:

  • Неинициализированный this доступный в конструкторе передается и используется где-либо (потерянный this).

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

• Взаимодействие с Java:

  • Попытки доступа к члену ссылки на null типа платформенного типа;

  • Проблемы с допускаемыми null значениями для общих типов, используемых для взаимодействия с Java. Например, фрагмент кода Java может добавить null в Kotlin MutableList<String>, поэтому для работы с ним требуется MutableList<String?>.

  • Другие проблемы, вызванные внешним кодом Java.

В Kotlin система типов различает ссылки, которые могут содержать null (ссылки, допускающие null), и ссылки, которые не могут (ссылки, не допускающие null). Например, обычная переменная типа String не может содержать null:

fun main() {
//sampleStart
    var a: String = "abc" // Regular initialization means non-null by default
    a = null // compilation error
//sampleEnd
}

Чтобы разрешить null, вы можете объявить переменную как строку, допускающую null, записав String?:

fun main() {
//sampleStart
    var b: String? = "abc" // can be set to null
    b = null // ok
    print(b)
//sampleEnd
}

Теперь, если вы вызываете метод или обращаетесь к свойству a, гарантируется, что это не вызовет NPE, поэтому вы можете безопасно сказать:

val l = a.length

Но если вы хотите обратиться к тому же свойству b, это будет небезопасно, и компилятор сообщит об ошибке:

val l = b.length // error: variable 'b' can be null

Но вам все равно нужно обратиться к этому свойству, верно? Существует несколько способов сделать это.

Проверка на null в условиях

Во-первых, вы можете явно проверить, является ли b null, и обработать два варианта отдельно:

val l = if (b != null) b.length else -1

Компилятор отслеживает информацию о выполненной проверке и допускает вызов length внутри if. Также поддерживаются более сложные условия:

fun main() {
//sampleStart
    val b: String? = "Kotlin"
    if (b != null && b.length > 0) {
        print("String of length ${b.length}")
    } else {
        print("Empty string")
    }
//sampleEnd
}

Обратите внимание, что это работает только в том случае, если b неизменяем (то есть это локальная переменная, которая не изменяется между проверкой и ее использованием, или это член val, у которого есть вспомогательное поле и он не переопределяемый), так как в противном случае может произойти изменение b на null после проверки.

Безопасные вызовы

Второй вариант доступа к свойству в переменной, допускающей null, — использование оператора безопасного вызова ?.:

fun main() {
//sampleStart
    val a = "Kotlin"
    val b: String? = null
    println(b?.length)
    println(a?.length) // Unnecessary safe call
//sampleEnd
}

Это возвращает b.length если b не равно null и null в противном случае. Тип этого выражения — Int?.

Безопасные вызовы полезны в цепочках. Например, Bob — сотрудник, которому может быть назначено отделение (или нет). Это отделение, в свою очередь, может иметь другого сотрудника в качестве руководителя отдела. Чтобы получить имя руководителя отдела Bob (если оно есть), напишите следующее:

bob?.department?.head?.name

Такая цепочка возвращает null если любое из свойств в ней равно null.

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

fun main() {
//sampleStart
    val listWithNulls: List<String?> = listOf("Kotlin", null)
    for (item in listWithNulls) {
         item?.let { println(it) } // prints Kotlin and ignores null
    }
//sampleEnd
}

Безопасный вызов также может быть размещен в левой части присваивания. Тогда, если один из получателей в цепочке безопасных вызовов равен null, присваивание пропускается, и выражение справа вообще не вычисляется:

// If either `person` or `person.department` is null, the function is not called:
person?.department?.head = managersPool.getManager()

Оператор Elvis

Когда у вас есть ссылка, допускающая null, b, вы можете сказать «если b не равно null, используйте его, в противном случае используйте какое-то ненулевое значение»:

val l: Int = if (b != null) b.length else -1

Вместо написания полного выражения if, это можно также выразить с помощью оператора Elvis ?::

val l = b?.length ?: -1

Если выражение слева от ?: не равно null, оператор Elvis возвращает его, в противном случае он возвращает выражение справа. Обратите внимание, что выражение справа вычисляется только в том случае, если выражение слева равно null.

Поскольку throw и return являются выражениями в Kotlin, они также могут использоваться в правой части оператора Elvis. Это может быть полезно, например, при проверке аргументов функций:

fun foo(node: Node): String? {
    val parent = node.getParent() ?: return null
    val name = node.getName() ?: throw IllegalArgumentException("name expected")
    // ...
}

Оператор !!

Третий вариант для поклонников NPE: оператор явного указания не null значения (!!) преобразует любое значение в тип, не допускающий null, и выбрасывает исключение, если значение равно null. Вы можете написать b!!, и это вернет ненулевое значение типа b (например, String в нашем примере) или выбросит NPE, если b равно null:

val l = b!!.length

Таким образом, если вы хотите NPE, вы можете его получить, но вы должны об этом явно попросить, и он не появится из ниоткуда.

Безопасные преобразования типов

Обычные преобразования типов могут привести к ClassCastException если объект не относится к целевому типу. Другой вариант — использовать безопасные преобразования типов, которые возвращают null если попытка не удалась:

val aInt: Int? = a as? Int

Коллекции типа, допускающего null

Если у вас есть коллекция элементов типа, допускающего null, и вы хотите отфильтровать ненулевые элементы, вы можете сделать это, используя filterNotNull:

val nullableList: List<Int?> = listOf(1, 2, null, 4)
val intList: List<Int> = nullableList.filterNotNull()