Функции и параметры — бесплатный тест онлайн

Вопрос 1 из 20

Почему пример «Общий тип ветвей» даёт именно такой результат?

// На ревью требуется объяснить причину поведения.
fun parse(flag: Boolean) = if (flag) 1 else "1"

fun main() {
    val value = parse(true)
    println(value::class.simpleName)
}

Объяснение опирается на утверждение: Тип функции выводится как `Comparable<*>`, и обращение к `::class` запрещено. Причину поведения формулируют так: Будет показан `String`, поскольку строковая ветвь расширяет числовую. Семантика фрагмента приводит к тому, что будет показан `Any`, потому что объект меняет свой класс на общий тип функции. При выведении возвращаемого типа компилятор ищет общий тип всех ветвей; слишком широкий результат ослабляет контракт функции. Поведение связывают с правилом: Код не компилируется: ветви `if` обязаны иметь один и тот же точный тип.

Вопрос 2 из 20

Какой дополнительный сценарий нужен для «Порядок именованных аргументов»?

Зафиксировать сценарий, где ожидается: Она напечатает `api.test:8080/true`, потому что Boolean-параметр нельзя задавать по имени. Добавить граничный тест на утверждение: Возникнет ошибка времени выполнения из-за смешивания позиционного и именованных аргументов. При вызове Java-методов имена параметров обычно недоступны как стабильный контракт для именованных аргументов Kotlin. Проверить крайний ввод, при котором она напечатает `api.test:443/false`, поскольку именованный `port` игнорируется после аргумента по умолчанию. Считать опасной границей ситуацию, где код не компилируется, потому что `port` указан после `secure`.

Вопрос 3 из 20

Что может усложниться в сопровождении после изменения «Пропущенный первый параметр»: Давать по умолчанию только безопасные и ожидаемые значения, а обязательные ограничения проверять через `require` внутри функции?

Решение оправдано лишь при условии: Код не компилируется без явного `limit` перед `offset`. Компромисс состоит в утверждении: Будет выведено `(40, 60)`, потому что верхняя граница `until` включается. Параметры по умолчанию уменьшают число перегрузок, но большое их количество превращает функцию в неявный объект конфигурации. Новый риск связан с тем, что будет выведено `(0, 19)`, поскольку нельзя пропустить первый параметр. Обратная сторона изменения состоит в том, что будет выведено `(20, 39)`, потому что `offset` складывается со значением по умолчанию до вызова.

Вопрос 4 из 20

Чем завершится выполнение «Рекурсивная локальная функция»?

// Проследите фактическое выполнение без изменения кода.
fun countPaths(n: Int): Int {
    fun walk(left: Int): Int = when {
        left < 0 -> 0
        left == 0 -> 1
        else -> walk(left - 1) + walk(left - 2)
    }
    return walk(n)
}

fun main() = println(countPaths(4))

Будет выведено `8`, потому что ветвь `left < 0` возвращает единицу. Код не компилируется: локальная функция не может вызывать саму себя. Будет выведено `3`, так как вызовы с одинаковым аргументом объединяются компилятором. Возникнет бесконечная рекурсия, поскольку `left == 0` проверяется после отрицательного значения. Будет выведено `5`: локальная рекурсивная функция считает разложения 4 шагами длины 1 и 2.

Вопрос 5 из 20

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

После правки останется ограничение: Она напечатает `api.test:443/false`, поскольку именованный `port` игнорируется после аргумента по умолчанию. Главная цена решения — необходимость учитывать, что она напечатает `api.test:8080/true`, потому что Boolean-параметр нельзя задавать по имени. Граница полезности решения описывается условием: Возникнет ошибка времени выполнения из-за смешивания позиционного и именованных аргументов. Обратная сторона изменения состоит в том, что код не компилируется, потому что `port` указан после `secure`. Именованные аргументы делают вызов читаемым, но переименование публичного параметра может сломать исходную совместимость потребителей.

Вопрос 6 из 20

Что произойдёт при запуске примера «Пропущенный первый параметр»?

// Проследите фактическое выполнение без изменения кода.
fun page(limit: Int = 20, offset: Int = 0): IntRange =
    offset until (offset + limit)

fun main() = println(page(offset = 40).first to page(offset = 40).last)

