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

Массивы и срезы

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

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

⏱ --:--

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

Вопрос 1 из 20

На ревью разбирают тему «Массивы». Что гарантированно произойдёт в показанной последовательности операций?

// Фрагмент для трассировки.
package main
import "fmt"
func main() {
    a := [2]int{1,2}
    b := a
    b[0] = 9
    fmt.Println(a, b)
}

`Admin` получает продвинутый метод `Name`, однако значение `Admin` нельзя передать туда, где требуется конкретный `User`. После `*p = 8` исходная переменная `n` равна 8. `makeInt` возвращает корректный указатель; значение не исчезает после выхода из функции. `p := &n` создаёт указатель на `n`, и сравнение `p == &n` истинно в рамках этого значения. После `b := a` изменение `b[0]` не меняет `a[0]`, потому что массив скопирован как значение.

Вопрос 2 из 20

В разделе «Массивы» показан конкретный случай. Какой вариант исправления соответствует обычной практике Go?

// Фрагмент из ревью: требуется выбрать безопасную правку.
package main
import "fmt"
func main() {
    a := [2]int{1,2}
    b := a
    b[0] = 9
    fmt.Println(a, b)
}

Проверять возможность `nil` на границе и не разносить необязательный указатель глубже без необходимости. Передавать большой массив указателем либо срезом, если полная копия не является частью замысла. Делать глубокую копию ссылочных полей, если копия структуры должна владеть независимым состоянием. Использовать значимый получатель для небольших неизменяемых значений и указательный — когда метод меняет состояние или копирование дорого. Передавать адрес только когда требуется общая мутация, идентичность или избегание значимой копии.

Вопрос 3 из 20

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

// Определите правило Go, которое объясняет результат.
package main
import "fmt"
func main() {
    a := [2]int{1,2}
    b := a
    b[0] = 9
    fmt.Println(a, b)
}

Длина входит в тип массива; `[3]int` и `[4]int` — разные типы, а присваивание массива копирует все элементы. Оператор `*p` читает или изменяет значение по адресу; разыменование `nil` вызывает панику. Передача `*T` позволяет функции менять исходное значение, потому что копируется сам адрес, указывающий на тот же объект. Встраивание продвигает поля и методы, но не превращает внешний тип в подтип встроенного. Структура копируется как значение, но ссылочные поля внутри копии могут продолжать указывать на общие данные.

Вопрос 4 из 20

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

Escape analysis может изменить размещение после небольшой правки или обновления компилятора. Сравнение массивов допустимо только тогда, когда тип их элементов сравним. Нельзя взять адрес элемента карты, потому что элементы карты не являются адресуемыми значениями. Даже значимый получатель может менять объект через ссылочное поле, например элемент общего среза. Переназначение локального параметра-указателя не меняет указатель у вызывающего кода.

Вопрос 5 из 20

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

Мутация через указатель удобна для состояния, но чистая функция проще для параллельного использования и тестов. Значимые методы поддерживают семантику значения, но крупные структуры могут копироваться дороже и случайно разделять внутренние ссылки. Массив фиксирует размер в типе и полезен для точных структур, но срез гибче на границах API. Явное разыменование показывает мутацию, но API с множеством указателей часто сигнализирует о неясном владении. Структуры удобны как значения, но наличие карт, срезов и указателей требует отдельно определить семантику копирования.

Вопрос 6 из 20

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

// Фрагмент для трассировки.
package main
func main() {
    a := [4]int{0,1,2,3}
    s := a[1:3]
    _, _ = len(s), cap(s)
}

Для строки `"я"` значение `len(s)` равно 2 в UTF-8, а `utf8.RuneCountInString(s)` равно 1. При входе из двух байтов и буфере длины 3 `ReadFull` вернёт `n=2` и `io.ErrUnexpectedEOF`. Для карты `{"x":0}` чтение ключа `x` вернёт `0, true`, а ключа `y` — `0, false`. Для `"aя"` индексы будут `0` и `1`, а следующая позиция после второй руны — 3 байта. Для `s := a[1:3]` при массиве длины 4 значения равны `len(s)==2` и `cap(s)==3`.

Вопрос 7 из 20

Команда проверяет решение по теме «len и cap». Какую правку разумнее внести до объединения изменений?

