Технические вопросы к джуну на собеседовании фронтенд-разработчика | Хекслет

29 июня 2025 г. · 82 мин. чтения

Сегодня мы разберём реальные вопросы с собеседований для junior frontend-разработчиков: что именно спрашивают, почему задают тот или иной вопрос и какие ответы ожидают услышать интервьюеры. Мы рассмотрим темы от алгоритмических задач и фреймворков до Git, Docker, CI/CD и внутренней работы JavaScript — и разберёмся, где важна практика, а где достаточно честно сказать «с этим не сталкивался».

Вопрос 1. Решал ли задачи на платформах вроде Codewars, LeetCode или других подобных сервисах?

Таймкод: 00:00:43

Ответ собеседника: Правильный. От джуниоров ожидают, что они проявляют интерес к разработке за пределами фреймворков — решают алгоритмические задачи, учатся писать качественный код. Не требуется решать суперсложные задачи, но иметь хотя бы десяток решённых задач на простом или среднем уровне очень полезно. Это помогает набрать опыт программирования, и такие задачи нередко дают на реальных собеседованиях.

Правильный ветвь разработки

Почему это важно

Решение алгоритмических задач — это не просто формальность для галочки. На платформах вроде LeetCode, Codewars, HackerRank и Exercism вы развиваете навыки, которые напрямую применяются в реальной разработке:

Умение разбираться с задачей, а не просто копипастить код
Понимание временной и пространственной сложности
Работа с граничными случаями и тестирование
Привычка писать чистый, читаемый код

Что реально ожидают на собеседовании

На интервью на Go-разработчика часто спрашивают задачи уровня easy и medium. Типичные темы:

Работа со слайсами и мапами
Два указателя, скользящее окно
Обход дерева (BFS/DFS)
Хеш-таблицы для оптимизации
Простые задачи на строки

Пример задачи уровня easy на Go

// Two Sum — найти два числа в слайсе, дающие целевую сумму
func twoSum(nums []int, target int) []int {
    seen := make(map[int]int)
    for i, num := range nums {
        complement := target - num
        if j, ok := seen[complement]; ok {
            return []int{j, i}
        }
        seen[num] = i
    }
    return nil
}

Как подходить к решению задач

Начинайте с easy — 10–15 задач на easy дают больше пользы, чем одна hard
Пишите тесты — даже если платформа не требует, это формирует привычку
Анализируйте чужие решения — на LeetCode посмотрите топовые решения, часто они короче и элегантнее
Фокус на паттерны — многие задачи — вариации одних и тех же подходов

Конкретные рекомендации для Go

Решайте задачи именно на Go, чтобы прокачивать язык
Используйте стандартную библиотеку: sort, container/heap, strings, sync
Практикуйтесь с горутинами и каналами — это ваше конкурентное преимущество
Exercism имеет менторскую систему — опытные разработчики ревьюят ваш код

Сколько задач достаточно

Для джуниора: 30–50 задач на easy/medium — это реалистичная цель за 2–3 месяца при регулярной практике. Для мидла: 100+ задач с фокусом на medium и hard, плюс задачи на проектирование систем.

Вопрос 2. Какие фреймворки знаешь? Расскажи о своём опыте использования фреймворков.

Таймкод: 00:01:58

Ответ собеседника: Правильный. Вопрос открытый, чтобы собеседующий мог зацепиться за то, что знает кандидат. Нормально сказать, что есть опыт работы только с одним фреймворком (например, React или Vue), при этом слышал про остальные, но практики с ними нет. Главное — уверенно рассказывать о том фреймворке, с которым есть опыт. От джуниора не ждут сверхъестественных знаний.

Правильный ответ

Популярные фреймворки для Go

В экосистеме Go существует несколько категорий фреймворков и библиотек:

Веб-фреймворки

Gin — самый популярный веб-фреймворк, быстрый, минималистичный, с поддержкой middleware
Echo — похож на Gin, но имеет встроенную поддержку WebSocket, более строгую типизацию
Fiber — вдохновлён Express.js, работает поверх fasthttp, высокая производительность
Chi — легковесный роутер, совместимый с net/http, без лишней магии
Beego — полноценный MVC-фреймворк, больше подходит для монолитных приложений

ORM и работа с базой данных

GORM — самая популярная ORM, поддерживает миграции, хуки, связи между моделями
sqlx — расширение стандартного database/sql, без ORM-магии
ent — фреймворк от Facebook, генерирует типобезопасный код

gRPC и микросервисы

gRPC-Go — стандарт для межсервисного взаимодействия
go-kit — набор утилит для построения микросервисов
micro — полноценный фреймворк для микросервисной архитектуры

Пример простого REST API на Gin

package main

import (
    "net/http"
    "github.com/gin-gonic/gin"
)

type User struct {
    ID   int    `json:"id"`
    Name string `json:"name"`
}

func main() {
    r := gin.Default()

    r.GET("/users", func(c *gin.Context) {
        users := []User{
            {ID: 1, Name: "Alice"},
            {ID: 2, Name: "Bob"},
        }
        c.JSON(http.StatusOK, users)
    })

    r.GET("/users/:id", func(c *gin.Context) {
        id := c.Param("id")
        c.JSON(http.StatusOK, gin.H{"user_id": id})
    })

    r.POST("/users", func(c *gin.Context) {
        var user User
        if err := c.ShouldBindJSON(&user); err != nil {
            c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
            return
        }
        c.JSON(http.StatusCreated, user)
    })

    r.Run(":8080")
}

Как структурировать ответ на собеседовании

Назовите 1–2 фреймворка, с которыми есть реальный опыт
Расскажите конкретный проект — что делали, какие задачи решали
Объясните выбор — почему выбрали этот фреймворк, какие были альтернативы
Упомянуйте ограничения — покажите, что понимаете trade-offs

Пример хорошего ответа

> «В основном работал с Gin для REST API и GORM для работы с PostgreSQL. В проекте X мы выбрали Gin из-за скорости и большого сообщества. GORM использовали для быстрого прототипирования, но в горячих путях перешли на сырые запросы через sqlx, потому что GORM добавлял накладные расходы. Слышал про Echo и Fiber, но не имел опыта с ними в продакшене».

Чего не стоит говорить

«Я знаю все фреймворки» — звучит неправдоподобно
«Фреймворк X лучше Y» — без контекста это бессмысленное утверждение
«Я использовал только стандартную библиотеку» — хотя это возможно, на практике большинство проектов используют хотя бы роутер

Стандартная библиотека vs фреймворк

Go известен мощной стандартной библиотекой. net/http достаточно для многих задач. Фреймворки добавляют:

Удобную маршрутизацию с параметрами
Встроенные middleware (логирование, аутентификация, CORS)
Валидацию запросов
Генерацию документации

Для джуниора достаточно уверенного владения одним веб-фреймворком и понимания, когда нужен фреймворк, а когда хватит стандартной библиотеки.

Вопрос 3. Когда пишешь код — делаешь так, чтобы просто работало, или пишешь обдуманно?

Таймкод: 00:02:50

Ответ собеседника: Правильный. Хороший ответ — итеративный подход: сначала быстро набрасываешь рабочее решение, а затем приводишь код в порядок — дописываешь тесты, рефакторишь, выделяешь функции. Важно делать это до слияния кода в основную ветку репозитория, что подразумевает знание Git. Ответ «делаю только чтобы работало» или «долго думаю, чтобы сделать идеально» — оба плохие.

Правильный ответ

Итеративный подход к написанию кода

Опытные разработчики придерживаются итеративного подхода, который можно описать фразой «Make it work, make it right, make it fast» (Кент Бек).

Этап 1: Сделать работающим (Make it work)

На этом этапе цель — получить рабочее решение, которое проходит базовые тесты. Код может быть неоптимальным, с дублированием и без обработки всех граничных случаев.

// Первая итерация — просто работает
func CalculateTotal(items []Item) float64 {
    var total float64
    for _, item := range items {
        total += item.Price * float64(item.Quantity)
    }
    return total
}

Этап 2: Сделать правильным (Make it right)

Рефакторинг: обработка ошибок, тесты, читаемость, выделение логики.

// Вторая итерация — правильный код
type Item struct {
    Name     string
    Price    float64
    Quantity int
}

func CalculateTotal(items []Item) (float64, error) {
    if len(items) == 0 {
        return 0, ErrEmptyCart
    }

    var total float64
    for _, item := range items {
        if item.Price < 0 {
            return 0, fmt.Errorf("negative price for item %s", item.Name)
        }
        if item.Quantity < 0 {
            return 0, fmt.Errorf("negative quantity for item %s", item.Name)
        }
        total += item.Price * float64(item.Quantity)
    }
    return total, nil
}

Этап 3: Сделать быстрым (Make it fast)

Оптимизация только после профилирования. В Go есть встроенные инструменты: pprof, benchmark тесты.

// Бенчмарк для проверки производительности
func BenchmarkCalculateTotal(b *testing.B) {
    items := generateItems(10000)
    for i := 0; i < b.N; i++ {
        CalculateTotal(items)
    }
}

Почему этот подход работает

Быстрая обратная связь — вы видите результат и можете корректировать направление
Риск ошибок снижается — проще рефакторить маленький кусок, чем переписывать всё
Тесты пишутся осмысленно — вы уже понимаете граничные случаи
Код-ревью проходит легче — ревьюеры видят чистый код, а не «рабочий черновик»

Практические привычки

Коммитьте часто — даже незаконченные изменения в feature-ветке
Используйте pre-commit хуки — автоматический запуск линтеров и тестов
Пишите тесты до рефакторинга — они страхуют от регрессий
Следуйте принципу «мусор не выносим на улицу» — не мержьте грязный код в main

Пример рабочего процесса с Git

# Создаём feature-ветку
git checkout -b feature/calculate-total

# Первый коммит — рабочее решение
git add .
git commit -m "feat: add basic calculate total function"

# Второй коммит — тесты
git add .
git commit -m "test: add tests for calculate total"

# Третий коммит — рефакторинг
git add .
git commit -m "refactor: improve error handling in calculate total"

# Пушим и создаём Pull Request
git push origin feature/calculate-total

Чего стоит избегать

Преждевременная оптимизация — не оптимизируйте то, что ещё не профилировали
Перфекционизм на старте — идеального кода не существует, лучше получить обратную связь раньше
Откладывание тестов — «потом напишу» обычно означает «никогда не напишу»

Этот подход показывает зрелость разработчика и понимание реального процесса разработки в команде.

Вопрос 4. С какими менеджерами задач работал?

Таймкод: 00:04:52

Ответ собеседника: Правильный. Конкретный менеджер задач не принципиален. Главное — концептуальное понимание процесса разработки: задачи ставятся в менеджер, имеют статусы, перемещаются по этапам, связываются с коммитами и пул-реквестами, содержат комментарии. Отсутствие опыта работы с менеджером задач сигнализирует о слабом понимании процесса разработки.

Правильный ответ

Популярные менеджеры задач

Jira — стандарт индустрии, особенно в крупных компаниях. Поддерживает Scrum и Kanban, имеет мощную систему отчётов, интеграцию с Bitbucket и GitHub.

Trello — простая Kanban-доска, подходит для небольши команд и стартапов.

Asana — гибкая система с проектами, задачами и подзадачами.

YouTrack — продукт JetBrains, популярен среди Go-разработчиков.

Linear — современный и быстрый, набирает популярность в стартапах.

GitHub Issues / GitLab Issues — встроенные трекеры, тесно интегрированы с кодом.

Базовые концепции, которые нужно знать

Жизненный цикл задачи

Типичный воркфлоу задачи в менеджере:

Backlog — задача создана, но ещё не запланирована
To Do / Ready — задача готова к работе
In Progress — разработчик начал работу
In Review — код на ревью
Testing / QA — тестирование
Done — задача завершена

Связь задач с Git

Хорошая практика — связывать коммиты и Pull Request с задачей:

# Название ветки содержит номер задачи
git checkout -b feature/PROJ-123-add-user-auth

# Коммит ссылается на задачу
git commit -m "PROJ-123: add JWT authentication middleware"

В Pull Request автоматически появится ссылка на задачу в Jira.

Типичные поля задачи

Название — краткое описание
Описание — детали, критерии приёмки
Приоритет — Critical, Major, Minor, Trivial
Story Points / Estimate — оценка сложности
Исполнитель — кто работает над задачей
Спринт — к какому спринту относится
Метки — баг, фича, технический долг

Пример хорошего ответа на собеседовании

> «Работал с Jira в двух проектах. Мы использовали Scrum с двухнедельными спринтами. Каждая задача проходила путь от Backlog через In Progress и Code Review до Done. Я привязывал коммиты к задачам через ключ проекта в сообщении коммита, это автоматически отображалось в Jira. Также писал комментарии к задачам, если были вопросы или нужны уточнения от продакта».

Почему это важно для джуниора

Даже если вы работали только над pet-проектами, стоит упомянуть:

Как вы организовывали работу (доска в Trello, GitHub Issues)
Как разбивали задачи на подзадачи
Как отслеживали прогресс

Это показывает, что вы понимаете процесс разработки в команде и готовы работать в ней.

Минимальный навык

Если у вас нет коммерческого опыта, создайте доску в Trello или GitHub Projects для своего pet-проекта. Это займёт 10 минут и даст вам о чём рассказать на собеседовании.

Вопрос 5. Расскажи о своём пути в разработку. Почему именно фронтенд?

Таймкод: 00:06:13

Ответ собеседника: Правильный. У всех разные пути, и нет ничего зазорного в том, чтобы рассказать свою уникальную историю, даже если приход в профессию был случайным. Важно показать интерес к разработке. Не стоит говорить, что «было всё равно, просто увидел хорошую зарплату».

Правильный ответ

Как структурировать рассказ о пути в разработку

Этот вопрос — возможность показать свою мотивацию и осознанность выбора. Хороший ответ обычно содержит три части:

1. Как всё началось

Расскажите, что привлекло вас в программировании. Это может быть:

Желание создать что-то своё (сайт, приложение, игру)
Интерес к технологиям и тому, как работают цифровые продукты
Первый положительный опыт написания кода
Влияние окружения (друзья, ментор, онлайн-курс)

2. Почему именно Go (бэкенд)

Если вы переключаетесь с фронтенда или другого стека, объясните причину:

Интерес к серверной логике и архитектуре
Желание работать с высоконагруженными системами
Привлекательность простоты и производительности Go
Рыночный спрос на Go-разработчиков

3. Что делаете для развития

Покажите, что вы активно учитесь:

Решаете задачи на LeetCode/Codewars
Ведёте pet-проекты
Читаете техническую литературу
Участвуете в open-source

Примеры хороших ответов

Вариант 1 — классический путь:

> «Я начал изучать программирование в университете на Python, потом попробовал веб-разработку. Мне понравилось создавать полноценные приложения, но со временем потянуло к серверной части. Выбрал Go из-за его простоты и производительности. Сейчас активно изучаю конкурентность и строю pet-проект на Gin с микросервисной архитектурой».

Вариант 2 — переход из другой сферы:

> «До разработки я работал в логистике. Заметил, что многие процессы можно автоматизировать, и начал изучать Python для написания скриптов. Это затянуло, и я решил сменить профессию. Выбрал Go, потому что он хорошо подходит для бэкенда, имеет понятный синтаксис и сильное комьюнити. Полгода учился самостоятельно, сейчас ищу первую работу».

Вариант 3 — из фронтенда в бэкенд:

> «Два года работал фронтенд-разработчиком на React. Мне нравилось создавать интерфейсы, но я хотел глубже понимать, как работает серверная часть. Начал изучать Go вечерами, написал несколько REST API. Меня привлекла простота языка и мощная модель конкурентности. Сейчас хочу развиваться именно в бэкенд-разработке».

Чего стоит избегать

«Просто увидел, что зарплаты высокие» — показывает отсутствие внутренней мотивации
«Было всё равно, попробовал — получилось» — слишком небрежно
Длинные истории без структуры — собеседник может потерять интерес
Отсутствие конкретики — «я что-то учил, что-то делал» не впечатляет

Совет

Подготовьте короткий рассказ на 2–3 минуты. Он должен быть структурированным, честным и показывать ваш интерес к разработке. Даже если ваш путь был нелинейным — это нормально, главное — уметь это объяснить.

Вопрос 6. Приходилось ли писать тесты? Знаешь ли такое понятие как TDD/BDD?

Таймкод: 00:07:28

Ответ собеседника: Правильный. Это не совсем базовый вопрос, но он выделяет кандидата среди других джуниоров, особенно самоучек, которые часто не сталкивались с автоматизированным тестированием. Тестирование не является обязательным с точки зрения фактической работы — приложение может работать и без тестов, но знание принципов тестирования и опыт написания тестов говорит о более зрелом подходе к разработке.

Правильный ответ

Виды тестирования в Go

Unit-тесты — тестируют отдельные функции и методы. В Go встроена поддержка тестирования через пакет testing.

// calculator.go
package calculator

func Add(a, b int) int {
    return a + b
}

// calculator_test.go
package calculator

import "testing"

func TestAdd(t *testing.T) {
    tests := []struct {
        name     string
        a, b     int
        expected int
    }{
        {"positive numbers", 2, 3, 5},
        {"negative numbers", -1, -1, -2},
        {"zero", 0, 5, 5},
    }

    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            result := Add(tt.a, tt.b)
            if result != tt.expected {
                t.Errorf("Add(%d, %d) = %d; want %d", tt.a, tt.b, result, tt.expected)
            }
        })
    }
}

Интеграционные тесты — проверяют взаимодействие компонентов (например, сервис + база данных).

