GO Go · 20 вопросов · ~55 мин · ⏱ Таймер 55:00 · Лёгкий ·

Карты и строки

Проверяет чтение и изменение `map`, двухзначное извлечение, неизменяемые строки, руны и реальные последствия UTF-8. В тесте 20 вопросов, из них 12 требуют чтения кода, команд или диагностических фрагментов. Задания опираются на устойчивые правила современного Go; если поведение зависит от версии, это оговорено в самом вопросе.

Отвечено: 0 из 20

⏱ --:--

💡 Инструкция: Выберите один ответ из пяти. На 20 вопросов отведено 55 минут. В каждом вопросе верен только один вариант. После завершения вы увидите общий результат и результаты по 4 тематическим шкалам с объяснениями и практическими рекомендациями.

Вопрос 1 из 20

Фрагмент относится к теме «Карты map». Какой итог можно предсказать без пробного запуска?

// Фрагмент для трассировки.
package main
func main() {
    var m map[string]int
    _ = m["x"]
    // m["x"] = 1
}

Чтение `m["x"]` из `nil`-карты даёт `0`, но попытка `m["x"] = 1` завершится паникой. Код сначала обрабатывает `n` байтов, а затем завершает цикл по `io.EOF`, не теряя последний фрагмент. Попытка сериализовать поле-функцию завершается `json: unsupported type`, а не молча пропускает его. `io.TeeReader` отдаёт данные вызывающему коду и одновременно записывает прочитанные байты в другой `Writer`. Чтение `<-ch` получит `7` только после готовой отправки, а небуферизованный канал создаёт точку встречи.

Вопрос 2 из 20

На ревью разбирают тему «Карты map». Как изменить решение, не ломая его исходную задачу?

// Фрагмент из ревью: требуется выбрать безопасную правку.
package main
func main() {
    var m map[string]int
    _ = m["x"]
    // m["x"] = 1
}

Всегда обрабатывать данные до ошибки и использовать `io.ReadAll`, `io.Copy` или буфер там, где они точнее выражают задачу. Комбинировать стандартные обёртки и закрывать ресурсы в порядке, соответствующем их контрактам. Проверять ошибку записи и использовать `io.Copy` для полного переноса потока с корректной обработкой коротких записей. Не оставлять канал `nil` случайно; намеренно использовать `nil` только для отключения ветви `select`. Создавать карту через `make` или литерал до первой записи; чтение из `nil` допустимо, если такой контракт осознан.

Вопрос 3 из 20

В разделе «Карты map» показан конкретный случай. Какое утверждение остаётся верным на всех поддерживаемых платформах?

// Определите правило Go, которое объясняет результат.
package main
func main() {
    var m map[string]int
    _ = m["x"]
    // m["x"] = 1
}

`json.Marshal` возвращает байты и ошибку; неподдерживаемые значения вроде функций и каналов приводят к ошибке. Чтение отсутствующего ключа возвращает нулевое значение элемента; запись в `nil`-карту вызывает панику. `Read(p)` возвращает число прочитанных байтов и ошибку; допустимо получить `n>0` вместе с `io.EOF`. Добавление необязательного поля обычно совместимо со старым JSON, а переименование или изменение смысла существующего поля требует миграции. Отправка и чтение синхронизируются согласно состоянию канала; операция с `nil`-каналом блокируется навсегда.

Вопрос 4 из 20

Команда проверяет решение по теме «Карты map». Какое условие нельзя считать выполненным по умолчанию?

Один успешный `Decode` не гарантирует отсутствие лишнего второго JSON-значения после ожидаемого объекта. `NaN` и бесконечности `float64` не являются допустимыми числами JSON и вызывают ошибку кодирования. Отправка в закрытый канал вызывает панику, а чтение из закрытого и опустошённого канала возвращает ноль и `ok=false`. Порядок обхода карты не определён и не должен использоваться как часть результата. Опция `omitempty` не всегда различает отсутствующее поле и переданное нулевое значение.

Вопрос 5 из 20

Перед публикацией кода по теме «Карты map» нужно уточнить контракт. Какой вариант честно называет и преимущество, и издержку?

