Типы, переменные и null-безопасность — бесплатный тест онлайн

Вопрос 1 из 20

Как превратить неявное предположение в проверяемый контракт «Ранний возврат и smart cast»?

// Сохраните назначение фрагмента, но укрепите его контракт.
fun normalize(raw: String?): Int {
    val text = raw ?: return -1
    return text.trim().length
}

fun main() = println(normalize("  kt  "))

Ограничиться поясняющим комментарием о том, что функция возвращает `-1`, поскольку оператор Elvis срабатывает и для строки с пробелами. Сохранить API и считать достаточным условие: Код не компилируется: локальная переменная, полученная из `String?`, сохраняет тип `String?`. Спрятать участок за вспомогательной функцией, сохранив предположение: Возникает `NullPointerException` при вычислении длины. Свести проверку отсутствия значения к одной точке — раннему возврату, `requireNotNull` или явному преобразованию в доменный результат. Добавить локальную обработку результата, потому что программа печатает `6`, потому что nullable-проверка отключает `trim()`.

Вопрос 2 из 20

Что проверить отдельно, чтобы не принять «Цепочка безопасных вызовов» за универсальное правило?

Добавить граничный тест на утверждение: Код не компилируется: safe call разрешён только для одной операции. Проверить крайний ввод, при котором будет выведена пустая строка, потому что `?.` подставляет нейтральное значение типа. Проверить, сохраняется ли контракт, когда возникнет `NullPointerException` при вызове `uppercase()`. Отдельно воспроизвести случай, в котором будет выведено `NULL`, поскольку `uppercase()` применяется к текстовому представлению отсутствующего значения. Safe call не различает, на каком звене цепочки возник `null`, поэтому для диагностики иногда нужны отдельные проверки.

Вопрос 3 из 20

Для «Elvis после takeIf» предлагают правку: Подставлять значение по умолчанию только там, где оно не смешивается с реальным пользовательским значением и не маскирует ошибку входа. Какой компромисс нельзя пропустить?

Elvis делает обычный путь компактным, но агрессивные значения по умолчанию способны стереть различие между ошибкой и допустимым отсутствием. После внедрения придётся исходить из того, что обе строки будут `гость`, потому что nullable-тип не smart cast внутри `takeIf`. Цена упрощения проявится, если код не компилируется из-за несовместимости `String?` и `String` в одном выражении. Главная цена решения — необходимость учитывать, что сначала три пробела, затем `Ada`: Elvis проверяет только исходный аргумент. Граница полезности решения описывается условием: Сначала `null`, затем `Ada`: Elvis не работает после `takeIf`.

Вопрос 4 из 20

Какой принцип лежит в основе поведения «Изменение объекта, связанного с val»?

// На ревью требуется объяснить причину поведения.
fun main() {
    val tags = mutableListOf("jvm")
    tags += "android"
    // tags = mutableListOf("native")
    println(tags.joinToString("/"))
}

Из правил языка или API следует, что она напечатает `native`, потому что компилятор выполняет закомментированное присваивание при выводе типов. Такой результат объясняют тем, что она напечатает только `jvm`, поскольку `+=` для `val` игнорируется. Ключевым считают контракт: Код не компилируется, потому что `val` запрещает вызывать изменяющие методы объекта. `val` фиксирует значение переменной после инициализации; глубина неизменяемости объекта определяется его собственным API. Причина результата в том, что возникнет `UnsupportedOperationException`, так как список создан через `mutableListOf`.

Вопрос 5 из 20

В «Цепочка безопасных вызовов» выбрали решение: Если отсутствие города допустимо, завершить цепочку осмысленным Elvis-значением; если нет — вернуть ошибку валидации до отображения. Какова его реальная цена?

После правки останется ограничение: Возникнет `NullPointerException` при вызове `uppercase()`. Сопровождение усложнится, если окажется, что будет выведена пустая строка, потому что `?.` подставляет нейтральное значение типа. Короткая цепочка хорошо выражает необязательные данные, но длинная может скрыть источник отсутствующего значения. Главная цена решения — необходимость учитывать, что код не компилируется: safe call разрешён только для одной операции. Граница полезности решения описывается условием: Будет выведено `NULL`, поскольку `uppercase()` применяется к текстовому представлению отсутствующего значения.