func TestUserRepository_Create(t *testing.T) {
    db := setupTestDB(t) // поднимаем тестовую БД
    defer db.Close()

    repo := NewUserRepository(db)
    user := &User{Name: "Alice", Email: "alice@example.com"}

    err := repo.Create(user)
    if err != nil {
        t.Fatalf("failed to create user: %v", err)
    }

    found, err := repo.FindByEmail("alice@example.com")
    if err != nil {
        t.Fatalf("failed to find user: %v", err)
    }
    if found.Name != "Alice" {
        t.Errorf("expected name Alice, got %s", found.Name)
    }
}

Бенчмарки — измеряют производительность кода.

func BenchmarkAdd(b *testing.B) {
    for i := 0; i < b.N; i++ {
        Add(2, 3)
    }
}

TDD (Test-Driven Development)

TDD — подход, при котором сначала пишется тест, а потом код для его прохождения. Цикл: Red → Green → Refactor.

Red — пишем тест, который падает
Green — пишем минимальный код для прохождения теста
Refactor — улучшаем код, тесты продолжают проходить

Пример TDD на Go

// Шаг 1: Пишем тест (Red)
func TestDivide(t *testing.T) {
    result, err := Divide(10, 2)
    if err != nil {
        t.Fatalf("unexpected error: %v", err)
    }
    if result != 5 {
        t.Errorf("expected 5, got %f", result)
    }
}

// Шаг 2: Пишем код (Green)
func Divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, ErrDivisionByZero
    }
    return a / b, nil
}

// Шаг 3: Добавляем тест на граничный случай
func TestDivide_ByZero(t *testing.T) {
    _, err := Divide(10, 0)
    if err != ErrDivisionByZero {
        t.Errorf("expected ErrDivisionByZero, got %v", err)
    }
}

BDD (Behavior-Driven Development)

BDD расширяет TDD, фокусируясь на поведении системы с точки зрения пользователя. Тесты описываются на естественном языке.

В Go для BDD используется библиотека godog (реализация Cucumber).

# user_registration.feature
Feature: User Registration

  Scenario: Successful registration
    Given I am on the registration page
    When I enter email "alice@example.com" and password "secret123"
    And I click the register button
    Then I should see a confirmation message

// steps.go
func iEnterEmailAndPassword(email, password string) error {
    // код для заполнения формы
    return nil
}

func iClickTheRegisterButton() error {
    // код для нажатия кнопки
    return nil
}

Популярные инструменты тестирования в Go

testify — удобные assertions и mock-генерация
gomock — генерация mock-объектов
httptest — встроенный пакет для тестирования HTTP-хендлеров
testcontainers — поднятие Docker-контейнеров для интеграционных тестов
golden files — сравнение вывода с эталонным файлом

Пример с testify

import "github.com/stretchr/testify/assert"

func TestAdd(t *testing.T) {
    assert.Equal(t, 5, Add(2, 3))
    assert.Equal(t, 0, Add(-1, 1))
}

Как ответить на собеседовании

> «Да, писал unit-тесты на Go с использованием стандартного пакета testing и testify для удобных assertions. В одном проекте практиковал TDD — сначала писал тесты, потом реализацию. Это помогало лучше продумывать API и ловить граничные случаи на раннем этапе. Знаком с BDD теоретически, но не использовал в реальных проектах».

Почему это важно

Тесты снижают количество багов в продакшене
Тесты служат документацией к коду
Тесты делают рефакторинг безопасным
Наличие тестов в проекте — признак зрелой кодовой базы

Даже если у вас мало опыта с тестированием, покажите, что вы понимаете его ценность и готовы учиться.

Вопрос 7. Как следишь за качеством кода? Какие инструменты используешь?

Таймкод: 00:08:27

Ответ собеседника: Правильный. Речь идёт о линтерах и стандартах кодирования — это база для всех разработчиков, потому что в команде невозможно работать, если каждый пишет код по-своему. Линтеры и форматеры проверяют код на соответствие правилам и автоматически приводят его к единому стилю.

Правильный ответ

Инструменты качества кода в Go

Встроенные инструменты Go

Go — один из немногих языков, где инструменты форматирования и линтинга входят в стандартную поставку:

gofmt — форматирует код согласно официальному стилю
go vet — статический анализ, поиск подозрительных конструкций
golint — проверка стиля кода (устарел, заменён на revive)

# Форматирование кода
gofmt -w .

# Статический анализ
go vet ./...

# Проверка форматирования (показывает различия)
gofmt -d .

golangci-lint — основной линтер

golangci-lint — это мета-линтер, который запускает десятки других линтеров параллельно. Это стандарт индустрии для Go.

# .golangci.yml
run:
  timeout: 5m

linters:
  enable:
    - errcheck      # проверка необработанных ошибок
    - gosimple      # упрощение кода
    - govet         # стандартный vet
    - ineffassign   # неиспользуемые присваивания
    - staticcheck   # мощный статический анализ
    - unused        # неиспользуемый код
    - gosec         # проверка безопасности
    - misspell      # опечатки в строках
    - gocyclo       # сложность функций
    - bodyclose     # проверка закрытия body HTTP-ответов

# Установка
go install github.com/golangci/golangci-lint/cmd/golangci-lint@latest

# Запуск
golangci-lint run ./...

Pre-commit хуки

Автоматический запуск линтеров перед каждым коммитом:

# .pre-commit-config.yaml
repos:
  - repo: https://github.com/golangci/golangci-lint
    rev: v1.55.2
    hooks:
      - id: golangci-lint
  - repo: https://github.com/dnephin/pre-commit-golang
    rev: v0.5.1
    hooks:
      - id: go-fmt
      - id: go-vet
      - id: go-unit-tests

CI/CD интеграция

Линтеры должны запускаться в CI-пайплайне:

# .github/workflows/lint.yml
name: Lint
on: [push, pull_request]

jobs:
  lint:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-go@v5
        with:
          go-version: '1.21'
      - name: golangci-lint
        uses: golangci/golangci-lint-action@v3
        with:
          version: latest

Метрики качества кода

Цикломатическая сложность — не более 10–15 на функцию
Покрытие тестами — цель 60–80% для бизнес-логики
Дублирование кода — менее 3%
Количество предупреждений линтера — стремление к нулю

Дополнительные инструменты

go-critic — расширенный линтер с дополнительными проверками
staticcheck — мощный статический анализ, находит баги
gosec — проверка безопасности (SQL-инъекции, утечки секретов)
revive — замена golint с настраиваемыми правилами

Пример плохого кода и исправления

// Плохо: необработанная ошибка, сложная функция
func ProcessData(data []byte) {
    var result map[string]interface{}
    json.Unmarshal(data, &result) // ошибка проигнорирована

    if result["type"] == "user" {
        // 50 строк логики...
    } else if result["type"] == "order" {
        // ещё 50 строк...
    }
}

// Хорошо: обработка ошибок, выделение функций
func ProcessData(data []byte) error {
    var result map[string]interface{}
    if err := json.Unmarshal(data, &result); err != nil {
        return fmt.Errorf("unmarshal data: %w", err)
    }

    switch result["type"] {
    case "user":
        return processUser(result)
    case "order":
        return processOrder(result)
    default:
        return fmt.Errorf("unknown type: %s", result["type"])
    }
}

Как ответить на собеседовании

> «Для качества кода использую golangci-lint с набором линтеров: errcheck, staticcheck, gosec, gocyclo. Настроил pre-commit хуки, чтобы линтеры запускались автоматически перед каждым коммитом. В CI-пайплайне тоже запускается golangci-lint, и PR не проходит мерж, если есть ошибки. Также слежу за цикломатической сложностью функций — стараюсь держать её ниже 10».

Почему это важно

Единый стиль кода упрощает ревью и онбординг
Линтеры ловят баги до попадания в продакшн
Автоматизация экономит время разработчиков
Качественный код легче поддерживать и расширять

Вопрос 8. Какой сборщик выберешь: Webpack или Vite?

Таймкод: 00:09:32

Ответ собеседника: Правильный. Предпочтительнее выбрать Vite, так как он стал новым стандартом, а Webpack уходит на второй план. Однако принципиального значения это не имеет — сборщик лишь готовит код к продакшену и упрощает разработку.

Правильный ответ

Примечание: этот вопрос относится к фронтенд-разработке, а не к Go. Однако понимание инструментов сборки полезно для полноценного разработчика.

Сборка в Go

В Go нет необходимости в сборщиках типа Webpack или Vite. Компилятор Go сам решает все задачи сборки:

# Компляция бинарника
go build -o myapp ./cmd/server

# Кросс-компиляция для другой платформы
GOOS=linux GOARCH=amd64 go build -o myapp-linux ./cmd/server

# Запуск без компиляции
go run ./cmd/server

Makefile для автоматизации

В Go-проектах часто используется Makefile для автоматизации задач:

# Makefile
.PHONY: build test lint run

build:
	go build -o bin/myapp ./cmd/server

test:
	go test -v -race ./...

lint:
	golangci-lint run ./...

run:
	go run ./cmd/server

migrate-up:
	migrate -path migrations -database "$(DATABASE_URL)" up

migrate-down:
	migrate -path migrations -database "$(DATABASE_URL)" down

Taskfile как альтернатива Makefile

# Taskfile.yml
version: '3'

tasks:
  build:
    cmds:
      - go build -o bin/myapp ./cmd/server

  test:
    cmds:
      - go test -v -race ./...

  lint:
    cmds:
      - golangci-lint run ./...

  docker-build:
    cmds:
      - docker build -t myapp:latest .

Docker для сборки

# Dockerfile
FROM golang:1.21-alpine AS builder
WORKDIR /app
COPY go.mod go.sum ./
RUN go mod download
COPY . .
RUN CGO_ENABLED=0 GOOS=linux go build -o myapp ./cmd/server

FROM alpine:latest
RUN apk --no-cache add ca-certificates
WORKDIR /root/
COPY --from=builder /app/myapp .
CMD ["./myapp"]

Если вопрос был про фронтенд

Для полноты картины, вот краткое сравнение Webpack и Vite:

Webpack

Зрелый, с огромной экосистемой
Сложная конфигурация
Медленный старт при больших проектах
Подходит для legacy-проектов

Vite

Быстрый старт благодаря ESM
Простая конфигурация
Мгновенный HMR (Hot Module Replacement)
Рекомендуется для новых проектов

Как ответить на собеседовании Go

> «В Go нет необходимости в сборщиках типа Webpack или Vite. Компилятор Go сам собирает проект в один бинарник. Для автоматизации задач я использую Makefile или Taskfile — это стандартный подход в Go-проектах. Для продакшена собираю Docker-образ с multi-stage build, чтобы минимизировать размер контейнера».

Это показывает, что вы понимаете специфику Go-экосистемы и не путаете её с фронтенд-инструментами.

Вопрос 9. MobX или Redux — какой state-менеджер выбрать в React?

Таймкод: 00:10:21

Ответ собеседника: Правильный. Конкретный выбор не имеет принципиального значения — оба инструмента используются, и популярность любого со временем меняется. Главное — понимать, какую задачу они решают (управление состоянием), и уметь работать с хотя бы одним из них.

Правильный ответ

Примечание: этот вопрос относится к фронтенд-разработке на React, а не к Go. Однако понимание управления состоянием полезно для полноценного разработчика.

Управление состоянием в Go

В Go-бэкенде нет прямого аналога React- state-менеджеров, но есть похожие концепции:

Хранение состояния в памяти

// In-memory store с потокобезопасностью
type UserStore struct {
    mu    sync.RWMutex
    users map[int]*User
}

func NewUserStore() *UserStore {
    return &UserStore{
        users: make(map[int]*User),
    }
}

func (s *UserStore) Get(id int) (*User, bool) {
    s.mu.RLock()
    defer s.mu.RUnlock()
    user, ok := s.users[id]
    return user, ok
}

func (s *UserStore) Set(user *User) {
    s.mu.Lock()
    defer s.mu.Unlock()
    s.users[user.ID] = user
}

Redis как внешнее хранилище состояния

import "github.com/redis/go-redis/v9"

type SessionStore struct {
    client *redis.Client
    ctx    context.Context
}

func NewSessionStore(addr string) *SessionStore {
    client := redis.NewClient(&redis.Options{
        Addr: addr,
    })
    return &SessionStore{
        client: client,
        ctx:    context.Background(),
    }
}

func (s *SessionStore) Set(sessionID string, data map[string]string, ttl time.Duration) error {
    return s.client.HSet(s.ctx, sessionID, data).Err()
}

func (s *SessionStore) Get(sessionID string) (map[string]string, error) {
    return s.client.HGetAll(s.ctx, sessionID).Result()
}
**

**Контекст для передачи состояния между обработчиками**