// Фрагмент из ревью: требуется выбрать безопасную правку.
package main
func main() {
    a := [4]int{0,1,2,3}
    s := a[1:3]
    _, _ = len(s), cap(s)
}

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

Вопрос 8 из 20

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

// Определите правило Go, которое объясняет результат.
package main
func main() {
    a := [4]int{0,1,2,3}
    s := a[1:3]
    _, _ = len(s), cap(s)
}

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

Вопрос 9 из 20

В рабочем примере по теме «len и cap» важно отделить гарантию от догадки. Где заканчивается гарантия показанного приёма?

Опция `omitempty` не всегда различает отсутствующее поле и переданное нулевое значение. Срез с нулевой длиной может иметь ненулевую ёмкость и быть не равен `nil`. После удаления ключа `delete` не сообщает, существовал ли ключ; при необходимости это проверяют до удаления. Закрытый канал всегда готов к чтению; если не отключить его после `ok=false`, `select` может крутиться на нулевых значениях. Некорректная последовательность UTF-8 при `range` заменяется руной `utf8.RuneError` с продвижением по правилам декодирования.

Вопрос 10 из 20

Фрагмент относится к теме «len и cap». Когда этот приём помогает, а когда начинает мешать?

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

Вопрос 11 из 20

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

// Фрагмент для трассировки.
package main
func main() {
    s := make([]int, 0, 2)
    s = append(s, 1)
    s = append(s, 2)
    s = append(s, 3)
    _ = s
}

После первого `append` с достаточной ёмкостью новый элемент записывается в тот же массив; после исчерпания ёмкости возможен новый массив. `makeInt` возвращает корректный указатель; значение не исчезает после выхода из функции. Вызов `p.Move()` корректен для переменной `p`: компилятор использует `(&p).Move()`, и `X` станет 1. После `b := a` поле-срез в обеих структурах указывает на один массив, поэтому изменение элемента видно через обе копии. После `*p = 8` исходная переменная `n` равна 8.

Вопрос 12 из 20

Перед публикацией кода по теме «Рост среза через append» нужно уточнить контракт. Какое изменение лучше всего укрепит контракт этого фрагмента?

// Фрагмент из ревью: требуется выбрать безопасную правку.
package main
func main() {
    s := make([]int, 0, 2)
    s = append(s, 1)
    s = append(s, 2)
    s = append(s, 3)
    _ = s
}

Использовать встраивание для композиции поведения, а не для имитации наследования и неявной подстановки типов. Передавать адрес только когда требуется общая мутация, идентичность или избегание значимой копии. Ориентироваться на семантику владения, а не вручную угадывать стек или кучу; измерять аллокации при реальной необходимости. Использовать значимый получатель для небольших неизменяемых значений и указательный — когда метод меняет состояние или копирование дорого. Всегда присваивать результат `append` обратно нужной переменной и не полагаться на сохранение адреса элементов.

Вопрос 13 из 20

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

// Определите правило Go, которое объясняет результат.
package main
func main() {
    s := make([]int, 0, 2)
    s = append(s, 1)
    s = append(s, 2)
    s = append(s, 3)
    _ = s
}

Метод с получателем `*T` может менять исходное значение; компилятор часто автоматически берёт адрес адресуемой переменной. Встраивание продвигает поля и методы, но не превращает внешний тип в подтип встроенного. `append` может использовать прежний базовый массив либо выделить новый; это зависит от ёмкости. Структура копируется как значение, но ссылочные поля внутри копии могут продолжать указывать на общие данные. Компилятор может разместить локальное значение в куче, если указатель на него переживает вызов; возвращать такой указатель безопасно.

Вопрос 14 из 20

Фрагмент относится к теме «Рост среза через append». Что может изменить вывод при небольшом изменении условий?

Конфликтующие продвинутые имена требуют явного указания пути и не выбираются произвольно. Указатель на элемент среза может стать указателем на старый массив после перераспределения при `append`. Нельзя автоматически взять адрес результата функции или другого неадресуемого значения для вызова указательного метода. Нельзя взять адрес элемента карты, потому что элементы карты не являются адресуемыми значениями. Escape analysis может изменить размещение после небольшой правки или обновления компилятора.

Вопрос 15 из 20