Вопрос 6 из 20

Какие две строки напечатает программа?

// Проследите фактическое выполнение без изменения кода.
fun label(name: String?): String =
    name?.takeIf { it.isNotBlank() } ?: "гость"

fun main() {
    println(label("   "))
    println(label("Ada"))
}

Код не компилируется из-за несовместимости `String?` и `String` в одном выражении. Сначала три пробела, затем `Ada`: Elvis проверяет только исходный аргумент. Сначала `null`, затем `Ada`: Elvis не работает после `takeIf`. Сначала `гость`, затем `Ada`: `takeIf` возвращает `null` для пустой после проверки строки, и срабатывает Elvis. Обе строки будут `гость`, потому что nullable-тип не smart cast внутри `takeIf`.

Вопрос 7 из 20

Что стоит исправить в «Изменение объекта, связанного с val» перед слиянием?

// Сохраните назначение фрагмента, но укрепите его контракт.
fun main() {
    val tags = mutableListOf("jvm")
    tags += "android"
    // tags = mutableListOf("native")
    println(tags.joinToString("/"))
}

Спрятать участок за вспомогательной функцией, сохранив предположение: Она напечатает только `jvm`, поскольку `+=` для `val` игнорируется. Если вызывающему коду не следует менять коллекцию, принимать и возвращать `List<String>`, а изменяемый список держать внутри владельца состояния. Перенести проверку в вызывающий код, исходя из того, что возникнет `UnsupportedOperationException`, так как список создан через `mutableListOf`. Сохранить API и считать достаточным условие: Код не компилируется, потому что `val` запрещает вызывать изменяющие методы объекта. Добавить защитную проверку перед фрагментом, поскольку она напечатает `native`, потому что компилятор выполняет закомментированное присваивание при выводе типов.

Вопрос 8 из 20

Какой соседний случай отличает устойчивое решение «Ранний возврат и smart cast» от удачного примера?

Проверить соседний случай: Код не компилируется: локальная переменная, полученная из `String?`, сохраняет тип `String?`. Smart cast может быть недоступен для изменяемого свойства, которое другой код способен поменять между проверкой и использованием. Считать опасной границей ситуацию, где возникает `NullPointerException` при вычислении длины. Добавить тест на состояние, при котором программа печатает `6`, потому что nullable-проверка отключает `trim()`. Добавить регрессию на гипотезу: Функция возвращает `-1`, поскольку оператор Elvis срабатывает и для строки с пробелами.

Вопрос 9 из 20

Что точнее описывает механику фрагмента «Elvis после takeIf»?

// На ревью требуется объяснить причину поведения.
fun label(name: String?): String =
    name?.takeIf { it.isNotBlank() } ?: "гость"

fun main() {
    println(label("   "))
    println(label("Ada"))
}

Оператор `?:` вычисляет правый операнд лишь тогда, когда левое выражение дало `null`; правый операнд может быть возвратом или исключением. Такой результат объясняют тем, что обе строки будут `гость`, потому что nullable-тип не smart cast внутри `takeIf`. Механика примера описывается утверждением: Код не компилируется из-за несовместимости `String?` и `String` в одном выражении. Ключевым считают контракт: Сначала `null`, затем `Ada`: Elvis не работает после `takeIf`. Здесь действует следующее правило: Сначала три пробела, затем `Ada`: Elvis проверяет только исходный аргумент.

Вопрос 10 из 20

На каком входе или состоянии граница «Изменение объекта, связанного с val» становится заметной?

Ссылка типа `List` ограничивает доступные операции, но объект под ней может оставаться изменяемым и меняться через другую ссылку. Проверить крайний ввод, при котором она напечатает `native`, потому что компилятор выполняет закомментированное присваивание при выводе типов. Считать опасной границей ситуацию, где она напечатает только `jvm`, поскольку `+=` для `val` игнорируется. Зафиксировать сценарий, где ожидается: Возникнет `UnsupportedOperationException`, так как список создан через `mutableListOf`. Добавить регрессию на гипотезу: Код не компилируется, потому что `val` запрещает вызывать изменяющие методы объекта.