Код не компилируется без явного `limit` перед `offset`. Будет выведено `(40, 60)`, потому что верхняя граница `until` включается. Будет выведено `(40, 59)`: `limit` берётся равным 20, а `until` исключает 60. Будет выведено `(20, 39)`, потому что `offset` складывается со значением по умолчанию до вызова. Будет выведено `(0, 19)`, поскольку нельзя пропустить первый параметр.

Вопрос 7 из 20

Какой контракт определяет наблюдаемый результат «Рекурсивная локальная функция»?

// На ревью требуется объяснить причину поведения.
fun countPaths(n: Int): Int {
    fun walk(left: Int): Int = when {
        left < 0 -> 0
        left == 0 -> 1
        else -> walk(left - 1) + walk(left - 2)
    }
    return walk(n)
}

fun main() = println(countPaths(4))

Локальная функция видит параметры и локальные значения внешней функции и может инкапсулировать вспомогательный алгоритм. Ключевым считают контракт: Возникнет бесконечная рекурсия, поскольку `left == 0` проверяется после отрицательного значения. Объяснение опирается на утверждение: Код не компилируется: локальная функция не может вызывать саму себя. Причину поведения формулируют так: Будет выведено `8`, потому что ветвь `left < 0` возвращает единицу. Наблюдаемое поведение выводят из того, что будет выведено `3`, так как вызовы с одинаковым аргументом объединяются компилятором.

Вопрос 8 из 20

Как сделать ответственность во фрагменте «Общий тип ветвей» понятной следующему разработчику?

// Сохраните назначение фрагмента, но укрепите его контракт.
fun parse(flag: Boolean) = if (flag) 1 else "1"

fun main() {
    val value = parse(true)
    println(value::class.simpleName)
}

Спрятать участок за вспомогательной функцией, сохранив предположение: Код не компилируется: ветви `if` обязаны иметь один и тот же точный тип. Перенести проверку в вызывающий код, исходя из того, что тип функции выводится как `Comparable<*>`, и обращение к `::class` запрещено. Ограничиться поясняющим комментарием о том, что будет показан `Any`, потому что объект меняет свой класс на общий тип функции. Уточнить предметную модель: вернуть единый тип, sealed-результат или явное преобразование, а не позволять выводу скрыть неоднородность. Добавить защитную проверку перед фрагментом, поскольку будет показан `String`, поскольку строковая ветвь расширяет числовую.

Вопрос 9 из 20

Почему пример «Пропущенный первый параметр» даёт именно такой результат?

// На ревью требуется объяснить причину поведения.
fun page(limit: Int = 20, offset: Int = 0): IntRange =
    offset until (offset + limit)

fun main() = println(page(offset = 40).first to page(offset = 40).last)

Поведение связывают с правилом: Будет выведено `(40, 60)`, потому что верхняя граница `until` включается. Значение по умолчанию подставляется в точке вызова Kotlin; пропущенный параметр не меняет порядок остальных аргументов. Объяснение опирается на утверждение: Будет выведено `(20, 39)`, потому что `offset` складывается со значением по умолчанию до вызова. Контракт здесь понимают так: Будет выведено `(0, 19)`, поскольку нельзя пропустить первый параметр. Причину поведения формулируют так: Код не компилируется без явного `limit` перед `offset`.

Вопрос 10 из 20

Какую точечную правку стоит принять на ревью фрагмента «Рекурсивная локальная функция»?

// Сохраните назначение фрагмента, но укрепите его контракт.
fun countPaths(n: Int): Int {
    fun walk(left: Int): Int = when {
        left < 0 -> 0
        left == 0 -> 1
        else -> walk(left - 1) + walk(left - 2)
    }
    return walk(n)
}

fun main() = println(countPaths(4))

Оставить структуру прежней, документировав утверждение: Код не компилируется: локальная функция не может вызывать саму себя. Обернуть операцию проверкой и не менять основной контракт: Будет выведено `3`, так как вызовы с одинаковым аргументом объединяются компилятором. Для экспоненциальной рекурсии добавить мемоизацию или перейти к итеративному расчёту, сохранив вспомогательную функцию локальной. Передать ответственность владельцу вызова, предполагая, что возникнет бесконечная рекурсия, поскольку `left == 0` проверяется после отрицательного значения. Оставить реализацию без изменений и закрепить тестом предположение: Будет выведено `8`, потому что ветвь `left < 0` возвращает единицу.