Небуферизованный канал задаёт сильную координацию, но может ограничить пропускную способность и усилить взаимные ожидания. Потоковый интерфейс экономит память, но требует аккуратного цикла и границ объёма для недоверенного входа. Стандартный кодировщик надёжен для общего случая, но высоконагруженный путь нужно оптимизировать только после профиля. Карта даёт быстрый доступ по ключу, но для стабильного порядка ключи приходится собирать и сортировать отдельно. Теги удобны для простого контракта, но смешивание нескольких форматов в одной структуре делает модель хрупкой.

Вопрос 6 из 20

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

// Фрагмент для трассировки.
package main
func main() {
    m := map[string]int{"x":0}
    vx, okx := m["x"]
    vy, oky := m["y"]
    _, _, _, _ = vx, okx, vy, oky
}

GET можно повторить после временной сетевой ошибки, а POST без ключа идемпотентности может создать дубль. Для `"aя"` индексы будут `0` и `1`, а следующая позиция после второй руны — 3 байта. Функция `Has` принимает ключ любого сравнимого типа, согласованного с ключами карты. Для карты `{"x":0}` чтение ключа `x` вернёт `0, true`, а ключа `y` — `0, false`. Для `s := a[1:3]` при массиве длины 4 значения равны `len(s)==2` и `cap(s)==3`.

Вопрос 7 из 20

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

// Фрагмент из ревью: требуется выбрать безопасную правку.
package main
func main() {
    m := map[string]int{"x":0}
    vx, okx := m["x"]
    vy, oky := m["y"]
    _, _, _, _ = vx, okx, vy, oky
}

Использовать полное выражение среза `a[low:high:max]`, когда нужно ограничить ёмкость и предотвратить запись через `append` в соседние данные. Использовать индекс из `range` как байтовое смещение, а не как порядковый номер символа. Хранить примеры компилируемыми, тестировать нулевое значение и конкурентный контракт, если они обещаны. Использовать собственный неэкспортируемый тип ключа и небольшие неизменяемые значения. Использовать форму с `ok`, если ноль является допустимым сохранённым значением.

Вопрос 8 из 20

Команда проверяет решение по теме «Проверка наличия». Какое правило достаточно применить для проверки ответа?

// Определите правило Go, которое объясняет результат.
package main
func main() {
    m := map[string]int{"x":0}
    vx, okx := m["x"]
    vy, oky := m["y"]
    _, _, _, _ = vx, okx, vy, oky
}

Двухзначное чтение `v, ok := m[k]` отличает отсутствующий ключ от присутствующего ключа с нулевым значением. `range` по строке выдаёт байтовый индекс начала руны и саму руну; индекс может увеличиваться больше чем на единицу. Неинициализированная переменная получает нулевое значение своего типа; это не означает, что такое значение подходит предметной области. Каждый middleware тестируют отдельно и в реальном порядке цепочки, включая отсутствие вызова `next`. `len` — доступная длина среза, `cap` — сколько элементов можно охватить от начала среза до конца базового массива.

Вопрос 9 из 20

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

Некорректная последовательность UTF-8 при `range` заменяется руной `utf8.RuneError` с продвижением по правилам декодирования. Простая обёртка может потерять дополнительные интерфейсы `Flusher`, `Hijacker` или `Pusher`, необходимые некоторым обработчикам. Срез с нулевой длиной может иметь ненулевую ёмкость и быть не равен `nil`. Преобразование целого к меньшему типу отбрасывает старшие биты и не сообщает о переполнении. После удаления ключа `delete` не сообщает, существовал ли ключ; при необходимости это проверяют до удаления.

Вопрос 10 из 20

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

Общий выход упрощает потребителя, но теряет происхождение элемента, если его не добавить в данные. Однозначный sentinel упрощает код лишь тогда, когда предметная область действительно запрещает такое значение. `range` надёжен для декодирования рун, но для строгой проверки входа сначала полезно вызвать `utf8.ValidString`. `defer` упрощает освобождение, но в большом цикле отдельная вспомогательная функция часто задаёт более короткое время жизни. Резерв ёмкости уменьшает аллокации, но чрезмерный запас удерживает память и может скрывать совместное владение массивом.