На ревью разбирают тему «Рост среза через append». Как решение влияет на читаемость и надёжность?

Значимые методы поддерживают семантику значения, но крупные структуры могут копироваться дороже и случайно разделять внутренние ссылки. Указательный получатель позволяет мутацию и избегает копии, но делает совместное состояние частью контракта. Предварительный `make` с разумной ёмкостью ускоряет рост, но точная оценка не должна превращаться в удержание огромного массива. Встраивание сокращает делегирование, но слишком глубокая композиция скрывает происхождение методов. Явное разыменование показывает мутацию, но API с множеством указателей часто сигнализирует о неясном владении.

Вопрос 16 из 20

Перед публикацией кода по теме «Общий backing array» нужно уточнить контракт. Что увидит вызывающий код после выполнения?

// Фрагмент для трассировки.
package main
import "fmt"
func main() {
    a := []int{1,2,3}
    left := a[:2]
    right := a[1:]
    left[1] = 8
    fmt.Println(right)
}

После `b := a` поле-срез в обеих структурах указывает на один массив, поэтому изменение элемента видно через обе копии. Вызов `p.Move()` не меняет `p.X`, потому что получатель `Point` скопирован. Вызов `p.Move()` корректен для переменной `p`: компилятор использует `(&p).Move()`, и `X` станет 1. `p := &n` создаёт указатель на `n`, и сравнение `p == &n` истинно в рамках этого значения. Изменение `left[1]` меняет `right[0]`, потому что оба элемента соответствуют одной ячейке базового массива.

Вопрос 17 из 20

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

// Фрагмент из ревью: требуется выбрать безопасную правку.
package main
import "fmt"
func main() {
    a := []int{1,2,3}
    left := a[:2]
    right := a[1:]
    left[1] = 8
    fmt.Println(right)
}

Использовать значимый получатель для небольших неизменяемых значений и указательный — когда метод меняет состояние или копирование дорого. Делать глубокую копию ссылочных полей, если копия структуры должна владеть независимым состоянием. Возвращать новое значение вместо мутации, если это делает поток данных проще и копирование недорого. Передавать адрес только когда требуется общая мутация, идентичность или избегание значимой копии. Копировать данные через `copy` или `append([]T(nil), src...)`, когда нужен независимый снимок.

Вопрос 18 из 20

Фрагмент относится к теме «Общий backing array». Какой контракт определяет результат показанного кода?

// Определите правило Go, которое объясняет результат.
package main
import "fmt"
func main() {
    a := []int{1,2,3}
    left := a[:2]
    right := a[1:]
    left[1] = 8
    fmt.Println(right)
}

Передача `*T` позволяет функции менять исходное значение, потому что копируется сам адрес, указывающий на тот же объект. Метод с получателем `*T` может менять исходное значение; компилятор часто автоматически берёт адрес адресуемой переменной. Компилятор может разместить локальное значение в куче, если указатель на него переживает вызов; возвращать такой указатель безопасно. Структура копируется как значение, но ссылочные поля внутри копии могут продолжать указывать на общие данные. Два среза могут видеть один базовый массив; запись через один срез отражается в другом, если их диапазоны пересекаются.

Вопрос 19 из 20

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

Даже значимый получатель может менять объект через ссылочное поле, например элемент общего среза. Маленький подсрез способен удерживать в памяти большой базовый массив. Escape analysis может изменить размещение после небольшой правки или обновления компилятора. Указатель на указатель имеет другой уровень разыменования и не заменяется автоматически обычным указателем. Сравнивать структуру оператором `==` можно только тогда, когда сравнимы все её поля.

Вопрос 20 из 20

В разделе «Общий backing array» показан конкретный случай. Какое замечание о цене решения будет точным?

Совместное владение экономит копирование, но требует ясного контракта мутации и времени жизни данных. Встраивание сокращает делегирование, но слишком глубокая композиция скрывает происхождение методов. Мутация через указатель удобна для состояния, но чистая функция проще для параллельного использования и тестов. Структуры удобны как значения, но наличие карт, срезов и указателей требует отдельно определить семантику копирования. Указатель избегает копирования и передаёт идентичность, но увеличивает число разделяемых состояний и проверок `nil`.

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

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

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

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