Вопрос 11 из 20

Какой дополнительный сценарий нужен для «Общий тип ветвей»?

Добавить граничный тест на утверждение: Тип функции выводится как `Comparable<*>`, и обращение к `::class` запрещено. Считать опасной границей ситуацию, где будет показан `Any`, потому что объект меняет свой класс на общий тип функции. Проверить крайний ввод, при котором код не компилируется: ветви `if` обязаны иметь один и тот же точный тип. Проверить, сохраняется ли контракт, когда будет показан `String`, поскольку строковая ветвь расширяет числовую. Функция с блочным телом и `return` требует явного возвращаемого типа, кроме функций, возвращающих `Unit`.

Вопрос 12 из 20

Чем завершится выполнение «Порядок именованных аргументов»?

// Проследите фактическое выполнение без изменения кода.
fun connect(host: String, port: Int = 443, secure: Boolean = true) =
    "$host:$port/$secure"

fun main() = println(connect("api.test", secure = false, port = 8080))

Она напечатает `api.test:443/false`, поскольку именованный `port` игнорируется после аргумента по умолчанию. Код не компилируется, потому что `port` указан после `secure`. Возникнет ошибка времени выполнения из-за смешивания позиционного и именованных аргументов. Она напечатает `api.test:8080/false`: именованные аргументы можно передавать не в порядке объявления. Она напечатает `api.test:8080/true`, потому что Boolean-параметр нельзя задавать по имени.

Вопрос 13 из 20

Где поведение «Рекурсивная локальная функция» требует отдельной проверки?

Проверить соседний случай: Будет выведено `3`, так как вызовы с одинаковым аргументом объединяются компилятором. Добавить тест на состояние, при котором код не компилируется: локальная функция не может вызывать саму себя. Проверить границу полезности утверждения: Будет выведено `8`, потому что ветвь `left < 0` возвращает единицу. Отдельно проверить предположение, что возникнет бесконечная рекурсия, поскольку `left == 0` проверяется после отрицательного значения. Захваченная изменяемая переменная создаёт скрытое состояние и может сделать локальную функцию непригодной для параллельного вызова.

Вопрос 14 из 20

Предложенная правка для «Общий тип ветвей» звучит так: Уточнить предметную модель: вернуть единый тип, sealed-результат или явное преобразование, а не позволять выводу скрыть неоднородность. Какой недостаток важнее обсудить?

Граница полезности решения описывается условием: Тип функции выводится как `Comparable<*>`, и обращение к `::class` запрещено. После правки останется ограничение: Код не компилируется: ветви `if` обязаны иметь один и тот же точный тип. Вывод типа экономит запись для простых функций, но публичный явный тип лучше фиксирует намерение и защищает от случайного изменения контракта. Главная цена решения — необходимость учитывать, что будет показан `String`, поскольку строковая ветвь расширяет числовую. Сопровождение усложнится, если окажется, что будет показан `Any`, потому что объект меняет свой класс на общий тип функции.

Вопрос 15 из 20

Какое объяснение результата «Порядок именованных аргументов» выдерживает проверку соседними случаями?

// На ревью требуется объяснить причину поведения.
fun connect(host: String, port: Int = 443, secure: Boolean = true) =
    "$host:$port/$secure"

fun main() = println(connect("api.test", secure = false, port = 8080))

Семантика фрагмента приводит к тому, что возникнет ошибка времени выполнения из-за смешивания позиционного и именованных аргументов. После позиционных аргументов именованные можно располагать в любом порядке, но имена параметров становятся частью удобства исходного API. Такой результат объясняют тем, что код не компилируется, потому что `port` указан после `secure`. Механика примера описывается утверждением: Она напечатает `api.test:443/false`, поскольку именованный `port` игнорируется после аргумента по умолчанию. Причина результата в том, что она напечатает `api.test:8080/true`, потому что Boolean-параметр нельзя задавать по имени.

Вопрос 16 из 20

Как превратить неявное предположение в проверяемый контракт «Пропущенный первый параметр»?