Вопрос 11 из 20

В разделе «Строки и руны» показан конкретный случай. Что именно произойдёт при выполнении показанного фрагмента?

// Фрагмент для трассировки.
package main
import "unicode/utf8"
func main() {
    s := "я"
    _, _ = len(s), utf8.RuneCountInString(s)
}

Для строки `"я"` значение `len(s)` равно 2 в UTF-8, а `utf8.RuneCountInString(s)` равно 1. `io.WriteString` передаёт строку писателю и возвращает фактически записанное число байтов и ошибку. При входе из двух байтов и буфере длины 3 `ReadFull` вернёт `n=2` и `io.ErrUnexpectedEOF`. Старый потребитель проигнорирует новое поле при обычном декодировании, если не включён строгий запрет неизвестных полей. Чтение `<-ch` получит `7` только после готовой отправки, а небуферизованный канал создаёт точку встречи.

Вопрос 12 из 20

Команда проверяет решение по теме «Строки и руны». Как исправить основной риск без ненужной перестройки решения?

// Фрагмент из ревью: требуется выбрать безопасную правку.
package main
import "unicode/utf8"
func main() {
    s := "я"
    _, _ = len(s), utf8.RuneCountInString(s)
}

Всегда обрабатывать данные до ошибки и использовать `io.ReadAll`, `io.Copy` или буфер там, где они точнее выражают задачу. Выбирать `ReadFull` для заголовков фиксированной длины и обычный цикл для произвольного потока. Проверять ошибку записи и использовать `io.Copy` для полного переноса потока с корректной обработкой коротких записей. Выбирать байтовую обработку для протоколов и `[]rune` или пакет `utf8` для операций над кодовыми точками. Не оставлять канал `nil` случайно; намеренно использовать `nil` только для отключения ветви `select`.

Вопрос 13 из 20

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

// Определите правило Go, которое объясняет результат.
package main
import "unicode/utf8"
func main() {
    s := "я"
    _, _ = len(s), utf8.RuneCountInString(s)
}

`Write(p)` сообщает число принятых байтов; `n < len(p)` без ошибки нарушает обычный контракт и трактуется как `io.ErrShortWrite` помощниками. Для фиксированного блока `io.ReadFull` читает ровно нужное число байтов либо возвращает `ErrUnexpectedEOF`/`EOF`. `json.Marshal` возвращает байты и ошибку; неподдерживаемые значения вроде функций и каналов приводят к ошибке. `Read(p)` возвращает число прочитанных байтов и ошибку; допустимо получить `n>0` вместе с `io.EOF`. Строка — неизменяемая последовательность байтов; `len` возвращает число байтов, а не символов Unicode.

Вопрос 14 из 20

В рабочем примере по теме «Строки и руны» важно отделить гарантию от догадки. Какой контрпример разрушит слишком широкое толкование правила?

Опция `omitempty` не всегда различает отсутствующее поле и переданное нулевое значение. Даже при ошибке возвращённые `n` байтов могут быть полезны для диагностики, но недостаточны для полного сообщения. `NaN` и бесконечности `float64` не являются допустимыми числами JSON и вызывают ошибку кодирования. `Read` может вернуть меньше `len(p)` без ошибки, поэтому одно чтение не обязано заполнить буфер. Одна видимая графема может состоять из нескольких рун, поэтому даже число рун не всегда равно числу пользовательских символов.

Вопрос 15 из 20

Фрагмент относится к теме «Строки и руны». Что важно учесть помимо формальной корректности?

Жёсткое чтение упрощает двоичный протокол, но требует ограничения размера до выделения памяти. Небуферизованный канал задаёт сильную координацию, но может ограничить пропускную способность и усилить взаимные ожидания. Потоковый интерфейс экономит память, но требует аккуратного цикла и границ объёма для недоверенного входа. Потоковый декодер снижает пиковую память, но строгая проверка окончания и схемы требует дополнительных шагов. Преобразование в `[]rune` упрощает индексацию кодовых точек, но выделяет память и не решает задачу графем полностью.

Вопрос 16 из 20