Вопрос 11 из 20

Какова практическая цена решения «Ранний возврат и smart cast»: Свести проверку отсутствия значения к одной точке — раннему возврату, `requireNotNull` или явному преобразованию в доменный результат?

После внедрения придётся исходить из того, что программа печатает `6`, потому что nullable-проверка отключает `trim()`. Практическое ограничение подхода: Функция возвращает `-1`, поскольку оператор Elvis срабатывает и для строки с пробелами. Компромисс состоит в утверждении: Возникает `NullPointerException` при вычислении длины. Цена упрощения проявится, если код не компилируется: локальная переменная, полученная из `String?`, сохраняет тип `String?`. Nullable-тип честно отражает отсутствие значения, но заставляет определить семантику этого отсутствия на границе каждого API.

Вопрос 12 из 20

Какое значение напечатает «Цепочка безопасных вызовов»?

// Проследите фактическое выполнение без изменения кода.
data class Profile(val city: String?)
data class User(val profile: Profile?)

fun main() {
    val user = User(Profile(null))
    println(user.profile?.city?.uppercase())
}

Будет выведена пустая строка, потому что `?.` подставляет нейтральное значение типа. Будет выведено `null`: цепочка safe call прекращает вычисление на nullable-значении и возвращает `null` для всей цепочки. Будет выведено `NULL`, поскольку `uppercase()` применяется к текстовому представлению отсутствующего значения. Код не компилируется: safe call разрешён только для одной операции. Возникнет `NullPointerException` при вызове `uppercase()`.

Вопрос 13 из 20

Решение для «Изменение объекта, связанного с val»: Если вызывающему коду не следует менять коллекцию, принимать и возвращать `List<String>`, а изменяемый список держать внутри владельца состояния. Что в нём остаётся не бесплатным?

После правки останется ограничение: Она напечатает `native`, потому что компилятор выполняет закомментированное присваивание при выводе типов. Неизменяемый внешний контракт упрощает рассуждение о состоянии, хотя иногда требует копии или отдельного слоя мутации. Решение оправдано лишь при условии: Код не компилируется, потому что `val` запрещает вызывать изменяющие методы объекта. Главная цена решения — необходимость учитывать, что возникнет `UnsupportedOperationException`, так как список создан через `mutableListOf`. Обратная сторона изменения состоит в том, что она напечатает только `jvm`, поскольку `+=` для `val` игнорируется.

Вопрос 14 из 20

Каков результат вызова `normalize(" kt ")`?

// Проследите фактическое выполнение без изменения кода.
fun normalize(raw: String?): Int {
    val text = raw ?: return -1
    return text.trim().length
}

fun main() = println(normalize("  kt  "))

Возникает `NullPointerException` при вычислении длины. Код не компилируется: локальная переменная, полученная из `String?`, сохраняет тип `String?`. Программа печатает `2`: после раннего возврата компилятор рассматривает `text` как `String`, а `trim()` убирает пробелы. Программа печатает `6`, потому что nullable-проверка отключает `trim()`. Функция возвращает `-1`, поскольку оператор Elvis срабатывает и для строки с пробелами.

Вопрос 15 из 20

Какой контракт снимает спор о причине поведения «Цепочка безопасных вызовов»?

// На ревью требуется объяснить причину поведения.
data class Profile(val city: String?)
data class User(val profile: Profile?)

fun main() {
    val user = User(Profile(null))
    println(user.profile?.city?.uppercase())
}

Механика примера описывается утверждением: Возникнет `NullPointerException` при вызове `uppercase()`. Причина результата в том, что код не компилируется: safe call разрешён только для одной операции. Семантика фрагмента приводит к тому, что будет выведено `NULL`, поскольку `uppercase()` применяется к текстовому представлению отсутствующего значения. Из правил языка или API следует, что будет выведена пустая строка, потому что `?.` подставляет нейтральное значение типа. Оператор `?.` вызывает член только для ненулевого получателя; результат выражения становится nullable независимо от типа члена.

Вопрос 16 из 20

Что изменить в «Elvis после takeIf», чтобы скрытое допущение стало явным контрактом?

// Сохраните назначение фрагмента, но укрепите его контракт.
fun label(name: String?): String =
    name?.takeIf { it.isNotBlank() } ?: "гость"