// Сохраните назначение фрагмента, но укрепите его контракт.
fun page(limit: Int = 20, offset: Int = 0): IntRange =
    offset until (offset + limit)

fun main() = println(page(offset = 40).first to page(offset = 40).last)

Давать по умолчанию только безопасные и ожидаемые значения, а обязательные ограничения проверять через `require` внутри функции. Спрятать участок за вспомогательной функцией, сохранив предположение: Будет выведено `(20, 39)`, потому что `offset` складывается со значением по умолчанию до вызова. Добавить локальную обработку результата, потому что будет выведено `(0, 19)`, поскольку нельзя пропустить первый параметр. Ограничиться поясняющим комментарием о том, что код не компилируется без явного `limit` перед `offset`. Зафиксировать текущее поведение регрессионным тестом: Будет выведено `(40, 60)`, потому что верхняя граница `until` включается.

Вопрос 17 из 20

Какой тип будет показан при выполнении?

// Проследите фактическое выполнение без изменения кода.
fun parse(flag: Boolean) = if (flag) 1 else "1"

fun main() {
    val value = parse(true)
    println(value::class.simpleName)
}

Будет показан `Any`, потому что объект меняет свой класс на общий тип функции. Будет показан `String`, поскольку строковая ветвь расширяет числовую. Код не компилируется: ветви `if` обязаны иметь один и тот же точный тип. Тип функции выводится как `Comparable<*>`, и обращение к `::class` запрещено. Будет показан `Int`, но статический возвращаемый тип функции выведен как общий супертип, фактически `Any`.

Вопрос 18 из 20

Как сделать ответственность во фрагменте «Порядок именованных аргументов» понятной следующему разработчику?

// Сохраните назначение фрагмента, но укрепите его контракт.
fun connect(host: String, port: Int = 443, secure: Boolean = true) =
    "$host:$port/$secure"

fun main() = println(connect("api.test", secure = false, port = 8080))

Ограничиться поясняющим комментарием о том, что код не компилируется, потому что `port` указан после `secure`. Для нескольких однотипных параметров использовать имена или объект конфигурации, чтобы вызов не зависел от запоминания позиции. Добавить защитную проверку перед фрагментом, поскольку она напечатает `api.test:8080/true`, потому что Boolean-параметр нельзя задавать по имени. Перенести проверку в вызывающий код, исходя из того, что возникнет ошибка времени выполнения из-за смешивания позиционного и именованных аргументов. Спрятать участок за вспомогательной функцией, сохранив предположение: Она напечатает `api.test:443/false`, поскольку именованный `port` игнорируется после аргумента по умолчанию.

Вопрос 19 из 20

Какой дополнительный сценарий нужен для «Пропущенный первый параметр»?

Проверить, сохраняется ли контракт, когда код не компилируется без явного `limit` перед `offset`. Изменение значения по умолчанию в библиотеке может по-разному проявляться у уже скомпилированных и заново скомпилированных клиентов. Зафиксировать сценарий, где ожидается: Будет выведено `(0, 19)`, поскольку нельзя пропустить первый параметр. Проверить крайний ввод, при котором будет выведено `(40, 60)`, потому что верхняя граница `until` включается. Добавить граничный тест на утверждение: Будет выведено `(20, 39)`, потому что `offset` складывается со значением по умолчанию до вызова.

Вопрос 20 из 20

Предложенная правка для «Рекурсивная локальная функция» звучит так: Для экспоненциальной рекурсии добавить мемоизацию или перейти к итеративному расчёту, сохранив вспомогательную функцию локальной. Какой недостаток важнее обсудить?

После правки останется ограничение: Код не компилируется: локальная функция не может вызывать саму себя. Обратная сторона изменения состоит в том, что будет выведено `8`, потому что ветвь `left < 0` возвращает единицу. Локальная функция удерживает деталь рядом с местом использования, но крупный алгоритм труднее тестировать отдельно. Главная цена решения — необходимость учитывать, что будет выведено `3`, так как вызовы с одинаковым аргументом объединяются компилятором. Граница полезности решения описывается условием: Возникнет бесконечная рекурсия, поскольку `left == 0` проверяется после отрицательного значения.