Команда проверяет решение по теме «Итерация UTF-8». Какое описание результата совпадает с правилами Go?

// Фрагмент для трассировки.
package main
import "fmt"
func main() {
    for i, r := range "aя" { fmt.Println(i, r) }
}

Для карты `{"x":0}` чтение ключа `x` вернёт `0, true`, а ключа `y` — `0, false`. Для `s := a[1:3]` при массиве длины 4 значения равны `len(s)==2` и `cap(s)==3`. Код сначала обрабатывает `n` байтов, а затем завершает цикл по `io.EOF`, не теряя последний фрагмент. Тест ожидает `Rollback`, если второй запрос транзакции завершился ошибкой. Для `"aя"` индексы будут `0` и `1`, а следующая позиция после второй руны — 3 байта.

Вопрос 17 из 20

Перед публикацией кода по теме «Итерация UTF-8» нужно уточнить контракт. Какая правка устраняет причину, а не маскирует её проявление?

// Фрагмент из ревью: требуется выбрать безопасную правку.
package main
import "fmt"
func main() {
    for i, r := range "aя" { fmt.Println(i, r) }
}

Использовать форму с `ok`, если ноль является допустимым сохранённым значением. Использовать полное выражение среза `a[low:high:max]`, когда нужно ограничить ёмкость и предотвратить запись через `append` в соседние данные. Не использовать порядок `case` как приоритет; строить приоритет явной двухступенчатой логикой, если он действительно нужен. Использовать индекс из `range` как байтовое смещение, а не как порядковый номер символа. Использовать `iotest` и собственные маленькие заглушки, измерять число байтов и длительность без записи содержимого секретных потоков.

Вопрос 18 из 20

В рабочем примере по теме «Итерация UTF-8» важно отделить гарантию от догадки. Что именно гарантирует Go в этой ситуации?

// Определите правило Go, которое объясняет результат.
package main
import "fmt"
func main() {
    for i, r := range "aя" { fmt.Println(i, r) }
}

Все обычные `.go`-файлы одного каталога должны объявлять один пакет; пакет задаёт единицу компиляции и повторного использования. `sync.Mutex` защищает инвариант общего состояния; копировать мьютекс после начала использования нельзя. Двухзначное чтение `v, ok := m[k]` отличает отсутствующий ключ от присутствующего ключа с нулевым значением. `range` по строке выдаёт байтовый индекс начала руны и саму руну; индекс может увеличиваться больше чем на единицу. `len` — доступная длина среза, `cap` — сколько элементов можно охватить от начала среза до конца базового массива.

Вопрос 19 из 20

Фрагмент относится к теме «Итерация UTF-8». Что нельзя автоматически переносить на похожий код?

Некорректная последовательность UTF-8 при `range` заменяется руной `utf8.RuneError` с продвижением по правилам декодирования. `NaN` и бесконечности `float64` не являются допустимыми числами JSON и вызывают ошибку кодирования. Мьютекс, удерживаемый вокруг `next`, последовательно обработает весь сервер и может привести к взаимной блокировке. После удаления ключа `delete` не сообщает, существовал ли ключ; при необходимости это проверяют до удаления. Срез с нулевой длиной может иметь ненулевую ёмкость и быть не равен `nil`.

Вопрос 20 из 20

На ревью разбирают тему «Итерация UTF-8». Как оценить этот подход для производственного кода?

Резерв ёмкости уменьшает аллокации, но чрезмерный запас удерживает память и может скрывать совместное владение массивом. Разделение причин полезно для эксплуатации, но чрезмерная детализация меток способна раздуть кардинальность метрик. Детерминированный тест полезнее случайной нагрузки, а стресс остаётся дополнением для неизвестных чередований. `range` надёжен для декодирования рун, но для строгой проверки входа сначала полезно вызвать `utf8.ValidString`. Однозначный sentinel упрощает код лишь тогда, когда предметная область действительно запрещает такое значение.

Ответьте на все 20 вопросов, чтобы получить результат

🔗 Встроить тест на свой сайт (iframe) ▼

Скопируйте код и вставьте в любое место на вашем сайте:

Также доступна прямая ссылка на embed-страницу