fun main() {
    println(label("   "))
    println(label("Ada"))
}

Вынести участок в отдельный метод, считая верным следующее: Сначала `null`, затем `Ada`: Elvis не работает после `takeIf`. Оставить реализацию без изменений и закрепить тестом предположение: Сначала три пробела, затем `Ada`: Elvis проверяет только исходный аргумент. Обернуть операцию проверкой и не менять основной контракт: Код не компилируется из-за несовместимости `String?` и `String` в одном выражении. Подставлять значение по умолчанию только там, где оно не смешивается с реальным пользовательским значением и не маскирует ошибку входа. Оставить структуру прежней, документировав утверждение: Обе строки будут `гость`, потому что nullable-тип не smart cast внутри `takeIf`.

Вопрос 17 из 20

Какое объяснение результата «Ранний возврат и smart cast» выдерживает проверку соседними случаями?

// На ревью требуется объяснить причину поведения.
fun normalize(raw: String?): Int {
    val text = raw ?: return -1
    return text.trim().length
}

fun main() = println(normalize("  kt  "))

Такой результат объясняют тем, что программа печатает `6`, потому что nullable-проверка отключает `trim()`. Механика примера описывается утверждением: Код не компилируется: локальная переменная, полученная из `String?`, сохраняет тип `String?`. Тип `T?` допускает `null`; после явной проверки или раннего выхода компилятор может выполнить smart cast к `T`. Семантика фрагмента приводит к тому, что возникает `NullPointerException` при вычислении длины. Причина результата в том, что функция возвращает `-1`, поскольку оператор Elvis срабатывает и для строки с пробелами.

Вопрос 18 из 20

Какая правка устраняет причину риска в «Цепочка безопасных вызовов», а не только его проявление?

// Сохраните назначение фрагмента, но укрепите его контракт.
data class Profile(val city: String?)
data class User(val profile: Profile?)

fun main() {
    val user = User(Profile(null))
    println(user.profile?.city?.uppercase())
}

Если отсутствие города допустимо, завершить цепочку осмысленным Elvis-значением; если нет — вернуть ошибку валидации до отображения. Вынести участок в отдельный метод, считая верным следующее: Будет выведено `NULL`, поскольку `uppercase()` применяется к текстовому представлению отсутствующего значения. Добавить защитную проверку перед фрагментом, поскольку возникнет `NullPointerException` при вызове `uppercase()`. Спрятать участок за вспомогательной функцией, сохранив предположение: Будет выведена пустая строка, потому что `?.` подставляет нейтральное значение типа. Оставить реализацию без изменений и закрепить тестом предположение: Код не компилируется: safe call разрешён только для одной операции.

Вопрос 19 из 20

Какой сценарий выявит скрытое ограничение «Elvis после takeIf»?

Пустая строка, ноль и `false` не считаются отсутствием: для них нужна отдельная предметная проверка до Elvis. Отдельно проверить предположение, что код не компилируется из-за несовместимости `String?` и `String` в одном выражении. Воспроизвести редкий сценарий, где сначала три пробела, затем `Ada`: Elvis проверяет только исходный аргумент. Проверить границу полезности утверждения: Сначала `null`, затем `Ada`: Elvis не работает после `takeIf`. Добавить тест на состояние, при котором обе строки будут `гость`, потому что nullable-тип не smart cast внутри `takeIf`.

Вопрос 20 из 20

Что напечатает программа, если закомментированная строка остаётся выключенной?

// Проследите фактическое выполнение без изменения кода.
fun main() {
    val tags = mutableListOf("jvm")
    tags += "android"
    // tags = mutableListOf("native")
    println(tags.joinToString("/"))
}

Она напечатает `native`, потому что компилятор выполняет закомментированное присваивание при выводе типов. Она напечатает только `jvm`, поскольку `+=` для `val` игнорируется. Код не компилируется, потому что `val` запрещает вызывать изменяющие методы объекта. Она напечатает `jvm/android`: `val` запрещает переназначить ссылку, но не делает сам `MutableList` неизменяемым. Возникнет `UnsupportedOperationException`, так как список создан через `mutableListOf`.