```go
type contextKey string

const userIDKey contextKey = &#34;userID&#34;

func AuthMiddleware(next http.Handler) http.Handler \{
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) \{
        userID := extractUserIDFromToken(r)
        ctx := context.WithValue(r.Context(), userIDKey, userID)
        next.ServeHTTP(w, r.WithContext(ctx))
    \})
\}

func GetUserIDFromContext(ctx context.Context) (int, bool) \{
    userID, ok := ctx.Value(userIDKey).(int)
    return userID, ok
\}

Если вопрос был про фронтенд

Для полноты картины:

Redux

Предсказуемый state через однонаправленный поток данных
Много boilerplate-кода
Отличные devtools
Подходит для больших приложений со сложным state

MobX

Реактивный подход, меньше кода
Проще для небольших проектов
Магия под капотом может затруднить отладку

Современные альтернативы

Zustand — минималистичный, набирает популярность
React Query / TanStack Query — для серверного state
Jotai / Recoil — атомарный подход

Как ответить на собеседовании Go

> «State-менеджеры вроде Redux и MobX — это фронтенд-концепции. В Go-бэкенде я работаю с состоянием через in-memory хранилища с mutex для потокобезопасности, Redis для распределённого кэширования и context для передачи данных между обработчиками. Если говорить о фронтенде, то понимаю разницу между Redux и MobX, но в Go-проектах они не применяются».

Это показывает, что вы разбираетесь в бэкенд-специфике и не путаете контексты.

Вопрос 10. Для чего нужен TypeScript?

Таймкод: 00:11:39

Ответ собеседника: Правильный. TypeScript добавляет статическую типизацию к JavaScript, что упрощает написание кода, отладку и рефакторинг. Статическая типизация особенно полезна при росте проекта и увеличении числа разработчиков.

Правильный ответ

Примечание: TypeScript относится к фронтенд/Node.js экосистеме. В Go статическая типизация встроена в язык изначально.

Типизация в Go

Go — статически типизированный язык с сильной системой типов. Это одна из ключевых особенностей языка:

// Сильная типизация — нельзя смешивать типы без явного преобразования
var count int = 42
var price float64 = 19.99

// Ошибка компиляции: count + price
// Нужно явное преобразование:
total := float64(count) + price

Интерфейсы в Go

Go использует утиную типизацию через интерфейсы:

type Logger interface {
    Log(message string)
}

type ConsoleLogger struct{}

func (c ConsoleLogger) Log(message string) {
    fmt.Println(message)
}

type FileLogger struct{}

func (f FileLogger) Log(message string) {
    // запись в файл
}

// Функция принимает любой тип, реализующий интерфейс Logger
func ProcessData(data string, logger Logger) {
    logger.Log("Processing: " + data)
}

Generics (с Go 1.18)

Go получил поддержку дженериков для переиспользуемого кода:

// Универсальная функция Min
func Min[T constraints.Ordered](a, b T) T {
    if a < b {
        return a
    }
    return b
}

// Использование
minInt := Min(3, 5)       // 3
minFloat := Min(3.14, 2.72) // 2.72
minString := Min("abc", "def") // "abc"

Сравнение типизации в Go и TypeScript

Аспект	Go	TypeScript
Типизация	Статическая, сильная	Статическая, структурная
Проверка	На этапе компиляции	На этапе компиляции (tsc)
Интерфейсы	Утиная типизация	Структурная типизация
Generics	С версии 1.18	Полная поддержка
Null safety	nil вместо null	strictNullChecks

Как ответить на собеседовании Go

> «TypeScript решает проблему динамической типизации JavaScript. В Go этой проблемы нет — язык изначально статически типизирован. Компилятор Go проверяет типы на этапе компиляции, что предотвращает многие ошибки. Также Go имеет интерфейсы для полиморфизма и дженерики (с версии 1.18) для переиспользуемого кода. Если говорить о TypeScript, то я понимаю его ценность для фронтенда, но в Go-разработке он не применяется».

Почему это важно

Понимание типизации показывает, что вы разбираетесь в фундаментальных концепциях языков программирования. Go и TypeScript имеют разные подходы к типизации, и важно понимать эти различия.

Вопрос 11. Что такое CI/CD?

Таймкод: 00:13:54

Ответ собеседника: Правильный. CI — это система, которая забирает код при изменениях и выполняет проверки: запускает линтеры, тесты, процесс сборки. CD — автоматический деплой пользователям по коммитам без ручного выкатывания версий.

Правильный ответ

CI/CD подробно

CI (Continuous Integration — Непрерывная интеграция)

CI — практика автоматической проверки кода при каждом изменении. Основные этапы:

Коммит в репозиторий — разработчик пушит код
Автоматический запуск пайплайна — CI-система обнаруживает изменения
Сборка — компиляция проекта
Линтинг — проверка стиля и качества кода
Тестирование — запуск unit и интеграционных тестов
Отчёт — уведомление о результатах

CD (Continuous Delivery — Непрерывная доставка)

Continuous Delivery — код всегда готов к деплою, но сам деплой запускается вручную.

CD (Continuous Deployment — Непрерывное развёртывание)

Continuous Deployment — код автоматически деплоится в продакшн после прохождения всех проверок.

Популярные CI/CD инструменты

GitHub Actions — интегрирован с GitHub, бесплатный для публичных репозиториев
GitLab CI/CD — встроен в GitLab
Jenkins — зрелый, но сложный в настройке
CircleCI — облачный, простой в использовании
Travis CI — популярен для open-source проектов

Пример GitHub Actions для Go

# .github/workflows/ci.yml
name: CI

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

jobs:
  lint:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-go@v5
        with:
          go-version: '1.21'
      - name: golangci-lint
        uses: golangci/golangci-lint-action@v3
        with:
          version: latest

  test:
    runs-on: ubuntu-latest
    services:
      postgres:
        image: postgres:15
        env:
          POSTGRES_USER: test
          POSTGRES_PASSWORD: test
          POSTGRES_DB: testdb
        ports:
          - 5432:5432
        options: >-
          --health-cmd pg_isready
          --health-interval 10s
          --health-timeout 5s
          --health-retries 5
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-go@v5
        with:
          go-version: '1.21'
      - name: Run tests
        run: go test -v -race ./...
        env:
          DATABASE_URL: postgres://test:test@localhost:5432/testdb?sslmode=disable

  build:
    runs-on: ubuntu-latest
    needs: [lint, test]
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-go@v5
        with:
          go-version: '1.21'
      - name: Build
        run: go build -v ./cmd/server

Пример CD с деплоем

# .github/workflows/deploy.yml
name: Deploy

on:
  push:
    branches: [main]

jobs:
  deploy:
    runs-on: ubuntu-latest
    needs: [ci]
    if: github.ref == 'refs/heads/main'
    steps:
      - uses: actions/checkout@v4
      - name: Build Docker image
        run: |
          docker build -t myapp:${{ github.sha }} .
          docker tag myapp:${{ github.sha }} myapp:latest
      - name: Push to registry
        run: |
          echo ${{ secrets.DOCKER_PASSWORD }} | docker login -u ${{ secrets.DOCKER_USERNAME }} --password-stdin
          docker push myapp:${{ github.sha }}
      - name: Deploy to server
        run: |
          ssh user@server "docker pull myapp:${{ github.sha }} && docker-compose up -d"

Типичный CI/CD пайплайн для Go-проекта

┌─────────────┐    ┌─────────────┐    ┌─────────────┐    ┌─────────────┐
│   Commit    │───▶│    Lint     │───▶│    Test     │───▶│    Build    │
└─────────────┘    └─────────────┘    └─────────────┘    └─────────────┘
                                                                │
                                                                ▼
                   ┌─────────────┐    ┌─────────────┐    ┌─────────────┐
                   │   Deploy    │◀───│   Staging   │◀───│ Docker Build│
                   └─────────────┘    └─────────────┘    └─────────────┘

Как ответить на собеседовании

> «CI/CD — это практика автоматизации проверки и развёртывания кода. CI запускает линтеры, тесты и сборку при каждом коммите. CD автоматически деплоит код в продакшн после прохождения всех проверок. Я настраивал GitHub Actions для Go-проектов: линтинг через golangci-lint, тестирование с тестовой базой PostgreSQL в Docker, сборка Docker-образа. Понимаю разницу между Continuous Delivery (ручной деплой) и Continuous Deployment (автоматический деплой)».

Почему это важно

CI ловит ошибки до попадания в продакшн
CD ускоряет доставку фич пользователям
Автоматизация экономит время разработчиков
CI/CD — стандарт в современной разработке

Вопрос 12. Какой опыт работы с Docker?

Таймкод: 00:16:13

Ответ собеседника: Правильный. Понимание Docker полезно, но не критично для трудоустройства. Нужно концептуально понимать, что такое Docker — это изоляция, docker-compose, возможность упаковать проект и обеспечить повторяемость.

Правильный ответ

Docker для Go-разработчика

Основные концепции

Образ (Image) — шаблон для создания контейнеров, содержит всё необходимое для запуска приложения
Контейнер (Container) — запущенный экземпляр образа
Dockerfile — инструкция для сборки образа
Docker Compose — оркестрация нескольких контейнеров

Dockerfile для Go-приложения

# Многоэтапная сборка для минимального размера образа
FROM golang:1.21-alpine AS builder

WORKDIR /app

# Копируем зависимости и скачиваем их (кэширование слоёв)
COPY go.mod go.sum ./
RUN go mod download

# Копируем исходный код
COPY . .

# Собираем бинарник
RUN CGO_ENABLED=0 GOOS=linux go build -ldflags="-w -s" -o /myapp ./cmd/server

# Финальный образ — минимальный Alpine
FROM alpine:latest

RUN apk --no-cache add ca-certificates tzdata

WORKDIR /root/

# Копируем бинарник из builder-этапа
COPY --from=builder /myapp .

# Копируем конфигурации и миграции
COPY --from=builder /app/configs ./configs
COPY --from=builder /app/migrations ./migrations

EXPOSE 8080

CMD ["./myapp"]

Docker Compose для локальной разработки

# docker-compose.yml
version: '3.8'

services:
  app:
    build:
      context: .
      dockerfile: Dockerfile
    ports:
      - "8080:8080"
    environment:
      - DATABASE_URL=postgres://user:password@postgres:5432/mydb?sslmode=disable
      - REDIS_URL=redis:6379
    depends_on:
      postgres:
        condition: service_healthy
      redis:
        condition: service_started
    volumes:
      - ./configs:/root/configs

  postgres:
    image: postgres:15-alpine
    environment:
      POSTGRES_USER: user
      POSTGRES_PASSWORD: password
      POSTGRES_DB: mydb
    ports:
      - "5432:5432"
    volumes:
      - postgres_data:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U user -d mydb"]
      interval: 5s
      timeout: 5s
      retries: 5

  redis:
    image: redis:7-alpine
    ports:
      - "6379:6379"

  migrate:
    image: migrate/migrate
    volumes:
      - ./migrations:/migrations
    command: ["-path", "/migrations", "-database", "postgres://user:password@postgres:5432/mydb?sslmode=disable", "up"]
    depends_on:
      postgres:
        condition: service_healthy

volumes:
  postgres_data:

Полезные команды Docker

# Сборка образа
docker build -t myapp:latest .

# Запуск контейнера
docker run -p 8080:8080 myapp:latest

# Запуск через docker-compose
docker-compose up -d

# Просмотр логов
docker-compose logs -f app

# Выполнение команды в контейнере
docker-compose exec app sh

# Остановка и удаление контейнеров
docker-compose down

# Очистка неиспользуемых образов
docker system prune -a

.dockerignore

.git
.gitignore
README.md
docker-compose.yml
Dockerfile
*.test
vendor/

Как ответить на собеседовании

> «Использую Docker для локальной разработки и деплоя Go-приложений. Пишу multi-stage Dockerfile для минимизации размера образа — собираю Go-бинарник в builder-контейнере и копирую его в Alpine. Для локальной разработки использую docker-compose с PostgreSQL, Redis и сервисом миграций. Понимаю разницу между образом и контейнером, умею смотреть логи и выполнять команды в запущенном контейнере».

Почему это важно

Docker обеспечивает воспроизводимость окружения
Упрощает онбординг новых разработчиков
Стандарт для деплоя в облако
Управление зависимостями (БД, кэш, очереди) в одном файле

Даже базовое понимание Docker выделяет вас среди кандидатов без этого опыта.

Вопрос 13. В чём отличие Git Revert от Git Reset?

Таймкод: 00:17:03

Ответ собеседника: Правильный. Git Revert создаёт новый коммит, который откатывает предыдущий. Git Reset удаляет коммиты и сбрасывает состояние рабочей директории.

Правильный ответ

Git Revert vs Git Reset

Git Revert — безопасный откат

Revert создаёт новый коммит, который отменяет изменения указанного коммита. История сохраняется, что безопасно для публичных веток.

# Откат конкретного коммита
git revert abc1234

# Откат без автоматического коммита
git revert --no-commit abc1234

# Откат нескольких коммитов
git revert abc1234 def5678

# Откат merge-коммита
git revert -m 1 <merge-commit-hash>

Git Reset — опасный откат

Reset перемещает указатель ветки, может удалить коммиты из истории. Опасен для публичных веток.

# Soft reset — отменяет коммит, изменения остаются в staging
git reset --soft HEAD~1

# Mixed reset (по умолчанию) — отменяет коммит и staging, изменения в working directory
git reset HEAD~1

# Hard reset — полностью удаляет коммит и все изменения
git reset --hard HEAD~1

# Reset до конкретного коммита
git reset --hard abc1234

Сравнение

Характеристика	Git Revert	Git Reset
История	Сохраняется	Может быть перезаписана
Новый коммит	Да	Нет
Безопасность	Безопасен для публичных веток	Опасен для публичных веток
Использование	Откат в main/develop	Откат в feature-ветке

Когда использовать

Revert:

Откат коммита в main или develop
Откат уже запушенных изменений
Когда другие разработчики могли сделать pull

Reset:

Откат локальных коммитов в feature-ветке
Перед пушем, чтобы почистить историю
Отмена последнего коммита с сохранением изменений

Пример рабочего процесса

# Вы заметили баг в main ветке
git log --oneline
# abc1234 feat: add payment feature  <-- здесь баг
# def5678 fix: update user model
# ghi9012 docs: update README

# Безопасный откат через revert
git revert abc1234
# Создаётся новый коммит, отменяющий изменения abc1234

# История выглядит так:
# jkl3456 Revert "feat: add payment feature"
# abc1234 feat: add payment feature
# def5678 fix: update user model

Git Reflog — спасение после reset

Если вы случайно сделали hard reset, можно восстановить коммиты через reflog:

# Просмотр всех действий
git reflog

# Восстановление до определённого состояния
git reset --hard HEAD@{2}

Как ответить на собеседовании

> «Git Revert создаёт новый коммит, который отменяет изменения предыдущего. Это безопасный способ отката для публичных веток, потому что история не перезаписывается. Git Reset перемещает указатель ветки и может удалить коммиты — его стоит использовать только в локальных feature-ветках до пуша. В команде мы используем revert для отката в main, а reset — для очистки локальной истории перед мержем».

Почему это важно

Понимание разницы показывает опыт работы с Git в команде
Неправильное использование reset может привести к потере чужой работы
Revert — стандарт для отката в продакшене

Вопрос 14. Сталкивался ли с ревью кода? Как проходило ревью? По какому принципу бы сам проводил ревью?

Таймкод: 00:18:01

Ответ собеседника: Правильный. Вопрос проверяет опыт работы в команде. Важно участвовать в командных проектах или open-source, где есть код-ревью.

Правильный ответ

Что такое Code Review

Code Review — процесс проверки кода другими разработчиками перед мержем в основную ветку. Это один из ключевых процессов в профессиональной разработке.

Цели Code Review

Обнаружение багов и логических ошибок
Проверка соответствия стандартам кодирования
Обмен знаниями между членами команды
Поддержание качества кодовой базы
Обучение джуниоров через фидбек

Как проходит Code Review

Разработчик создаёт Pull Request (PR)
Автоматические проверки (CI): линтеры, тесты
Назначается ревьюер (обычно 1–2 человека)
Ревьюер оставляет комментарии
Автор вносит исправления
Ревьюер аппрувит PR
Код мержится в main

Пример хорошего комментария на ревью

// Комментарий:
// Здесь возможна гонка данных, если два запроса придут одновременно.
// Можно использовать SELECT ... FOR UPDATE или оптимистичную блокировку.
// Пример: https://wiki.company.com/concurrency-patterns

func (r *Repo) UpdateBalance(userID int, amount float64) error {
    // ...
}

Принципы хорошего Code Review

Что проверять:

Корректность логики
Обработка ошибок
Потенциальные баги и граничные случаи
Производительность (N+1 запросы, отсутствие индексов)
Безопасность (SQL-инъекции, XSS)
Читаемость и понятность кода
Покрытие тестами

Чего не стоит делать:

Придираться к стилю (это делают линтеры)
Требовать переписать всё по-своему без веской причины
Оставлять только негативные комментарии
Затягивать ревью на дни

Шаблон для ревью

## Code Review

### Что сделано
- Добавлена аутентификация через JWT
- Написаны unit-тесты для auth service

### Замечания
**Блокирующие:**
- [ ] Нет обработки ошибки в `ValidateToken` (строка 42)
- [ ] Токен не проверяется на истечение срока

**Рекомендации:**
- Рассмотрите использование `context.WithTimeout` для HTTP-запросов
- Можно вынести логику валидации в отдельный middleware

### Общая оценка
В целом хороший PR, после исправления блокирующих замечаний можно мержить.

Как проводить ревью — чек-лист

Код компилируется и проходит все тесты
Нет необработанных ошибок
Имена переменных и функций понятны
Нет дублирования кода
Сложные места прокомментированы
Добавлены тесты для новой функциональности
Нет утечек ресурсов (незакрытые соединения, файлы)
Соответствует архитектурным решениям проекта

Как ответить на собеседовании

> «Да, участвовал в code review в командном проекте. Я как автор получал фидбек по обработке ошибок и именованию, а как ревьюер проверял логику, обработку edge cases и покрытие тестами. Если бы проводил ревью, я бы фокусировался на: корректности логики, обработке ошибок, безопасности и читаемости. Стилистические замечания оставлял бы линтерам. Старался бы давать конструктивный фидбек с объяснением, почему предлагаю изменить».

Если нет опыта

> «Прямого опыта code review в коммерческом проекте нет, но я понимаю его важность. Участвовал в open-source проектах на GitHub, где мои PR проходили ревью от мейнтейнеров. Также проводил ревью кода в учебных проектах с однокурсниками. Знаю, что хорошее ревью — это не поиск недостатков, а совместная работа над качеством кода».

Вопрос 15. Приходилось ли работать в команде? Как была устроена работа с Git?

Таймкод: 00:19:13

Ответ собеседника: Правильный. Вопрос проверяет понимание работы с ветками в Git. Нет единого правильного способа — существует trunk-based development. Для реального понимания нужна команда.

Правильный ответ

Модели ветвления в Git

Git Flow

Классическая модель с несколькими типами веток:

main ─────●──────────────●──────────────●─────
           \            / \            /
release     \    ●──●──●   \          /
             \  /           \        /
develop  ────●──●──●──●──●──●──●──●──●──●──
                \      /
feature          ●──●──●

main — стабильный код в продакшене
develop — ветка разработки
feature/* — ветки для новых фич
release/*— подготовка релиза
hotfix/* — срочные исправления

GitHub Flow

Упрощённая модель, популярная в стартапах:

main ─────●──●──●──●──●──●──●──●──●──
           \    / \    / \    /
feature     ●──●   ●──●   ●──●

main — всегда стабильная
feature/* — ветки для задач
Из feature → PR → main

Trunk-Based Development

Разработчики коммитят напрямую в main или используют короткоживущие ветки (1–2 дня):

main ─────●──●──●──●──●──●──●──●──●──

Минимальное количество веток
Частые коммиты в main
Feature flags для скрытия незавершённого функционала

Типичный рабочий процесс с Git

# 1. Создаём feature-ветку от main
git checkout main
git pull origin main
git checkout -b feature/PROJ-123-add-auth

# 2. Работаем, коммитим
git add .
git commit -m "PROJ-123: add JWT token generation"

git add .
git commit -m "PROJ-123: add auth middleware"

# 3. Пушим ветку
git push origin feature/PROJ-123-add-auth

# 4. Создаём Pull Request на GitHub/GitLab

# 5. После ревью и аппрува — мержим

# 6. Удаляем feature-ветку
git branch -d feature/PROJ-123-add-auth

Конфликты и их решение

# При мерже или rebase возник конфликт
git merge main
# CONFLICT (content): Merge conflict in file.go

# Открываем файл, решаем конфликт
# Убираем маркеры <<<<<<< ======= >>>>>>>

# Добавляем решённый файл
git add file.go
git commit -m "resolve merge conflict"

Полезные практики

Атомарные коммиты — один коммит = одна логическая единица
Понятные сообщения — feat: add user auth вместо fix
Регулярный rebase — держите feature-ветку актуальной
Не коммитьте секреты — используйте .gitignore и env-файлы

Conventional Commits

Стандарт для сообщений коммитов:

<type>(<scope>): <description>

[optional body]

[optional footer]

Типы:

feat — новая фича
fix — исправление бага
docs — документация
style — форматирование
refactor — рефакторинг
test — добавление тестов
chore — вспомогательные задачи

Как ответить на собеседовании

> «Работал в команде по GitHub Flow: создавал feature-ветки от main, делал PR, проходил code review, затем мержил через squash merge. В другом проекте использовали Git Flow с develop и release-ветками. При возникновении конфликтов решал их через rebase или merge с ручным разрешением конфликтов. Следовал Conventional Commits для понятных сообщений коммитов».

Если нет командного опыта

> «Прямого опыта работы в команде нет, но я изучил основные модели ветвления: Git Flow, GitHub Flow и Trunk-Based Development. В pet-проектах практиковал создание feature-веток, PR и разрешение конфликтов. Понимаю важность атомарных коммитов и понятных сообщений. Готов быстро освоить процессы, принятые в команде».

Вопрос 16. Какие инструменты разработки используешь?

Таймкод: 00:20:48

Ответ собеседника: Правильный. Ожидается рассказ про редактор кода, Git, линтеры и форматеры, Docker. Можно уточнить у интервьюера, о каких инструментах идёт речь.

Правильный ответ

Инструменты Go-разработчика

Редакторы и IDE

GoLand — специализированная IDE от JetBrains, мощная, но платная
VS Code — бесплатный, с расширением Go от Google
Vim/Neovim — для любителей терминала, с плагинами vim-go или nvim-lsp

VS Code расширения для Go

- Go (by Go Team at GitHub)
- Go Test Explorer
- Error Lens
- GitLens
- Docker
- REST Client

Инструменты командной строки

go — компилятор, тестирование, управление модулями
golangci-lint — мета-линтер
air — hot reload для Go-приложений
migrate — управление миграциями базы данных
sqlc — генерация Go-кода из SQL-запросов
mockery — генерация mock-объектов

# Установка популярных инструментов
go install github.com/cosmtrek/air@latest
go install github.com/golangci/golangci-lint/cmd/golangci-lint@latest
go install -tags 'postgres' github.com/golang-migrate/migrate/v4/cmd/migrate@latest
go install github.com/sqlc-dev/sqlc/cmd/sqlc@latest
go install github.com/vektra/mockery/v2@latest

Hot Reload с Air

# .air.toml
root = "."
tmp_dir = "tmp"

[build]
  bin = "./tmp/main"
  cmd = "go build -o ./tmp/main ./cmd/server"
  delay = 1000
  exclude_dir = ["assets", "tmp", "vendor"]
  include_ext = ["go", "tpl", "tmpl", "html"]
  kill_delay = "0.5s"
  log = "build-errors.log"
  send_interrupt = false
  stop_on_error = true

[log]
  time = false

[misc]
  clean_on_exit = true

Отладка

Delve (dlv) — отладчик для Go
pprof — профилирование CPU и памяти
trace — трассировка горутин

# Запуск с отладчиком
dlv debug ./cmd/server

# Профилирование
go tool pprof http://localhost:6060/debug/pprof/profile
go tool pprof http://localhost:6060/debug/pprof/heap

Работа с базой данных

pgAdmin — веб-интерфейс для PostgreSQL
DBeaver — универсальный клиент для разных СУБД
TablePlus — красивый и простой клиент
psql — консольный клиент PostgreSQL

API-клиенты

Postman — популярный, с автоматизацией тестов
Insomnia — легковесная альтернатива
curl — для быстрых проверок из терминала
HTTP Client в VS Code — для простых запросов

# Примеры curl
curl -X GET http://localhost:8080/api/users
curl -X POST http://localhost:8080/api/users \
  -H "Content-Type: application/json" \
  -d '{"name": "Alice", "email": "alice@example.com"}'

Мониторинг и логирование

Grafana + Prometheus — мониторинг метрик
Jaeger — распределённая трассировка
Sentry — отслеживание ошибок
Loki — агрегация логов

Как ответить на собеседовании

> «Для разработки на Go использую VS Code с официальным расширением Go. Для hot reload — air, для отладки — delve. Качество кода обеспечиваю через golangci-lint с набором линтеров (errcheck, staticcheck, gosec). Для работы с базой данных — DBeaver для визуального просмотра и psql для быстрых запросов. API тестирую через Postman и curl. Для профилирования использую встроенный pprof. В CI/CD настраиваю GitHub Actions с автоматическим запуском линтеров и тестов».

Почему это важно

Знание инструментов показывает опыт реальной разработки
Правильные инструменты повышают продуктивность
Понимание экосистемы Go выделяет вас среди кандидатов

Вопрос 17. Какие виды уязвимостей знаешь? Что такое XSS?

Таймкод: 00:21:37

Ответ собеседника: Правильный. XSS (Cross-Site Scripting) — главная уязвимость фронтенда. Злоумышленник может вставить JavaScript-код через формы, который выполнится при выводе, если его не обработать.

Правильный ответ

Основные веб-уязвимости

XSS (Cross-Site Scripting)

XSS — инъекция вредоносного JavaScript-кода в страницу, которая выполняется в браузере другого пользователя.

Типы XSS:

Stored XSS — скрипт сохраняется в базе данных (например, в комментарии)
Reflected XSS — скрипт передаётся через URL и отображается в ответе
DOM-based XSS — уязвимость в клиентском JavaScript-коде

// Защита от XSS в Go — экранирование вывода
import "html/template"

// Безопасно: template автоматически экранирует
tmpl := template.Must(template.New("").Parse(`<h1>{{.Name}}</h1>`))
tmpl.Execute(w, userInput) // <script>alert('xss')</script> будет экранирован

// Опасно: не используйте text/template для HTML
// Или ручная вставка без экранирования
fmt.Fprintf(w, "<h1>%s</h1>", userInput) // УЯЗВИМО!

CSRF (Cross-Site Request Forgery)

CSRF — заставить пользователя выполнить нежелательное действие на сайте, где он авторизован.

// Защита от CSRF в Go
import "github.com/gorilla/csrf"

func main() {
    r := mux.NewRouter()
    r.HandleFunc("/transfer", TransferHandler)

    // CSRF-токен для всех запросов
    csrfMiddleware := csrf.Protect(
        []byte("32-byte-long-auth-key"),
        csrf.Secure(false), // true в продакшене (HTTPS)
    )

    http.ListenAndServe(":8080", csrfMiddleware(r))
}

SQL Injection

Внедрение SQL-кода через пользовательский ввод.

// УЯЗВИМО: конкатенация строк
query := "SELECT * FROM users WHERE name = '" + userInput + "'"
// Злоумышленник введет: ' OR '1'='1

// БЕЗОПАСНО: параметризованные запросы
query := "SELECT * FROM users WHERE name = $1"
row := db.QueryRow(query, userInput)

// БЕЗОПАСНО: использование GORM
db.Where("name = ?", userInput).First(&user)

OWASP Top 10

Список самых критичных уязвимостей по OWASP:

Broken Access Control — неправильный контроль доступа
Cryptographic Failures — ошибки в криптографии (хранение паролей в открытом виде)
Injection — SQL, NoSQL, OS-инъекции
Insecure Design — небезопасный дизайн архитектуры
Security Misconfiguration — неправильная конфигурация
Vulnerable Components — уязвимые зависимости
Authentication Failures — ошибки аутентификации
Data Integrity Failures — нарушение целостности данных
Logging Failures — недостаточное логирование
SSRF — подделка запросов на стороне сервера

Защита в Go

// 1. Content Security Policy для защиты от XSS
w.Header().Set("Content-Security-Policy", "default-src 'self'")

// 2. CORS для ограничения доменов
w.Header().Set("Access-Control-Allow-Origin", "https://mysite.com")

// 3. Rate limiting для защиты от brute force
import "golang.org/x/time/rate"
limiter := rate.NewLimiter(1, 5) // 1 запрос в секунду, burst 5

// 4. Валидация входных данных
import "github.com/go-playground/validator/v10"
validate := validator.New()
err := validate.Struct(userInput)

// 5. Безопасные заголовки
w.Header().Set("X-Content-Type-Options", "nosniff")
w.Header().Set("X-Frame-Options", "DENY")
w.Header().Set("X-XSS-Protection", "1; mode=block")

Инструменты для проверки безопасности

gosec — статический анализ безопасности для Go
nmap — сканирование сети
OWASP ZAP — тестирование веб-приложений
Snyk — проверка зависимостей на уязвимости

# Запуск gosec
gosec ./...

# Проверка зависимостей
snyk test

Как ответить на собеседовании

> «Знаю основные веб-уязвимости из OWASP Top 10. XSS — инъекция JavaScript через пользовательский ввод, защита — экранирование вывода и Content Security Policy. CSRF — выполнение действий от имени пользователя, защита — CSRF-токены. SQL Injection — внедрение SQL-кода, защита — параметризованные запросы. В Go использую html/template для автоматического экранирования, параметризованные запросы через database/sql или GORM, и добавляю безопасные HTTP-заголовки. Для статического анализа безопасности использую gosec».

Почему это важно

Безопасность — ответственность разработчика, не только специалистов
Уязвимости могут привести к утечке данных и финансовым потерям
Знание базовых уязвимостей показывает зрелость разработчика

Вопрос 18. Строки в JavaScript изменяемы или нет?

Таймкод: 00:25:01

Ответ собеседника: Правильный. Строки в JavaScript неизменяемы. Любые преобразования строк всегда порождают новые строки.

Правильный ответ

Примечание: этот вопрос относится к JavaScript, а не к Go. Однако понимание неизменяемости строк важно для любого разработчика.

Строки в Go

В Go строки также неизменяемы (immutable). Это означает, что после создания строку нельзя изменить — любая операция создаёт новую строку.

s := "hello"
// s[0] = 'H' // Ошибка компиляции: cannot assign to s[0]

// Для изменения строки нужно создать новую
s = "H" + s[1:] // "Hello"

Внутреннее представление строки в Go

// Строка в Go — это структура с указателем на байты и длиной
type StringHeader struct {
    Data uintptr
    Len  int
}

Работа с изменяемыми строками

Для эффективного построения строк используется strings.Builder:

// Неэффективно: создаёт много промежуточных строк
var result string
for i := 0; i < 1000; i++ {
    result += "a" // Каждая итерация создаёт новую строку
}

// Эффективно: strings.Builder
var builder strings.Builder
for i := 0; i < 1000; i++ {
    builder.WriteString("a")
}
result := builder.String()

Сравнение неизменяемости в разных языках

Язык	Неизменяемость строк	Комментарий
Go	Да	Строки — неизменяемые байтовые слайсы
JavaScript	Да	Примитивный тип, неизменяемый
Python	Да	Строки неизменяемы
Java	Да	String immutable, StringBuilder для изменений
C++	Нет	std::string изменяем
Rust	Нет	String изменяем, &str — нет

Практические следствия

// 1. Безопасность: строки можно безопасно передавать между горутинами
func process(s string) {
    // s не может быть изменена извне
}

// 2. Сравнение строк
if s1 == s2 { // Работает корректно
    // ...
}

// 3. Конкатенация — дорогая операция
// Для частых конкатенаций используйте strings.Builder

// 4. Руны для Unicode
s := "Привет"
fmt.Println(len(s))           // 12 (байты)
fmt.Println(len([]rune(s)))   // 6 (символы)

Как ответить на собеседовании Go

> «В Go строки неизменяемы, как и в JavaScript. Каждая операция со строкой создаёт новую строку. Для эффективного построения строк используется strings.Builder, который минимизирует аллокации. Также важно помнить, что len(s) возвращает количество байт, а не символов — для работы с Unicode нужно использовать []rune(s) или utf8.RuneCountInString(s)».

Почему это важно

Понимание неизменяемости помогает писать эффективный код
Неизменяемость обеспечивает потокобезопасность
Знание strings.Builder показывает осведомлённость о производительности

Вопрос 19. Как проверить переменную на NaN?

Таймкод: 00:25:28

Ответ собеседника: Правильный. В реальной жизни это почти никогда не нужно. Можно честно сказать, что с таким не встречался.

Правильный ответ

Примечание: NaN (Not a Number) — концепция из мира чисел с плавающей точкой. В Go это актуально для float64/float32.

NaN в Go

package main

import (
    "fmt"
    "math"
)

func main() {
    // Создание NaN
    nan := math.NaN()
    
    // Проверка на NaN
    if math.IsNaN(nan) {
        fmt.Println("Это NaN")
    }
    
    // NaN не равен ничему, даже самому себе
    fmt.Println(nan == nan) // false!
}

Почему NaN == NaN возвращает false

Это поведение определено стандартом IEEE 754 для чисел с плавающей точкой. NaN представляет неопределённое значение, поэтому оно не может быть равно ничему.

Практические примеры

func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, fmt.Errorf("division by zero")
    }
    return a / b, nil
}

func calculateAverage(numbers []float64) (float64, error) {
    if len(numbers) == 0 {
        return math.NaN(), fmt.Errorf("empty slice")
    }
    
    var sum float64
    for _, n := range numbers {
        if math.IsNaN(n) {
            return math.NaN(), fmt.Errorf("NaN value in input")
        }
        sum += n
    }
    return sum / float64(len(numbers)), nil
}

Когда можно встретить NaN

Деление на ноль для float: 0.0 / 0.0
Извлечение корня из отрицательного числа: math.Sqrt(-1)
Операции с бесконечностью: math.Inf(1) * 0
Парсинг некорректной строки: math.ParseFloat("abc", 64)

// Примеры получения NaN
fmt.Println(0.0 / 0.0)           // NaN
fmt.Println(math.Sqrt(-1))       // NaN
fmt.Println(math.Log(-1))        // NaN

Как ответить на собеседовании

> «В Go для проверки на NaN используется функция math.IsNaN(). Важно помнить, что NaN не равен ничему, даже самому себе (NaN == NaN возвращает false), поэтому обычное сравнение не работает. На практике NaN можно получить при делении 0.0/0.0, извлечении корня из отрицательного числа или других неопределённых операциях. В реальном коде я встречал NaN редко, но знаю, как с ним работать».

Почему это может быть важно

Финансовые расчёты — неожиданный NaN может сломать отчёты
Научные вычисления — обработка граничных случаев
API — возврат NaN вместо ошибки может запутать клиентов

Вопрос 20. Передача параметров в функцию по ссылке или по значению?

Таймкод: 00:26:14

Ответ собеседника: Правильный. Вопрос проверяет концептуальное понимание работы с ссылками и значениями. Нужно понимать, что такое ссылки и не-ссылки, как это проявляется при передаче в функции.

Правильный ответ

Передача параметров в Go

Go передаёт параметры в функции по значению. Однако некоторые типы содержат указатели внутри себя, что создаёт иллюзию передачи по ссылке.

Примитивные типы — по значению

func modifyValue(x int) {
    x = 100
    fmt.Println("Inside function:", x) // 100
}

func main() {
    a := 42
    modifyValue(a)
    fmt.Println("After function:", a) // 42 — не изменилось
}

Указатели — явная передача по ссылке

func modifyValue(x *int) {
    *x = 100
}

func main() {
    a := 42
    modifyValue(&a)
    fmt.Println(a) // 100 — изменилось
}

Структуры — по значению (копируются)

type User struct {
    Name string
    Age  int
}

func updateUser(u User) {
    u.Name = "Modified"
    fmt.Println("Inside:", u.Name) // Modified
}

func main() {
    user := User{Name: "Alice", Age: 30}
    updateUser(user)
    fmt.Println("After:", user.Name) // Alice — не изменилось
}

// Чтобы изменить — передаём указатель
func updateUserPtr(u *User) {
    u.Name = "Modified"
}

Слайсы и мапы — особый случай

Слайсы и мапы содержат указатели на внутренние данные, поэтому изменения видны снаружи:

func modifySlice(s []int) {
    s[0] = 100        // Изменяет оригинал
    s = append(s, 999) // Не изменяет оригинал (новый слайс)
}

func main() {
    nums := []int{1, 2, 3}
    modifySlice(nums)
    fmt.Println(nums) // [100, 2, 3] — первый элемент изменился
}

func modifyMap(m map[string]int) {
    m["key"] = 100 // Изменяет оригинал
}

func main() {
    data := map[string]int{"key": 1}
    modifyMap(data)
    fmt.Println(data) // map[key:100]
}

Сравнение типов

Тип	Передача	Изменения видны снаружи
int, float, string, bool	По значению	Нет
struct	По значению	Нет (без указателя)
*T (указатель)	По значению (копия указателя)	Да
[]T (слайс)	По значению (копия заголовка)	Да (элементы), Нет (append)
map[K]V	По значению (копия заголовка)	Да
chan	По значению (копия заголовка)	Да
func	По значению (копия заголовка)	Да

Как ответить на собеседовании

> «В Go все параметры передаются по значению. Примитивные типы и структуры копируются полностью. Чтобы изменить оригинальную структуру, нужно передавать указатель. Слайсы и мапы — особый случай: они копируются по значению, но содержат указатели на внутренние данные, поэтому изменения элементов видны снаружи. Однако append к слайсу внутри функции не виден снаружи, потому что создаётся новый заголовок слайса».

Почему это важно

Понимание передачи параметров помогает избежать багов
Неправильное использование указателей может привести к гонкам данных
Знание особенностей слайсов и мапов критично для корректной работы

Вопрос 21. Как сделать глубокую копию объекта?

Таймкод: 00:27:55

Ответ собеседника: Правильный. Вопрос проверяет понимание разницы между глубоким и поверхностным копированием. На практике есть библиотеки для этого.

Правильный ответ

Глубокое копирование в Go

Проблема поверхностного копирования

type Address struct {
    City    string
    Street  string
}

type User struct {
    Name    string
    Age     int
    Address *Address
    Hobbies []string
}

// Поверхностное копирование
original := User{
    Name: "Alice",
    Age:  30,
    Address: &Address{City: "Moscow", Street: "Lenina"},
    Hobbies: []string{"reading", "coding"},
}

// Копируем структуру
copy := original

// Изменяем копию
copy.Address.City = "Saint Petersburg"
copy.Hobbies[0] = "gaming"

fmt.Println(original.Address.City) // "Saint Petersburg" — изменился оригинал!
fmt.Println(original.Hobbies[0])    // "gaming" — тоже изменился!

Способы глубокого копирования

1. Ручное копирование

func (u User) DeepCopy() User {
    // Копируем вложенную структуру
    addr := *u.Address
    
    // Копируем слайс
    hobbies := make([]string, len(u.Hobbies))
    copy(hobbies, u.Hobbies)
    
    return User{
        Name:    u.Name,
        Age:     u.Age,
        Address: &addr,
        Hobbies: hobbies,
    }
}

2. Сериализация/десериализация (JSON)

import "encoding/json"

func deepCopyJSON(src, dst interface{}) error {
    data, err := json.Marshal(src)
    if err != nil {
        return err
    }
    return json.Unmarshal(data, dst)
}

// Использование
var copy User
err := deepCopyJSON(&original, &copy)

3. Библиотека copier

import "github.com/jinzhu/copier"

var copy User
err := copier.CopyWithOption(&copy, &original, copier.Option{DeepCopy: true})

4. Библиотека deepcopy

import "github.com/mohae/deepcopy"

copy := deepcopy.Copy(original).(User)

Сравнение подходов

Способ	Плюсы	Минусы
Ручное	Быстрый, контроль	Много кода, ошибки
JSON	Простой	Медленный, не копирует неэкспортируемые поля
copier	Удобный, гибкий	Внешняя зависимость
deepcopy	Автоматический	Медленный, рефлексия

Когда нужно глубокое копирование

Кэширование — чтобы изменения в кэше не влияли на оригинал
Иммутабельность — передача данных без риска изменения
Тестирование — изоляция тестовых данных
Горутины — безопасная передача данных между горутинами

// Пример: безопасная передача в горутину
func processUsers(users []User) {
    for _, u := range users {
        u := u // захват переменной
        go func() {
            // Безопасно работаем с копией
            u.Name = "processed"
            fmt.Println(u)
        }()
    }
}

Как ответить на собеседовании

> «В Go для глубокого копирования есть несколько подходов. Можно написать метод DeepCopy вручную, копируя все вложенные структуры и слайсы. Можно использовать сериализацию через json.Marshal/Unmarshal, но это медленно и не работает с неэкспортируемыми полями. В продакшене я бы использовал библиотеку copier с опцией DeepCopy. Глубокое копирование нужно, когда структура содержит указатели, слайсы или мапы, и вы хотите изолировать копию от оригинала».

Почему это важно

Поверхностное копирование может привести к неожиданным багам
Гонки данных при работе с горутинами
Понимание разницы показывает глубину знаний языка

Вопрос 22. Что такое прототипы в JavaScript?

Таймкод: 00:28:38

Ответ собеседника: Правильный. Прототипы — серьёзная особенность JavaScript. Прямой работы с прототипами в современном JavaScript практически нет. Даже опытные разработчики могут не помнить детали.

Правильный ответ

Примечание: прототипы — концепция JavaScript. В Go аналогом являются структуры и интерфейсы.

Аналог прототипов в Go

В Go нет прототипного наследования, но есть композиция через встраивание (embedding):

// Базовая "структура-прототип"
type Animal struct {
    Name string
    Age  int
}

func (a Animal) Speak() string {
    return "..."
}

func (a Animal) Info() string {
    return fmt.Sprintf("%s (%d years)", a.Name, a.Age)
}

// "Наследование" через встраивание
type Dog struct {
    Animal // встраивание — аналог прототипа
    Breed  string
}

// Переопределение метода
func (d Dog) Speak() string {
    return "Woof!"
}

func main() {
    dog := Dog{
        Animal: Animal{Name: "Buddy", Age: 3},
        Breed:  "Labrador",
    }
    
    fmt.Println(dog.Speak()) // "Woof!" — переопределённый метод
    fmt.Println(dog.Info())  // "Buddy (3 years)" — унаследованный метод
}

Интерфейсы как полиморфизм

type Speaker interface {
    Speak() string
}

func MakeSound(s Speaker) {
    fmt.Println(s.Speak())
}

// Dog реализует интерфейс Speaker автоматически
MakeSound(dog) // "Woof!"

Сравнение подходов

Концепция	JavaScript	Go
Наследование	Прототипное	Композиция (embedding)
Полиморфизм	Прототипная цепочка	Интерфейсы
Переопределение	Да	Да
Множественное наследование	Нет (один прототип)	Да (множественное встраивание)

Как ответить на собеседовании Go

> «Прототипы — это концепция JavaScript, в Go её нет. Аналогом является встраивание структур (embedding), которое позволяет комбинировать поведение. Если структура Dog встраивает Animal, то методы Animal становятся доступны на Dog. Для полиморфизма в Go используются интерфейсы — любой тип, реализующий методы интерфейса, может быть использован как этот интерфейс. Это более явный и безопасный подход, чем прототипное наследование».

Если вопрос был про JavaScript

> «В JavaScript каждый объект имеет скрытое свойство [[Prototype]], которое ссылается на другой объект. При обращении к свойству, если его нет в объекте, поиск идёт по цепочке прототипов. В современном JavaScript прототипы используются неявно через классы — class Dog extends Animal создаёт прототипную цепочку. Прямая работа с прототипами нужна редко, в основном при создании библиотек или фреймворков».

Почему это важно

Понимание ООП-модели языка
Знание альтернативных подходов к наследованию
Способность сравнивать парадигмы разных языков

Вопрос 23. Что такое Node.js? Из чего он состоит?

Таймкод: 00:29:59

Ответ собеседника: Правильный. Node.js — это runtime для запуска JavaScript на сервере. Язык тот же, отличается только окружение.

Правильный ответ

Примечание: Node.js относится к JavaScript/TypeScript экосистеме. Для Go-разработчика аналогом является сам Go runtime.

Go Runtime vs Node.js

Go Runtime

Go — компилируемый язык с собственным runtime, который включает:

Сборщик мусора (GC) — автоматическое управление памятью
Планировщик горутин — M:N планировщик (M горутин на N OS-потоков)
Каналы — примитивы для коммуникации между горутинами
Рефлексия — возможность исследовать типы во время выполнения

// Go runtime управляет горутинами
func main() {
    // Go runtime автоматически управляет горутинами
    go func() {
        fmt.Println("Hello from goroutine")
    }()
    
    // Планировщик Go распределяет горутины по потокам
    runtime.GOMAXPROCS(4) // ограничение на количество потоков
}

Node.js

Node.js — среда выполнения JavaScript на сервере, построенная на V8 (движок Chrome):

V8 — движок для выполнения JavaScript
libuv — библиотека для асинхронного ввода/вывода
Event Loop — цикл событий для обработки асинхронных операций
npm — менеджер пакетов

Сравнение

Характеристика	Go	Node.js
Тип	Компилируемый	Интерпретируемый (JIT)
Конкурентность	Горутины (M:N)	Event Loop (однопоточный)
Параллелизм	Нативный	Через Worker Threads
Управление памятью	GC	GC (V8)
Типизация	Статическая	Динамическая (TypeScript опционально)

Когда что использовать

Go лучше подходит для:

Высоконагруженные сервисы
Микросервисы
CLI-утилиты
Системное программирование
Работа с сетью

Node.js лучше подходит для:

Веб-приложений (особенно с React/Vue)
Реального времени (WebSocket, чат)
API-шлюзы
Быстрое прототипирование
Serverless функций

Как ответить на собеседовании Go

> «Node.js — это среда выполнения JavaScript на сервере, построенная на движке V8. Она использует событийно-ориентированную модель с Event Loop для асинхронных операций. В Go аналогом является Go runtime, который включает сборщик мусора и планировщик горутин. Основное отличие: Go использует настоящий параллелизм через горутины, а Node.js — однопоточный Event Loop с асинхронным вводом-выводом. Для высоконагруженных сервисов я предпочитаю Go из-за лучшей производительности и предсказуемого поведения».

Почему это важно

Понимание разных подходов к конкурентности
Способность выбирать правильный инструмент для задачи
Знание экосистемы помогает в полноценной разработке

Вопрос 24. Какими способами можно обработать ошибку в промисе?

Таймкод: 00:32:15

Ответ собеседника: Правильный. Вопрос проверяет опыт работы с асинхронным программированием в JavaScript.

Правильный ответ

Примечание: промисы — концепция JavaScript. В Go аналогом являются каналы и паттерны обработки ошибок.

Аналог промисов в Go

В Go нет промисов, но есть аналогичные паттерны:

Каналы для асинхронных результатов

// Аналог Promise — канал с результатом
func fetchUser(id int) <-chan Result {
    ch := make(chan Result, 1)
    
    go func() {
        user, err := getUserFromDB(id)
        ch <- Result{User: user, Err: err}
        close(ch)
    }()
    
    return ch
}

type Result struct {
    User User
    Err  error
}

// Использование
result := <-fetchUser(123)
if result.Err != nil {
    log.Printf("Error: %v", result.Err)
    return
}
fmt.Println(result.User)

Обработка ошибок в Go — if err != nil

Go использует явную обработку ошибок вместо try/catch:

// Аналог try/catch
func processData() error {
    data, err := fetchData()
    if err != nil {
        return fmt.Errorf("fetch data: %w", err)
    }
    
    result, err := transformData(data)
    if err != nil {
        return fmt.Errorf("transform data: %w", err)
    }
    
    if err := saveData(result); err != nil {
        return fmt.Errorf("save data: %w", err)
    }
    
    return nil
}

// Вызов с обработкой ошибки
if err := processData(); err != nil {
    log.Printf("Failed to process: %v", err)
}

Обработка ошибок в горутинах

// Паттерн: канал ошибок
func worker(id int, jobs <-chan Job, results chan<- Result, errors chan<- error) {
    for job := range jobs {
        result, err := process(job)
        if err != nil {
            errors <- fmt.Errorf("worker %d: %w", id, err)
            continue
        }
        results <- result
    }
}

// Использование
errors := make(chan error, 10)
go worker(1, jobs, results, errors)

select {
case err := <-errors:
    log.Printf("Error: %v", err)
case result := <-results:
    fmt.Println(result)
}

Context для отмены и таймаутов

// Аналог Promise.race с таймаутом
func fetchWithTimeout(url string, timeout time.Duration) ([]byte, error) {
    ctx, cancel := context.WithTimeout(context.Background(), timeout)
    defer cancel()
    
    req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
    if err != nil {
        return nil, err
    }
    
    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        return nil, fmt.Errorf("request failed: %w", err)
    }
    defer resp.Body.Close()
    
    return io.ReadAll(resp.Body)
}

Сравнение подходов

Концепция	JavaScript (Promise)	Go
Асинхронность	async/await, Promise	горутины, каналы
Обработка ошибок	.catch(), try/catch	if err != nil
Отмена	AbortController	context.Context
Таймаут	Promise.race	context.WithTimeout
Параллелизм	Promise.all	sync.WaitGroup + каналы

Как ответить на собеседовании Go

> «Промисы — концепция JavaScript. В Go для асинхронных операций используются горутины и каналы. Для обработки ошибок Go использует явный паттерн if err != nil вместо try/catch. Для отмены операций — context.Context с WithTimeout или WithCancel. Если нужно вернуть результат из горутины, используется канал с структурой, содержащей результат и ошибку. Это более явный подход, чем промисы, но он даёт лучший контроль над потоком выполнения».

Почему это важно

Понимание разных моделей асинхронности
Go использует уникальный подход к конкурентности
Способность объяснить разницу между языками

Вопрос 25. Когда-нибудь приходило понимание, что нужно использовать Event Emitter?

Таймкод: 00:32:31

Ответ собеседника: Правильный. Само по себе такое не приходит — нужно понимать теорию событийных систем. Аналогичные системы используются и в бэкенде.

Правильный ответ

Event Emitter и его аналоги в Go

Event Emitter в JavaScript

Event Emitter — паттерн «издатель-подписчик» (Pub/Sub), где объект может эмитить события, а другие объекты подписываться на них.

// JavaScript
const EventEmitter = require('events');
const emitter = new EventEmitter();

emitter.on('user:created', (user) => {
    console.log(`User ${user.name} created`);
});

emitter.emit('user:created', { name: 'Alice' });

Аналог в Go — каналы

В Go нет встроенного Event Emitter, но каналы реализуют тот же паттерн:

type Event struct {
    Type string
    Data interface{}
}

type EventEmitter struct {
    listeners map[string][]chan Event
    mu        sync.RWMutex
}

func NewEventEmitter() *EventEmitter {
    return &EventEmitter{
        listeners: make(map[string][]chan Event),
    }
}

func (e *EventEmitter) On(eventType string, ch chan Event) {
    e.mu.Lock()
    defer e.mu.Unlock()
    e.listeners[eventType] = append(e.listeners[eventType], ch)
}

func (e *EventEmitter) Emit(eventType string, data interface{}) {
    e.mu.RLock()
    defer e.mu.RUnlock()
    
    event := Event{Type: eventType, Data: data}
    for _, ch := range e.listeners[eventType] {
        ch <- event
    }
}

func (e *EventEmitter) Off(eventType string, ch chan Event) {
    e.mu.Lock()
    defer e.mu.Unlock()
    
    listeners := e.listeners[eventType]
    for i, l := range listeners {
        if l == ch {
            e.listeners[eventType] = append(listeners[:i], listeners[i+1:]...)
            break
        }
    }
}

Использование Event Emitter на практике

func main() {
    emitter := NewEventEmitter()
    
    // Подписчик 1: отправка email
    emailCh := make(chan Event, 10)
    emitter.On("user:created", emailCh)
    
    go func() {
        for event := range emailCh {
            user := event.Data.(User)
            sendWelcomeEmail(user)
        }
    }()
    
    // Подписчик 2: логирование
    logCh := make(chan Event, 10)
    emitter.On("user:created", logCh)
    
    go func() {
        for event := range logCh {
            log.Printf("Event: %s, Data: %+v", event.Type, event.Data)
        }
    }()
    
    // Эмитим событие
    emitter.Emit("user:created", User{Name: "Alice", Email: "alice@example.com"})
}

Когда использовать событийную модель

Разделение ответственности — бизнес-логика не знает о побочных эффектах
Расширяемость — легко добавить новых подписчиков без изменения кода эмиттера
Асинхронность — подписчики обрабатывают события параллельно
Слабая связанность — компоненты не знают друг о друге

Примеры использования

Уведомления (email, push, SMS)
Логирование и аудит
Обновление кэша
Индексация в поисковых системах
WebSocket-уведомления

Паттерн Observer через интерфейсы

type EventHandler interface {
    Handle(event Event)
}

type EventBus struct {
    handlers map[string][]EventHandler
}

func (b *EventBus) Subscribe(eventType string, handler EventHandler) {
    b.handlers[eventType] = append(b.handlers[eventType], handler)
}

func (b *EventBus) Publish(eventType string, data interface{}) {
    event := Event{Type: eventType, Data: data}
    for _, handler := range b.handlers[eventType] {
        go handler.Handle(event) // асинхронно
    }
}

Как ответить на собеседовании

> «Event Emitter — это паттерн «издатель-подписчик». В Go аналогом являются каналы, которые реализуют тот же принцип. Я использовал событийную модель, когда нужно было уведомить несколько сервисов о создании пользователя: отправка email, запись в лог, обновление кэша. Вместо того чтобы вызывать каждый сервис последовательно, я эмитил событие, и каждый подписчик обрабатывал его независимо. Это уменьшает связанность и упрощает добавление новых обработчиков».

Почему это важно

Понимание паттернов проектирования
Умение строить слабосвязанные системы
Знание альтернативным подходам к коммуникации между компонентами

Вопрос 26. Что такое Event Loop?

Таймкод: 00:33:12

Ответ собеседника: Правильный. Event Loop — концепция асинхронного кода, не специфичная только для JavaScript. Понимание полезно для работы с асинхронностью в любом языке.

Правильный ответ

Event Loop в JavaScript

Event Loop — механизм, который позволяет JavaScript выполнять асинхронные операции в одном потоке.

Как работает Event Loop

┌─────────────────────────────┐
│        Call Stack           │
│   (синхронный код)          │
└─────────────────────────────┘
              │
              ▼
┌─────────────────────────────┐
│        Microtask Queue      │
│   (Promise.then, queueMicrotask) │
└─────────────────────────────┘
              │
              ▼
┌─────────────────────────────┐
│        Macrotask Queue      │
│   (setTimeout, setInterval, I/O) │
└─────────────────────────────┘
              │
              ▼
┌─────────────────────────────┐
│      Web APIs (браузер)     │
│   (DOM, fetch, setTimeout)  │
└─────────────────────────────┘

Порядок выполнения:

Выполняется весь синхронный код в Call Stack
Выполняются все микрозадачи (Promise.then)
Выполняется одна макрозадача (setTimeout)
Повторяется с шага 2

Пример

console.log('1'); // синхронный

setTimeout(() => {
    console.log('2'); // макрозадача
}, 0);

Promise.resolve().then(() => {
    console.log('3'); // микрозадача
});

console.log('4'); // синхронный

// Вывод: 1, 4, 3, 2

Аналог в Go — планировщик горутин

В Go нет Event Loop, но есть планировщик горутин, который решает похожую задачу:

func main() {
    // Горутины — аналог асинхронных задач
    go func() {
        fmt.Println("Асинхронная задача 1")
    }()
    
    go func() {
        fmt.Println("Асинхронная задача 2")
    }()
    
    // Синхронный код
    fmt.Println("Синхронный код")
    
    // Ждём завершения горутин
    time.Sleep(time.Second)
}

Сравнение Event Loop и Go Scheduler

Характеристика	Event Loop (JS)	Go Scheduler
Потоки	1 (однопоточный)	M горутин на N потоков
Конкурентность	Кооперативная	Вытесняющая
Блокировка	Блокирует весь поток	Блокирует только горутину
I/O	Асинхронное (libuv)	Нативное (netpoller)

Go Scheduler под капотом

Go использует модель GMP:

G — горутина
M — OS-поток
P — процессор (логический)

┌─────────────────────────────────────┐
│              P1         P2          │
│  ┌─────────┐      ┌─────────┐      │
│  │ G1 G2 G3│      │ G4 G5   │      │
│  └─────────┘      └─────────┘      │
│      │                │             │
│      ▼                ▼             │
│  ┌─────────┐      ┌─────────┐      │
│  │   M1    │      │   M2    │      │
│  └─────────┘      └─────────┘      │
└─────────────────────────────────────┘

Как ответить на собеседовании Go

> «Event Loop — это механизм в JavaScript для выполнения асинхронного кода в одном потоке. Он берёт задачи из очереди и выполняет их, когда Call Stack пуст. В Go аналогом является планировщик горутин, который распределяет горутины по OS-потокам. Основное отличие: Event Loop однопоточный и использует кооперативную многозадачность, а Go Scheduler многопоточный с вытесняющей многозадачностью. Это делает Go более предсказуемым для CPU-интенсивных задач».

Почему это важно

Понимание асинхронности — ключевая концепция в программировании
Знание различий помогает выбирать правильный инструмент
Понимание планировщика Go помогает писать эффективный конкурентный код

Вопрос 27. Что такое Set, Map, WeakSet, WeakMap?

Таймкод: 00:33:52

Ответ собеседника: Правильный. Эти структуры полезно понимать, но активно использовать в жизни вряд ли придётся. Set — множество с уникальными значениями.

Правильный ответ

Примечание: Set и Map — структуры данных из JavaScript. В Go есть аналоги.

Аналоги в Go

Set — map[T]struct{}

В Go нет встроенного Set, но он эмулируется через map:

// Реализация Set на основе map
type Set[T comparable] struct {
    items map[T]struct{}
}

func NewSet[T comparable]() *Set[T] {
    return &Set[T]{items: make(map[T]struct{})}
}

func (s *Set[T]) Add(item T) {
    s.items[item] = struct{}{}
}

func (s *Set[T]) Remove(item T) {
    delete(s.items, item)
}

func (s *Set[T]) Contains(item T) bool {
    _, ok := s.items[item]
    return ok
}

func (s *Set[T]) Size() int {
    return len(s.items)
}

// Использование
func main() {
    set := NewSet[int]()
    set.Add(1)
    set.Add(2)
    set.Add(2) // дубликат игнорируется
    
    fmt.Println(set.Contains(1)) // true
    fmt.Println(set.Size())      // 2
}

Map — встроенный тип

В Go Map — это встроенный тип (хеш-таблица):

// Создание map
ages := map[string]int{
    "Alice": 30,
    "Bob":   25,
}

// Добавление/изменение
ages["Charlie"] = 35

// Проверка наличия
if age, ok := ages["Alice"]; ok {
    fmt.Println("Alice's age:", age)
}

// Удаление
delete(ages, "Bob")

// Итерация
for name, age := range ages {
    fmt.Printf("%s: %d\n", name, age)
}

WeakSet и WeakMap

В Go нет прямого аналога WeakSet/WeakMap. Для управления памятью используется сборщик мусора. Если нужны слабые ссылки, можно использовать unsafe.Pointer или сторонние библиотеки, но это редко требуется.

Структуры данных в Go

Структура	JavaScript	Go
Множество	Set	map[T]struct{}
Словарь	Map	map[K]V
Слабое множество	WeakSet	Нет аналога
Слабый словарь	WeakMap	Нет аналога
Массив	Array	[]T (слайс)

Когда использовать Set (map[T]struct{})

// Уникальные элементы
func unique(nums []int) []int {
    seen := make(map[int]struct{})
    var result []int
    
    for _, n := range nums {
        if _, ok := seen[n]; !ok {
            seen[n] = struct{}{}
            result = append(result, n)
        }
    }
    return result
}

// Проверка дубликатов
func hasDuplicates(items []string) bool {
    seen := make(map[string]struct{})
    for _, item := range items {
        if _, ok := seen[item]; ok {
            return true
        }
        seen[item] = struct{}{}
    }
    return false
}

Потокобезопасный Set

type SafeSet[T comparable] struct {
    mu    sync.RWMutex
    items map[T]struct{}
}

func NewSafeSet[T comparable]() *SafeSet[T] {
    return &SafeSet[T]{items: make(map[T]struct{})}
}

func (s *SafeSet[T]) Add(item T) {
    s.mu.Lock()
    defer s.mu.Unlock()
    s.items[item] = struct{}{}
}

func (s *SafeSet[T]) Contains(item T) bool {
    s.mu.RLock()
    defer s.mu.RUnlock()
    _, ok := s.items[item]
    return ok
}

Как ответить на собеседовании

> «В JavaScript Set — это коллекция уникальных значений, Map — пары ключ-значение. В Go Set эмулируется через map[T]struct{}, где пустая структура не занимает память. Map в Go — это встроенный тип, хеш-таблица. WeakSet и WeakMap позволяют хранить объекты без удержания их от сборки мусора, в Go аналога нет — сборщик мусора сам управляет памятью. Я использую map[T]struct{} для проверки уникальности и быстрого поиска элементов».

Почему это важно

Понимание структур данных помогает выбирать правильный инструмент
map[T]struct{} — идиоматический способ реализовать Set в Go
Знание различий между языками показывает глубину понимания

Вопрос 28. Как добавить интернационализацию в приложение?

Таймкод: 00:35:33

Ответ собеседника: Правильный. Понимание интернационализации полезно. Хардкодить строки — плохая идея, потому что управлять этим сложно.

Правильный ответ

Интернационализация (i18n) в Go

Интернационализация — процесс подготовки приложения к поддержке нескольких языков и локалей.

Библиотеки для i18n в Go

golang.org/x/text — стандартная библиотека для локализации
nicksnyder/go-i18n — популярная библиотека для переводов
i18n — легковесная альтернатива

Использование go-i18n

import (
    "github.com/nicksnyder/go-i18n/v2/i18n"
    "golang.org/x/text/language"
)

func main() {
    bundle := i18n.NewBundle(language.English)
    bundle.RegisterUnmarshalFunc("json", json.Unmarshal)
    
    // Загрузка файлов переводов
    bundle.LoadMessageFile("active.en.json")
    bundle.LoadMessageFile("active.ru.json")
    
    // Создание локализатора
    localizer := i18n.NewLocalizer(bundle, "ru")
    
    // Получение перевода
    msg := localizer.MustLocalize(&i18n.LocalizeConfig{
        DefaultMessage: &i18n.Message{
            ID:    "hello",
            Other: "Hello, {{.Name}}!",
        },
        TemplateData: map[string]string{
            "Name": "Alice",
        },
    })
    fmt.Println(msg) // "Привет, Alice!"
}

Файлы переводов

// active.en.json
{
    "hello": "Hello, {{.Name}}!",
    "items_count": "{{.Count}} item",
    "items_count_plural": "{{.Count}} items"
}

// active.ru.json
{
    "hello": "Привет, {{.Name}}!",
    "items_count": "{{.Count}} элемент",
    "items_count_plural": "{{.Count}} элементов"
}

Определение языка из запроса

func LanguageMiddleware(bundle *i18n.Bundle) func(http.Handler) http.Handler {
    return func(next http.Handler) http.Handler {
        return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            // Определяем язык из заголовка Accept-Language
            lang := r.Header.Get("Accept-Language")
            if lang == "" {
                lang = "en"
            }
            
            localizer := i18n.NewLocalizer(bundle, lang)
            
            // Передаём локализатор в контекст
            ctx := context.WithValue(r.Context(), "localizer", localizer)
            next.ServeHTTP(w, r.WithContext(ctx))
        })
    }
}

// Использование в хендлере
func Handler(w http.ResponseWriter, r *http.Request) {
    localizer := r.Context().Value("localizer").(*i18n.Localizer)
    
    msg := localizer.MustLocalize(&i18n.LocalizeConfig{
        DefaultMessage: &i18n.Message{
            ID: "welcome",
            Other: "Welcome!",
        },
    })
    
    json.NewEncoder(w).Encode(map[string]string{"message": msg})
}

Форматирование дат и чисел

import "golang.org/x/text/message"

func formatNumbers() {
    p := message.NewPrinter(language.Russian)
    
    // Числа
    p.Printf("Price: %d\n", 1234567) // "Price: 1 234 567"
    
    // Валюта
    p.Printf("Total: %.2f USD\n", 1234.5) // "Total: 1 234,50 USD"
}

Структура проекта с i18n

project/
├── locales/
│   ├── active.en.json
│   ├── active.ru.json
│   └── active.de.json
├── internal/
│   └── i18n/
│       └── i18n.go
└── cmd/
    └── server/
        └── main.go

Как ответить на собеседовании

> «Для интернационализации в Go я использую библиотеку go-i18n. Переводы хранятся в JSON-файлах для каждого языка. Язык определяется из заголовка Accept-Language или параметра URL. Локализатор передаётся через контекст запроса. Также использую golang.org/x/text для форматирования дат, чисел и валют в зависимости от локали. Хардкодить строки — плохая практика, потому что это усложняет поддержку и добавление новых языков».

Почему это важно

Интернационализация — требование для международных продуктов
Правильная архитектура переводов упрощает поддержку
Знание i18n показывает опыт работы с реальными проектами

Вопрос 29. Что такое package-lock.json?

Таймкод: 00:35:55

Ответ собеседника: Правильный. Lock-файл фиксирует версии зависимостей. Это фундаментальная концепция, идентичная во всех языках.

Правильный ответ

Lock-файлы в разных экосистемах

package-lock.json (Node.js)

Фиксирует точные версии всех зависимостей, включая транзитивные. Обеспечивает воспроизводимость сборки.

{
    "name": "my-app",
    "lockfileVersion": 2,
    "dependencies": {
        "express": {
            "version": "4.18.2",
            "resolved": "https://registry.npmjs.org/express/-/express-4.18.2.tgz",
            "integrity": "sha512-..."
        }
    }
}

go.sum и go.mod (Go)

В Go аналогом является пара файлов go.mod и go.sum:

// go.mod
module github.com/user/myapp

go 1.21

require (
    github.com/gin-gonic/gin v1.9.1
    github.com/lib/pq v1.10.9
)

// go.sum
github.com/gin-gonic/gin v1.9.1 h1:4idEAncQnU5cB7BeOkPtxjfCSye0AAm1R0RVIqJ+Jmg=
github.com/gin-gonic/gin v1.9.1/go.mod h1:hPrL7YrpYKXt5YId3A/Tnip5kqbEAP+KLuI3SUcPTg=

Сравнение lock-файлов

Экосистема	Lock-файл	Что фиксирует
Node.js	package-lock.json	Точные версии всех зависимостей
Go	go.sum	Контрольные суммы модулей
Python	Pipfile.lock	Точные версии pip-пакетов
Rust	Cargo.lock	Точные версии крейтов
Java	gradle.lockfile	Точные версии зависимостей

Зачем нужны lock-файлы

Воспроизводимость — одинаковые зависимости на всех машинах
Стабильность — защита от неожиданных обновлений
Безопасность — контроль целостности через хэши
Аудит — понимание, какие версии используются

Семантическое версионирование (SemVer)

MAJOR.MINOR.PATCH
1.2.3
│ │ └─ исправления багов (обратно совместимые)
│ └── новые функции (обратно совместимые)
└──── ломающие изменения

Операторы версий в Go

require (
    github.com/gin-gonic/gin v1.9.1        // точная версия
    github.com/lib/pq v1.10.9             // точная версия
)

Обновление зависимостей в Go

# Просмотр устаревших зависимостей
go list -m -u all

# Обновление до последней версии
go get -u github.com/gin-gonic/gin

# Обновление всех зависимостей
go get -u ./...

# Очистка неиспользуемых зависимостей
go mod tidy

Как ответить на собеседовании

> «package-lock.json фиксирует точные версии всех зависимостей в Node.js-проекте, включая транзитивные. Это обеспечивает воспроизводимость сборки — все разработчики и CI используют одинаковые версии. В Go аналогом являются go.mod и go.sum. go.mod содержит список зависимостей и их версии, а go.sum — контрольные суммы для проверки целостности. Я всегда коммитю lock-файлы в репозиторий и использую go mod tidy для очистки неиспользуемых зависимостей».

Почему это важно

Lock-файлы — стандарт индустрии
Без них возможны неожиданные поломки при обновлениях
Понимание зависимостей показывает зрелость разработчика

Вопрос 30. Отличие ES5 и ES6.

Таймкод: 00:37:19

Ответ собеседника: Правильный. Теряет актуальность, особенно при использовании TypeScript. История про ES5 устарела.

Правильный ответ

Примечание: ES5 и ES6 — версии стандарта JavaScript. В Go аналогом является эволюция версий языка.

Основные отличия ES5 и ES6

Объявление переменных

// ES5
var name = "Alice";

// ES6
const name = "Alice"; // неизменяемая ссылка
let age = 30;         // изменяемая переменная

Стрелочные функции

// ES5
var add = function(a, b) {
    return a + b;
};

// ES6
const add = (a, b) => a + b;

Классы

// ES5 — прототипное наследование
function User(name) {
    this.name = name;
}
User.prototype.greet = function() {
    return "Hello, " + this.name;
};

// ES6 — синтаксис классов
class User {
    constructor(name) {
        this.name = name;
    }
    greet() {
        return `Hello, ${this.name}`;
    }
}

Шаблонные строки

// ES5
var greeting = "Hello, " + name + "!";

// ES6
const greeting = `Hello, ${name}!`;

Деструктуризация

// ES6
const { name, age } = user;
const [first, second] = array;

Модули

// ES5 — CommonJS
var express = require('express');
module.exports = app;

// ES6
import express from 'express';
export default app;

Эволюция Go

В Go эволюция языка происходит через версии, но с обратной совместимостью:

// Go 1.18 — дженерики
func Min[T constraints.Ordered](a, b T) T {
    if a < b {
        return a
    }
    return b
}

// Go 1.21 — встроенные функции min, max, clear
minVal := min(3, 5)

Как ответить на собеседовании Go

> «ES5 и ES6 — это версии стандарта JavaScript. ES6 (ES2015) добавил классы, стрелочные функции, деструктуризацию, модули, const/let, шаблонные строки. В Go аналогом является эволюция версий языка: например, Go 1.18 добавил дженерики, Go 1.21 — встроенные функции min/max/clear. Важно понимать, что Go сохраняет обратную совместимость — код, написанный для Go 1.x, будет работать в Go 1.y (y > x)».

Почему это важно

Понимание эволюции языков
Способность читать код разных версий
Знание современных возможностей языков

Вопрос 31. Если поставить таймер на 10 секунд, через сколько он сработает? Почему?

Таймкод: 00:37:43

Ответ собеседника: Правильный. Таймер сработает не ровно через 10 секунд, а не раньше чем через 10 секунд. Это связано с работой Event Loop.

Правильный ответ

Почему таймер не точен

В JavaScript setTimeout(fn, 10000) гарантирует, что функция выполнится не раньше чем через 10 секунд, но не гарантирует точность.

Причины задержки:

Event Loop занят — если Call Stack выполняет другой код, таймер ждёт
Macrotask Queue — таймеры попадают в очередь макрозадач
Минимальная задержка — в браузерах минимальный таймаут для вложенных таймеров — 4мс

console.log('Start');

setTimeout(() => {
    console.log('Timeout');
}, 0);

// Долгий синхронный код
for (let i = 0; i < 1000000000; i++) {}

console.log('End');

// Вывод: Start, End, Timeout
// Timeout ждал завершения синхронного кода

Аналог в Go

В Go таймеры работают иначе благодаря планировщику горутин:

package main

import (
    "fmt"
    "time"
)

func main() {
    fmt.Println("Start:", time.Now())
    
    timer := time.NewTimer(10 * time.Second)
    
    // Долгая синхронная работа
    time.Sleep(2 * time.Second)
    
    // Таймер уже сработал, но мы заняты
    select {
    case <-timer.C:
        fmt.Println("Timeout:", time.Now())
    }
}

time.After vs time.NewTimer

// time.After — простой таймер
select {
case <-time.After(10 * time.Second):
    fmt.Println("Timeout")
}

// time.NewTimer — с возможностью остановить
timer := time.NewTimer(10 * time.Second)
defer timer.Stop()

select {
case <-timer.C:
    fmt.Println("Timeout")
case <-someOtherChannel:
    fmt.Println("Cancelled")
}

Точность таймеров в Go

Go использует нативные таймеры ОС, поэтому они точнее, чем в JavaScript:

func measureTime() {
    start := time.Now()
    
    timer := time.NewTimer(1 * time.Second)
    <-timer.C
    
    elapsed := time.Since(start)
    fmt.Printf("Elapsed: %v\n", elapsed)
    // Обычно 1.0001s - 1.001s
}

Сравнение таймеров

Характеристика	JavaScript	Go
Минимальная задержка	Не раньше указанного	Не раньше указанного
Точность	Зависит от Event Loop	Зависит от планировщика
Блокирующий	Нет (асинхронный)	Нет (горутины)
Точность	~4-16ms	~1μs - 1ms

Как ответить на собеседовании

> «Таймер на 10 секунд сработает не раньше чем через 10 секунд, но может сработать позже. В JavaScript это связано с Event Loop: если Call Stack занят выполнением другого кода, колбэк таймера ждёт в очереди макрозадач. В Go таймеры точнее, потому что планировщик горутин работает на уровне ОС, но тоже не гарантируют абсолютную точность — горутина может ждать планировщик. В обоих случаях таймер гарантирует минимальную задержку, но не максимальную».

Почему это важно

Понимание асинхронности и планирования
Невозможно полагаться на точные таймеры для критичных операций
Знание различий между языками помогает выбирать правильный инструмент

Вопрос 32. Что такое замыкание в JavaScript?

Таймкод: 00:38:55

Ответ собеседника: Правильный. Замыкание — фундаментальная концепция в программировании, не только в JavaScript. Важно понимать на глубоком уровне.

Правильный ответ

Замыкание (Closure)

Замыкание — это функция, которая запоминает переменные из внешней области видимости, даже после того как внешняя функция завершила выполнение.

Пример в JavaScript

function createCounter() {
    let count = 0; // переменная в замыкании
    
    return function increment() {
        count++;
        return count;
    };
}

const counter = createCounter();
console.log(counter()); // 1
console.log(counter()); // 2
console.log(counter()); // 3
// count сохраняется между вызовами

Аналог в Go

В Go замыкания работают аналогично:

package main

import "fmt"

func createCounter() func() int {
    count := 0 // переменная захватывается замыканием
    
    return func() int {
        count++
        return count
    }
}

func main() {
    counter := createCounter()
    fmt.Println(counter()) // 1
    fmt.Println(counter()) // 2
    fmt.Println(counter()) // 3
}

Практическое использование замыканий

1. Фабрики функций

func multiplier(factor int) func(int) int {
    return func(x int) int {
        return x * factor
    }
}

double := multiplier(2)
triple := multiplier(3)

fmt.Println(double(5))  // 10
fmt.Println(triple(5))  // 15

2. Middleware в веб-фреймворках

func loggingMiddleware(logger *log.Logger) gin.HandlerFunc {
    // logger захватывается замыканием
    return func(c *gin.Context) {
        start := time.Now()
        c.Next()
        logger.Printf("%s %s %v", c.Request.Method, c.Request.URL, time.Since(start))
    }
}

3. Приватные переменные

func NewUserRepo(db *sql.DB) *UserRepo {
    // db доступен только через методы
    return &UserRepo{db: db}
}

type UserRepo struct {
    db *sql.DB
}

func (r *UserRepo) FindByID(id int) (*User, error) {
    // используем r.db
}

4. Обработчики с конфигурацией

func createHandler(config Config) http.HandlerFunc {
    // config захватывается замыканием
    return func(w http.ResponseWriter, r *http.Request) {
        if config.RequireAuth {
            // проверка аутентификации
        }
        // обработка запроса
    }
}

Опасность: захват переменной в цикле

// Неправильно
var handlers []func()
for i := 0; i < 3; i++ {
    handlers = append(handlers, func() {
        fmt.Println(i) // все напечатают 3
    })
}

// Правильно
for i := 0; i < 3; i++ {
    i := i // новая переменная на каждой итерации
    handlers = append(handlers, func() {
        fmt.Println(i) // 0, 1, 2
    })
}

Как ответить на собеседовании

> «Замыкание — это функция, которая захватывает переменные из внешней области видимости и сохраняет к ним доступ даже после завершения внешней функции. В Go замыкания используются для создания фабрик функций, middleware, обработчиков с конфигурацией. Важно помнить о подводном камне с циклами — если замыкание захватывает переменную цикла, нужно создавать локальную копию. Замыкания — мощный инструмент для инкапсуляции состояния и создания функций с предустановленными параметрами».

Почему это важно

Замыкания — основа функционального программирования
Используются в middleware, обработчиках, фабриках
Понимание замыканий помогает избежать багов с захватом переменных

Вопрос 33. Что такое самовызывающаяся функция (IIFE)?

Таймкод: 00:39:19

Ответ собеседника: Правильный. В современном JavaScript это неактуально. Раньше это было базовым знанием, сейчас используется в основном сборщиками.

Правильный ответ

IIFE (Immediately Invoked Function Expression)

IIFE — функция, которая выполняется сразу после объявления.

Синтаксис в JavaScript

// Классический IIFE
(function() {
    var message = "Hello";
    console.log(message);
})();

// Стрелочная функция
(() => {
    console.log("IIFE");
})();

Зачем использовался IIFE

Изоляция области видимости — переменные не попадают в глобальную область
Модули — до появления ES6 модулей
Инкапсуляция — сокрытие приватных данных

// Пример: модуль через IIFE
var Counter = (function() {
    var count = 0; // приватная переменная
    
    return {
        increment: function() { return ++count; },
        decrement: function() { return --count; },
        getCount: function() { return count; }
    };
})();

Counter.increment(); // 1
Counter.increment(); // 2
Counter.getCount();  // 2

Аналог в Go

В Go нет IIFE в классическом понимании, но есть похожие паттерны:

// Аналог IIFE — анонимная функция, вызываемая сразу
func main() {
    result := func() int {
        a := 10
        b := 20
        return a + b
    }()
    fmt.Println(result) // 30
}

// Инициализация при загрузке пакета
var config = func() Config {
    cfg, err := loadConfig()
    if err != nil {
        log.Fatal(err)
    }
    return cfg
}()

init() функция в Go

Аналогом IIFE для инициализации пакета является функция init():

package database

import "log"

var db *sql.DB

func init() {
    var err error
    db, err = sql.Open("postgres", "connection_string")
    if err != nil {
        log.Fatal("Failed to connect to database:", err)
    }
}

Современная альтернатива

В современном JavaScript IIFE заменена модулями:

// Вместо IIFE
const message = "Hello"; // не попадает в глобальную область

export function greet() {
    console.log(message);
}

Как ответить на собеседовании Go

> «IIFE — это самовызывающаяся функция в JavaScript, которая выполняется сразу после объявления. Использовалась для изоляции области видимости и создания модулей до появления ES6. В Go аналогом является анонимная функция, вызываемая сразу, или функция init() для инициализации пакета. В современном JavaScript IIFE практически не используется благодаря модулям и блочной области видимости (let/const)».

Почему это важно

Понимание истории развития языков
Знание паттернов изоляции области видимости
Способность читать legacy-код

Вопрос 34. Чем отличается протокол HTTP от HTTPS?

Таймкод: 00:41:25

Ответ собеседника: Правильный. HTTPS — защищённая версия HTTP с сертификатами, трафик зашифрован.

Правильный ответ

HTTP vs HTTPS

HTTP (HyperText Transfer Protocol)

Передаёт данные в открытом виде
Порт по умолчанию: 80
Не обеспечивает конфиденциальность
Уязвим к атакам «человек посередине» (MITM)

HTTPS (HTTP Secure)

Использует TLS/SSL для шифрования
Порт по умолчанию: 443
Обеспечивает конфиденциальность и целостность данных
Требует SSL-сертификат

Как работает HTTPS

┌─────────┐                              ┌─────────┐
│ Клиент  │                              │ Сервер  │
└────┬────┘                              └────┬────┘
     │                                        │
     │  1. ClientHello (поддерживаемые алгоритмы)
     │───────────────────────────────────────▶│
     │                                        │
     │  2. ServerHello + Сертификат           │
     │◀───────────────────────────────────────│
     │                                        │
     │  3. Проверка сертификата               │
     │                                        │
     │  4. Обмен ключами                      │
     │◀──────────────────────────────────────▶│
     │                                        │
     │  5. Зашифрованный обмен данными        │
     │◀──────────────────────────────────────▶│

Настройка HTTPS в Go

package main

import (
    "log"
    "net/http"
)

func main() {
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        w.Write([]byte("Hello, HTTPS!"))
    })

    // HTTP сервер (для редиректа на HTTPS)
    go http.ListenAndServe(":80", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        http.Redirect(w, r, "https://"+r.Host+r.RequestURI, http.StatusMovedPermanently)
    }))

    // HTTPS сервер
    err := http.ListenAndServeTLS(":443", "cert.pem", "key.pem", nil)
    if err != nil {
        log.Fatal(err)
    }
}

Автоматический HTTPS с Let's Encrypt

package main

import (
    "log"
    "net/http"
    
    "golang.org/x/crypto/acme/autocert"
)

func main() {
    certManager := autocert.Manager{
        Prompt:     autocert.AcceptTOS,
        HostPolicy: autocert.HostWhitelist("example.com"),
        Cache:      autocert.DirCache("certs"),
    }

    server := &http.Server{
        Addr:      ":443",
        Handler:   http.HandlerFunc(handler),
        TLSConfig: certManager.TLSConfig(),
    }

    // Редирект с HTTP на HTTPS
    go http.ListenAndServe(":80", certManager.HTTPHandler(nil))

    log.Fatal(server.ListenAndServeTLS("", ""))
}

HTTP/2 и HTTPS

Начиная с HTTP/2, браузеры поддерживают протокол только по HTTPS:

// Go автоматически использует HTTP/2 при HTTPS
server := &http.Server{
    Addr:    ":443",
    Handler: handler,
}
server.ListenAndServeTLS("cert.pem", "key.pem")

Проверка сертификата в клиенте

import (
    "crypto/tls"
    "net/http"
)

func createSecureClient() *http.Client {
    return &http.Client{
        Transport: &http.Transport{
            TLSClientConfig: &tls.Config{
                MinVersion: tls.VersionTLS12,
                // Для тестов можно отключить проверку (НЕ в продакшене!)
                // InsecureSkipVerify: true,
            },
        },
    }
}

Как ответить на собеседовании

> «HTTP передаёт данные в открытом виде на порту 80, HTTPS использует TLS/SSL для шифрования на порту 443. HTTPS обеспечивает конфиденциальность, целостность данных и аутентификацию сервера через сертификат. В Go для HTTPS нужно вызвать ListenAndServeTLS с путями к сертификату и ключу. Для автоматического получения сертификатов от Let's Encrypt используется пакет golang.org/x/crypto/acme/autocert. Начиная с HTTP/2, браузеры поддерживают протокол только по HTTPS, поэтому в продакшене всегда нужно использовать HTTPS».

Почему это важно

HTTPS — стандарт для продакшена
Безопасность данных пользователей — приоритет
SEO: Google ранжирует HTTPS-сайты выше
Многие API требуют HTTPS для работы

Вопрос 35. Что такое CORS?

Таймкод: 00:42:31

Ответ собеседника: Правильный. CORS будет постоянно всплывать при работе с запросами между разными доменами.

Правильный ответ

CORS (Cross-Origin Resource Sharing)

CORS — механизм безопасности, который позволяет серверу указывать, каким источникам (origins) разрешено доступ к его ресурсам.

Что такое Origin

Origin — комбинация протокола, домена и порта:

https://example.com:443
├─────┘ ├──────────┘ ├─┘
протокол  домен      порт

Проблема: Same-Origin Policy

По умолчанию браузеры блокируют запросы к другому origin:

https://mysite.com  →  https://api.mysite.com  ❌ Блокировано (другой домен)
https://mysite.com  →  https://mysite.com:8080  ❌ Блокировано (другой порт)
https://mysite.com  →  http://mysite.com       ❌ Блокировано (другой протокол)

Как работает CORS

┌─────────────┐                        ┌─────────────┐
│   Клиент    │                        │   Сервер    │
└──────┬──────┘                        └──────┬──────┘
       │                                      │
       │  1. Preflight (OPTIONS)              │
       │  Origin: https://mysite.com          │
       │─────────────────────────────────────▶│
       │                                      │
       │  2. Ответ с CORS-заголовками         │
       │  Access-Control-Allow-Origin: *      │
       │◀─────────────────────────────────────│
       │                                      │
       │  3. Основной запрос (GET/POST)       │
       │─────────────────────────────────────▶│
       │                                      │
       │  4. Ответ с данными                  │
       │◀─────────────────────────────────────│

Основные CORS-заголовки

Заголовок	Описание
`Access-Control-Allow-Origin`	Разрешённые origins
`Access-Control-Allow-Methods`	Разрешённые HTTP-методы
`Access-Control-Allow-Headers`	Разрешённые заголовки
`Access-Control-Allow-Credentials`	Разрешены ли cookies
`Access-Control-Max-Age`	Время кэширования preflight

Настройка CORS в Go с Gin

package main

import (
    "github.com/gin-contrib/cors"
    "github.com/gin-gonic/gin"
    "time"
)

func main() {
    r := gin.Default()

    // Настройка CORS
    r.Use(cors.New(cors.Config{
        AllowOrigins:     []string{"https://mysite.com", "https://admin.mysite.com"},
        AllowMethods:     []string{"GET", "POST", "PUT", "DELETE", "OPTIONS"},
        AllowHeaders:     []string{"Origin", "Content-Type", "Authorization"},
        ExposeHeaders:    []string{"Content-Length"},
        AllowCredentials: true,
        MaxAge:           12 * time.Hour,
    }))

    r.GET("/api/users", getUsers)
    r.Run(":8080")
}

CORS middleware вручную

func CORSMiddleware() gin.HandlerFunc {
    return func(c *gin.Context) {
        c.Header("Access-Control-Allow-Origin", "https://mysite.com")
        c.Header("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS")
        c.Header("Access-Control-Allow-Headers", "Origin, Content-Type, Authorization")
        c.Header("Access-Control-Allow-Credentials", "true")

        // Preflight запрос
        if c.Request.Method == "OPTIONS" {
            c.AbortWithStatus(204)
            return
        }

        c.Next()
    }
}

CORS с стандартной библиотекой

func enableCORS(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        w.Header().Set("Access-Control-Allow-Origin", "https://mysite.com")
        w.Header().Set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS")
        w.Header().Set("Access-Control-Allow-Headers", "Content-Type, Authorization")

        if r.Method == "OPTIONS" {
            w.WriteHeader(http.StatusOK)
            return
        }

        next.ServeHTTP(w, r)
    })
}

func main() {
    mux := http.NewServeMux()
    mux.HandleFunc("/api/users", usersHandler)

    handler := enableCORS(mux)
    http.ListenAndServe(":8080", handler)
}

Как ответить на собеседовании

> «CORS — механизм безопасности браузера, который контролирует доступ к ресурсам с другого origin. Блокирует запросы между разными доменами, портами или протоколами. Для разрешения нужно настроить заголовки Access-Control-Allow-Origin, Allow-Methods, Allow-Headers на сервере. В Go я использую пакет gin-contrib/cors для Gin или пишу middleware вручную для стандартной библиотеки. Preflight-запрос (OPTIONS) браузер отправляет перед основным запросом, чтобы проверить разрешения».

Почему это важно

CORS — частая проблема при разработке веб-приложений
Понимание безопасности на уровне браузера
Необходимо для работы с API на другом домене

Вопрос 36. Что такое REST API?

Таймкод: 00:42:39

Ответ собеседника: Правильный. REST API — это HTTP-вызовы по определённым правилам. Лучше иметь практический опыт, чем заученный ответ.

Правильный ответ

REST (Representational State Transfer)

REST — архитектурный стиль для построения распределённых систем, основанный на принципах HTTP.

Принципы REST

Client-Server — разделение клиента и сервера
Stateless — сервер не хранит состояние между запросами
Cacheable — ответы можно кэшировать
Uniform Interface — единый интерфейс для всех ресурсов
Layered System — клиент не знает о промежуточных слоях

RESTful API — работа с ресурсами

Каждый ресурс имеет URL и оперирует через HTTP-методы:

Метод	Действие	Пример
GET	Получить ресурс	GET /api/users
GET	Получить один ресурс	GET /api/users/123
POST	Создать ресурс	POST /api/users
PUT	Обновить ресурс полностью	PUT /api/users/123
PATCH	Частичное обновление	PATCH /api/users/123
DELETE	Удалить ресурс	DELETE /api/users/123

REST API в Go с Gin

package main

import (
    "net/http"
    "strconv"

    "github.com/gin-gonic/gin"
)

type User struct {
    ID    int    `json:"id"`
    Name  string `json:"name"`
    Email string `json:"email"`
}

var users = []User{
    {ID: 1, Name: "Alice", Email: "alice@example.com"},
    {ID: 2, Name: "Bob", Email: "bob@example.com"},
}

func main() {
    r := gin.Default()

    // Получить всех пользователей
    r.GET("/api/users", func(c *gin.Context) {
        c.JSON(http.StatusOK, users)
    })

    // Получить пользователя по ID
    r.GET("/api/users/:id", func(c *gin.Context) {
        id, err := strconv.Atoi(c.Param("id"))
        if err != nil {
            c.JSON(http.StatusBadRequest, gin.H{"error": "invalid id"})
            return
        }

        for _, user := range users {
            if user.ID == id {
                c.JSON(http.StatusOK, user)
                return
            }
        }
        c.JSON(http.StatusNotFound, gin.H{"error": "user not found"})
    })

    // Создать пользователя
    r.POST("/api/users", func(c *gin.Context) {
        var newUser User
        if err := c.ShouldBindJSON(&newUser); err != nil {
            c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
            return
        }
        newUser.ID = len(users) + 1
        users = append(users, newUser)
        c.JSON(http.StatusCreated, newUser)
    })

    // Обновить пользователя
    r.PUT("/api/users/:id", func(c *gin.Context) {
        id, _ := strconv.Atoi(c.Param("id"))
        var updatedUser User
        if err := c.ShouldBindJSON(&updatedUser); err != nil {
            c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
            return
        }

        for i, user := range users {
            if user.ID == id {
                updatedUser.ID = id
                users[i] = updatedUser
                c.JSON(http.StatusOK, updatedUser)
                return
            }
        }
        c.JSON(http.StatusNotFound, gin.H{"error": "user not found"})
    })

    // Удалить пользователя
    r.DELETE("/api/users/:id", func(c *gin.Context) {
        id, _ := strconv.Atoi(c.Param("id"))
        for i, user := range users {
            if user.ID == id {
                users = append(users[:i], users[i+1:]...)
                c.JSON(http.StatusOK, gin.H{"message": "deleted"})
                return
            }
        }
        c.JSON(http.StatusNotFound, gin.H{"error": "user not found"})
    })

    r.Run(":8080")
}

Пагинация, фильтрация, сортировка

// GET /api/users?page=1&limit=10&sort=name&order=asc
r.GET("/api/users", func(c *gin.Context) {
    page, _ := strconv.Atoi(c.DefaultQuery("page", "1"))
    limit, _ := strconv.Atoi(c.DefaultQuery("limit", "10"))
    sort := c.DefaultQuery("sort", "id")
    order := c.DefaultQuery("order", "asc")

    // Логика пагинации и сортировки
    start := (page - 1) * limit
    end := start + limit
    if end > len(users) {
        end = len(users)
    }

    c.JSON(http.StatusOK, gin.H{
        "data":  users[start:end],
        "total": len(users),
        "page":  page,
        "limit": limit,
    })
})

Коды ответов

Код	Значение	Когда использовать
200	OK	Успешный GET, PUT, PATCH
201	Created	Успешный POST
204	No Content	Успешный DELETE
400	Bad Request	Ошибка валидации
401	Unauthorized	Не аутентифицирован
403	Forbidden	Нет прав доступа
404	Not Found	Ресурс не найден
500	Internal Server Error	Ошибка сервера

Как ответить на собеседовании

> «REST API — архитектурный стиль для построения веб-сервисов на основе HTTP. Основные принципы: работа с ресурсами через URL, использование HTTP-методов для операций (GET, POST, PUT, DELETE), stateless — сервер не хранит состояние между запросами. В Go я строил REST API с помощью Gin: маршрутизация, валидация входных данных, правильные HTTP-коды ответов. Также реализовывал пагинацию, фильтрацию и сортировку через query-параметры».

Почему это важно

REST API — стандарт для взаимодействия между сервисами
Понимание REST показывает знание HTTP и веб-разработки
Необходимо для работы с микросервисами и внешними API

Вопрос 37. Что такое reflow и repaint?

Таймкод: 00:43:52

Ответ собеседника: Правильный. Это особенности отрисовки страницы браузером. Специфические знания, которые не сильно влияют на результат собеседования.

Правильный ответ

Примечание: reflow и repaint — концепции из фронтенд-разработки, связанные с рендерингом в браузере. Для Go-разработчика это не критично, но понимание полезно.

Reflow и Repaint

Repaint (Перерисовка)

Происходит, когда изменяется визуальное представление элемента без изменения его размера или позиции:

Изменение цвета фона
Изменение цвета текста
Изменение видимости (visibility: hidden)

Reflow (Перевёрстка / Layout)

Происходит, когда изменяется размер или позиция элемента, что влияет на расположение других элементов:

Изменение ширины/высоты
Изменение padding/margin
Добавление/удаление элементов из DOM
Изменение шрифта
Изменение размера окна браузера

Процесс рендеринга в браузере

┌──────────┐    ┌──────────┐    ┌──────────┐    ┌──────────┐
│   HTML   │───▶│   DOM    │───▶│  Layout  │───▶│  Paint   │
│          │    │   Tree   │    │ (Reflow) │    │(Repaint) │
└──────────┘    └──────────┘    └──────────┘    └──────────┘

Оптимизация производительности

// Плохо: вызывает reflow на каждой итерации
for (let i = 0; i < 100; i++) {
    element.style.width = i + 'px';
}

// Хорошо: пакетное обновление
element.style.width = '100px';

// Хорошо: использование CSS классов
element.classList.add('expanded');

// Хорошо: DocumentFragment для пакетных DOM-операций
const fragment = document.createFragment();
for (let i = 0; i < 100; i++) {
    const li = document.createElement('li');
    li.textContent = `Item ${i}`;
    fragment.appendChild(li);
}
list.appendChild(fragment);

Как ответить на собеседовании Go

> «Reflow и repaint — это концепции фронтенд-разработки, связанные с рендерингом в браузере. Reflow происходит при изменении размеров или позиции элементов, что требует пересчёта layout. Repaint — перерисовка визуальных свойств без изменения layout. Для оптимизации избегают частых DOM-манипуляций, используют CSS-классы вместо inline-стилей и DocumentFragment для пакетных операций. Как Go-разработчик, я фокусируюсь на бэкенде, но понимаю основы фронтенда».

Почему это может быть полезно

Понимание полного стека веб-разработки
Умение объяснить фронтендерам ограничения бэкенда
Общее понимание производительности веб-приложений

Вопрос 38. Когда пользователь вводит запрос в адресной строке браузера или кликает на ссылку — что происходит?

Таймкод: 00:44:28

Ответ собеседника: Правильный. Вводите адрес → DNS узнаёт IP → устанавливается соединение → отправляется HTTPS-запрос → сервер возвращает ответ → браузер отрисовывает.

Правильный ответ

Полный процесс загрузки страницы

1. Ввод URL

https://example.com:443/users/123?page=1#profile
├─────┘ ├──────────┘├─┘├──────────────┘├─────┤├──────┘
протокол  домен     порт  path          query  fragment

2. DNS Resolution (определение IP)

Браузер → DNS сервер → IP адрес

Проверяется кэш браузера
Проверяется кэш ОС
Запрос к DNS-резолверу (провайдер)
Рекурсивный поиск: Root DNS → TLD DNS → Authoritative DNS

3. Установление соединения (TCP + TLS)

┌─────────┐                    ┌─────────┐
│ Клиент  │                    │ Сервер  │
└────┬────┘                    └────┬────┘
     │                              │
     │  1. SYN                      │
     │─────────────────────────────▶│
     │                              │
     │  2. SYN-ACK                  │
     │◀─────────────────────────────│
     │                              │
     │  3. ACK                      │
     │─────────────────────────────▶│
     │                              │
     │  TLS Handshake               │
     │◀────────────────────────────▶│
     │                              │
     │  Зашифрованное соединение    │
     │◀────────────────────────────▶│

4. Отправка HTTP-запроса

GET /users/123?page=1 HTTP/1.1
Host: example.com
User-Agent: Mozilla/5.0
Accept: text/html,application/json
Accept-Language: ru-RU,en-US
Cookie: session_id=abc123

5. Сервер обрабатывает запрос

Запрос → Балансировик → Веб-сервер → Приложение → База данных

6. Сервер отправляет ответ

HTTP/1.1 200 OK
Content-Type: text/html; charset=UTF-8
Content-Length: 1234
Cache-Control: max-age=3600
Set-Cookie: session_id=xyz789

<!DOCTYPE html>
<html>
<head>
    <link rel="stylesheet" href="/styles.css">
    <script src="/app.js"></script>
</head>
<body>
    <div id="root"></div>
</body>
</html>

7. Бренч-рендеринг

HTML → DOM Tree
CSS  → CSSOM Tree
      ↓
  Render Tree
      ↓
  Layout (Reflow)
      ↓
  Paint (Repaint)
      ↓
  Composite
      ↓
  Отображение на экране

Go-сервер, обрабатывающий запрос

package main

import (
    "fmt"
    "log"
    "net/http"
    "time"
)

func main() {
    // Middleware для логирования
    loggedHandler := loggingMiddleware(http.DefaultServeMux)

    http.HandleFunc("/users/", userHandler)

    server := &http.Server{
        Addr:         ":8080",
        Handler:      loggedHandler,
        ReadTimeout:  10 * time.Second,
        WriteTimeout: 10 * time.Second,
        IdleTimeout:  60 * time.Second,
    }

    log.Fatal(server.ListenAndServe())
}

func loggingMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()
        next.ServeHTTP(w, r)
        log.Printf("%s %s %v", r.Method, r.URL, time.Since(start))
    })
}

func userHandler(w http.ResponseWriter, r *http.Request) {
    // Парсинг параметров
    // Запрос к базе данных
    // Формирование ответа
    
    w.Header().Set("Content-Type", "application/json")
    w.WriteHeader(http.StatusOK)
    fmt.Fprintf(w, `{"id": 123, "name": "Alice"}`)
}

Как ответить на собеседовании

> «Когда пользователь вводит URL, происходит несколько этапов. Сначала DNS преобразует доменное имя в IP-адрес. Затем устанавливается TCP-соединение и TLS-рукопожатие для HTTPS. Браузер отправляет HTTP-запрос с методом, заголовками и телом. Сервер принимает запрос, обрабатывает его (возможно, обращается к базе данных), формирует HTTP-ответ с кодом статуса, заголовками и телом. Браузер получает ответ, парсит HTML, загружает ресурсы (CSS, JS, изображения), строит DOM и CSSOM, выполняет JavaScript и отрисовывает страницу. Как Go-разработчик, я отвечаю за серверную часть: обработку запросов, бизнес-логику и взаимодействие с базой данных».

Почему это важно

Понимание полного цикла запроса помогает отлаживать проблемы
Знание сетевых протоколов — основа веб-разработки
Умение объяснить процесс показывает глубину понимания

Вопрос 39. Как перенести изменения из одной ветки в другую без коммитов (hotfix в другую ветку)?

Таймкод: 00:45:55

Ответ собеседника: Правильный. Используется git stash для временного сохранения изменений.

Правильный ответ

Git Stash — временное сохранение изменений

Основные команды

# Сохранить изменения в stash
git stash
git stash save "описание изменений"

# Посмотреть список stash
git stash list

# Применить последний stash
git stash pop

# Применить конкретный stash
git stash apply stash@{2}

# Удалить stash
git stash drop stash@{0}
git stash clear  # удалить все

Сценарий: hotfix без коммитов

# Вы работаете в feature-ветке с незакоммиченными изменениями
git status
# modified:   main.go
# modified:   handler.go

# Нужно срочно переключиться на main для hotfix
git stash save "WIP: new feature"

# Переключаемся на main
git checkout main

# Делаем hotfix
git checkout -b hotfix/critical-bug
# ... вносим исправления ...
git add .
git commit -m "fix: critical bug"
git checkout main
git merge hotfix/critical-bug

# Возвращаемся к feature-ветке
git checkout feature/new-feature

# Восстанавливаем изменения
git stash pop

Cherry-pick — перенос конкретного коммита

Если изменения уже закоммичены:

# Перенести конкретный коммит в текущую ветку
git cherry-pick abc1234

# Перенести несколько коммитов
git cherry-pick abc1234 def5678

# Перенести без автоматического коммита
git cherry-pick --no-commit abc1234

Rebase — перенос ветки

# Перенести feature-ветку на актуальный main
git checkout feature/my-feature
git rebase main

# Интерактивный rebase для очистки истории
git rebase -i HEAD~5

Сравнение подходов

Команда	Когда использовать
`git stash`	Временно спрятать незакоммиченные изменения
`git cherry-pick`	Перенести конкретный коммит в другую ветку
`git rebase`	Перенести всю ветку на актуальную базу
`git merge`	Слить ветки с сохранением истории

Как ответить на собеседовании

> «Для переноса незакоммиченных изменений между ветками используется git stash. Команда git stash сохраняет текущие изменения в стек, после чего можно переключиться на другую ветку. После возвращения на исходную ветку изменения восстанавливаются через git stash pop. Если изменения уже закоммичены, можно использовать git cherry-pick для переноса конкретного коммита или git rebase для переноса всей ветки. Например, при hotfix я делаю stash, переключаюсь на main, создаю hotfix-ветку, коммитю исправление, мержу в main и возвращаюсь к своей работе».

Почему это важно

Stash — частая операция при работе с несколькими задачами
Cherry-pick полезен для backport-ов исправлений
Понимание этих команд показывает уверенное владение Git

Вопрос 40. В чём отличие merge от rebase?

Таймкод: 00:46:55

Ответ собеседника: Правильный. Отличия важные, но теоретических знаний может не хватать. Нужна практика.

Правильный ответ

Merge vs Rebase

Merge — слияние с сохранением истории

# Сливаем feature в main
git checkout main
git merge feature

Результат:

      A---B---C  feature
     /         \
D---E---F---G---H  main (merge commit)

Rebase — перенос коммитов

# Переносим feature на актуальный main
git checkout feature
git rebase main

Результат:

              A'--B'--C'  feature
             /
D---E---F---G  main

Сравнение

Характеристика	Merge	Rebase
История	Сохраняется вся	Линейная
Merge commit	Да	Нет
Безопасность	Безопасен	Опасен для публичных веток
Конфликты	Решаются один раз	Могут повторяться
Отмена	Легко (revert merge)	Сложно

Когда использовать Merge

Слияние feature-веток в main/develop
Когда важна полная история изменений
Для публичных веток

git checkout main
git merge --no-ff feature/my-feature

Когда использовать Rebase

Обновление feature-ветки от main
Очистка истории перед PR
Для локальных веток (не публичных!)

git checkout feature/my-feature
git rebase main
git push --force-with-lease

Интерактивный Rebase

# Объединить последние 3 коммита
git rebase -i HEAD~3

# В открывшемся редакторе:
pick abc1234 feat: add user model
squash def5678 fix: typo in user model
squash ghi9012 fix: another typo

# Результат: один коммит вместо трех

Золотое правило

> Никогда не делайте rebase публичных веток!

# ОПАСНО: rebase публичной ветки
git checkout main
git rebase feature  # ❌ Не делайте так!

# БЕЗОПАСНО: rebase локальной feature-ветки
git checkout feature
git rebase main  # ✅ Правильно

Решение конфликтов

# При merge
git merge feature
# CONFLICT in file.go
# Решаем конфликт
git add file.go
git commit

# При rebase
git rebase main
# CONFLICT in file.go
# Решаем конфликт
git add file.go
git rebase --continue

# Отмена rebase
git rebase --abort

Как ответить на собеседовании

> «Merge создаёт новый коммит слияния, сохраняя всю историю ветвления. Rebase переносит коммиты на другую базу, создавая линейную историю. Merge безопасен для любых веток, rebase — только для локальных. Я использую merge для слияния feature в main и rebase для обновления feature-веток от main перед PR. Важное правило: никогда не делайте rebase публичных веток, которые используют другие разработчики».

Почему это важно

Merge и rebase — основные операции в Git
Неправильное использование может сломать историю
Понимание различий показывает опыт работы с Git

Вопрос 1. Решал ли задачи на платформах вроде Codewars, LeetCode или других подобных сервисах?​

Вопрос 2. Какие фреймворки знаешь? Расскажи о своём опыте использования фреймворков.​

Вопрос 3. Когда пишешь код — делаешь так, чтобы просто работало, или пишешь обдуманно?​

Вопрос 4. С какими менеджерами задач работал?​

Вопрос 5. Расскажи о своём пути в разработку. Почему именно фронтенд?​

Вопрос 6. Приходилось ли писать тесты? Знаешь ли такое понятие как TDD/BDD?​

Вопрос 7. Как следишь за качеством кода? Какие инструменты используешь?​

Вопрос 8. Какой сборщик выберешь: Webpack или Vite?​

Вопрос 9. MobX или Redux — какой state-менеджер выбрать в React?​

Вопрос 10. Для чего нужен TypeScript?​

Вопрос 11. Что такое CI/CD?​

Вопрос 12. Какой опыт работы с Docker?​

Вопрос 13. В чём отличие Git Revert от Git Reset?​

Вопрос 14. Сталкивался ли с ревью кода? Как проходило ревью? По какому принципу бы сам проводил ревью?​

Вопрос 15. Приходилось ли работать в команде? Как была устроена работа с Git?​

Вопрос 16. Какие инструменты разработки используешь?​

Вопрос 17. Какие виды уязвимостей знаешь? Что такое XSS?​

Вопрос 18. Строки в JavaScript изменяемы или нет?​

Вопрос 19. Как проверить переменную на NaN?​

Вопрос 20. Передача параметров в функцию по ссылке или по значению?​

Вопрос 21. Как сделать глубокую копию объекта?​

Вопрос 22. Что такое прототипы в JavaScript?​

Вопрос 23. Что такое Node.js? Из чего он состоит?​

Вопрос 24. Какими способами можно обработать ошибку в промисе?​

Вопрос 25. Когда-нибудь приходило понимание, что нужно использовать Event Emitter?​

Вопрос 26. Что такое Event Loop?​

Вопрос 27. Что такое Set, Map, WeakSet, WeakMap?​

Вопрос 28. Как добавить интернационализацию в приложение?​

Вопрос 29. Что такое package-lock.json?​

Вопрос 30. Отличие ES5 и ES6.​

Вопрос 31. Если поставить таймер на 10 секунд, через сколько он сработает? Почему?​

Вопрос 32. Что такое замыкание в JavaScript?​

Вопрос 33. Что такое самовызывающаяся функция (IIFE)?​

Вопрос 34. Чем отличается протокол HTTP от HTTPS?​

Вопрос 35. Что такое CORS?​

Вопрос 36. Что такое REST API?​

Вопрос 37. Что такое reflow и repaint?​

Вопрос 38. Когда пользователь вводит запрос в адресной строке браузера или кликает на ссылку — что происходит?​

Вопрос 39. Как перенести изменения из одной ветки в другую без коммитов (hotfix в другую ветку)?​

Вопрос 40. В чём отличие merge от rebase?​

Вопрос 1. Решал ли задачи на платформах вроде Codewars, LeetCode или других подобных сервисах?

Вопрос 2. Какие фреймворки знаешь? Расскажи о своём опыте использования фреймворков.

Вопрос 3. Когда пишешь код — делаешь так, чтобы просто работало, или пишешь обдуманно?

Вопрос 4. С какими менеджерами задач работал?

Вопрос 5. Расскажи о своём пути в разработку. Почему именно фронтенд?

Вопрос 6. Приходилось ли писать тесты? Знаешь ли такое понятие как TDD/BDD?

Вопрос 7. Как следишь за качеством кода? Какие инструменты используешь?

Вопрос 8. Какой сборщик выберешь: Webpack или Vite?

Вопрос 9. MobX или Redux — какой state-менеджер выбрать в React?

Вопрос 10. Для чего нужен TypeScript?

Вопрос 11. Что такое CI/CD?

Вопрос 12. Какой опыт работы с Docker?

Вопрос 13. В чём отличие Git Revert от Git Reset?

Вопрос 14. Сталкивался ли с ревью кода? Как проходило ревью? По какому принципу бы сам проводил ревью?

Вопрос 15. Приходилось ли работать в команде? Как была устроена работа с Git?

Вопрос 16. Какие инструменты разработки используешь?

Вопрос 17. Какие виды уязвимостей знаешь? Что такое XSS?

Вопрос 18. Строки в JavaScript изменяемы или нет?

Вопрос 19. Как проверить переменную на NaN?

Вопрос 20. Передача параметров в функцию по ссылке или по значению?

Вопрос 21. Как сделать глубокую копию объекта?

Вопрос 22. Что такое прототипы в JavaScript?

Вопрос 23. Что такое Node.js? Из чего он состоит?

Вопрос 24. Какими способами можно обработать ошибку в промисе?

Вопрос 25. Когда-нибудь приходило понимание, что нужно использовать Event Emitter?

Вопрос 26. Что такое Event Loop?

Вопрос 27. Что такое Set, Map, WeakSet, WeakMap?

Вопрос 28. Как добавить интернационализацию в приложение?

Вопрос 29. Что такое package-lock.json?

Вопрос 30. Отличие ES5 и ES6.

Вопрос 31. Если поставить таймер на 10 секунд, через сколько он сработает? Почему?

Вопрос 32. Что такое замыкание в JavaScript?

Вопрос 33. Что такое самовызывающаяся функция (IIFE)?

Вопрос 34. Чем отличается протокол HTTP от HTTPS?

Вопрос 35. Что такое CORS?

Вопрос 36. Что такое REST API?

Вопрос 37. Что такое reflow и repaint?

Вопрос 38. Когда пользователь вводит запрос в адресной строке браузера или кликает на ссылку — что происходит?

Вопрос 39. Как перенести изменения из одной ветки в другую без коммитов (hotfix в другую ветку)?

Вопрос 40. В чём отличие merge от rebase?