Senior Go Interview Prep

- Core Go: https://go.vbloher.org/docs/01-core-go/
- Система типов Go: defined types, alignment, memory layout: https://go.vbloher.org/docs/01-core-go/type-system/
- Указатели в Go: https://go.vbloher.org/docs/01-core-go/pointers/
- Внутреннее устройство слайсов в Go: https://go.vbloher.org/docs/01-core-go/slices/
- Устройство map в Go: https://go.vbloher.org/docs/01-core-go/maps/
- Строки, руны и байты в Go: https://go.vbloher.org/docs/01-core-go/strings-runes-bytes/
- Интерфейсы в Go: https://go.vbloher.org/docs/01-core-go/interfaces/
- Встраивание структур и интерфейсов (Embedding): https://go.vbloher.org/docs/01-core-go/embedding/
- Ошибки в Go: error, wrapping, errors.Is/As/Join: https://go.vbloher.org/docs/01-core-go/errors/
- Механика defer в Go: https://go.vbloher.org/docs/01-core-go/defer/
- panic / recover: механика, раскрутка стека и runtime-паники: https://go.vbloher.org/docs/01-core-go/panic-recover/
- Замыкания и переменная цикла (Go 1.22): https://go.vbloher.org/docs/01-core-go/closures-loopvar/
- Дженерики в Go (1.18+): https://go.vbloher.org/docs/01-core-go/generics/
- encoding/json и теги структур: https://go.vbloher.org/docs/01-core-go/json-encoding/
- Рефлексия в Go (reflect): https://go.vbloher.org/docs/01-core-go/reflection/
- Модули, версионирование и зависимости: https://go.vbloher.org/docs/01-core-go/go-modules/
- Concurrency: https://go.vbloher.org/docs/02-concurrency/
- Горутины: жизненный цикл, стоимость, стек: https://go.vbloher.org/docs/02-concurrency/goroutines-lifecycle/
- Планировщик GMP: https://go.vbloher.org/docs/02-concurrency/scheduler-gmp/
- Каналы: устройство hchan: https://go.vbloher.org/docs/02-concurrency/channels/
- Буферизованные vs небуферизованные каналы: https://go.vbloher.org/docs/02-concurrency/buffered-unbuffered/
- select: https://go.vbloher.org/docs/02-concurrency/select/
- sync.WaitGroup: https://go.vbloher.org/docs/02-concurrency/waitgroup/
- sync.Mutex и sync.RWMutex: https://go.vbloher.org/docs/02-concurrency/mutex-rwmutex/
- sync/atomic: https://go.vbloher.org/docs/02-concurrency/atomic/
- sync.Once: https://go.vbloher.org/docs/02-concurrency/once/
- sync.Cond: https://go.vbloher.org/docs/02-concurrency/cond/
- sync.Map и sync.Pool: https://go.vbloher.org/docs/02-concurrency/sync-map-pool/
- errgroup: группа горутин с ошибкой и отменой: https://go.vbloher.org/docs/02-concurrency/errgroup/
- context: https://go.vbloher.org/docs/02-concurrency/context/
- Канал vs Mutex: когда что выбрать: https://go.vbloher.org/docs/02-concurrency/channel-vs-mutex/
- Паттерны конкурентности: https://go.vbloher.org/docs/02-concurrency/patterns/
- Утечки горутин, дедлоки, livelock, starvation: https://go.vbloher.org/docs/02-concurrency/common-leaks-deadlocks/
- Race Detector (гонки данных и -race): https://go.vbloher.org/docs/02-concurrency/race-detector/
- Runtime и память: https://go.vbloher.org/docs/03-runtime-memory/
- Стек vs Куча: где живут данные в Go: https://go.vbloher.org/docs/03-runtime-memory/stack-vs-heap/
- Escape Analysis: когда переменная убегает в кучу: https://go.vbloher.org/docs/03-runtime-memory/escape-analysis/
- Паттерны аллокаций и снижение давления на GC: https://go.vbloher.org/docs/03-runtime-memory/allocation-patterns/
- Сборщик мусора Go: concurrent tri-color mark-sweep: https://go.vbloher.org/docs/03-runtime-memory/gc/
- Тюнинг GC: GOGC и GOMEMLIMIT: https://go.vbloher.org/docs/03-runtime-memory/gogc-gomemlimit/
- GOMAXPROCS: параллелизм планировщика и проблема контейнеров: https://go.vbloher.org/docs/03-runtime-memory/gomaxprocs/
- Модель памяти Go (Go Memory Model): happens-before и синхронизация: https://go.vbloher.org/docs/03-runtime-memory/memory-model/
- Утечки памяти в Go (несмотря на GC): https://go.vbloher.org/docs/03-runtime-memory/memory-leaks/
- Утечки горутин (goroutine leaks): https://go.vbloher.org/docs/03-runtime-memory/goroutine-leaks/
- pprof: профилирование CPU, памяти и блокировок в Go: https://go.vbloher.org/docs/03-runtime-memory/pprof/
- Execution Tracer и runtime/trace: тайминги вместо агрегатов: https://go.vbloher.org/docs/03-runtime-memory/runtime-tracing/
- Тестирование: https://go.vbloher.org/docs/04-testing/
- Table-driven тесты, subtests и параллельность: https://go.vbloher.org/docs/04-testing/table-driven/
- testify, assert/require и golden files: https://go.vbloher.org/docs/04-testing/assertions-testify/
- Моки, стабы и тестируемость: https://go.vbloher.org/docs/04-testing/mocks/
- Покрытие, -race и флаки-тесты: https://go.vbloher.org/docs/04-testing/coverage-race/
- Бенчмарки в Go: https://go.vbloher.org/docs/04-testing/benchmarks/
- Нативный fuzzing в Go (1.18+): https://go.vbloher.org/docs/04-testing/fuzzing/
- Интеграционные тесты, testcontainers-go, TestMain: https://go.vbloher.org/docs/04-testing/integration-testcontainers/
- Backend: https://go.vbloher.org/docs/05-backend/
- Структура Go-проекта: https://go.vbloher.org/docs/05-backend/project-layout/
- net/http: Server, Handler, ServeMux, таймауты, Client и контекст: https://go.vbloher.org/docs/05-backend/net-http/
- Middleware-паттерн в Go: https://go.vbloher.org/docs/05-backend/middleware/
- REST: принципы, версионирование, идемпотентность, статусы, пагинация, ошибки: https://go.vbloher.org/docs/05-backend/rest/
- OpenAPI/Swagger, code generation, contract-first vs code-first, валидация: https://go.vbloher.org/docs/05-backend/openapi/
- gRPC: типы RPC, интерсепторы, контекст, метаданные, error model: https://go.vbloher.org/docs/05-backend/grpc/
- Protocol Buffers: схемы, wire format, эволюция и совместимость: https://go.vbloher.org/docs/05-backend/protobuf/
- Аутентификация и авторизация: AuthN/AuthZ, сессии vs токены, RBAC/ABAC, API keys, mTLS, секреты: https://go.vbloher.org/docs/05-backend/auth-authz/
- JWT (JSON Web Token): https://go.vbloher.org/docs/05-backend/jwt/
- OAuth2: роли, grant types, OIDC, токены и типовые ошибки: https://go.vbloher.org/docs/05-backend/oauth2/
- Graceful Shutdown HTTP/gRPC сервера в Go: https://go.vbloher.org/docs/05-backend/graceful-shutdown/
- Чистая архитектура и внедрение зависимостей в Go: https://go.vbloher.org/docs/05-backend/clean-architecture/
- Сети и протоколы: https://go.vbloher.org/docs/06-networking/
- TCP/IP: модель, транспорт и что важно бэкендеру: https://go.vbloher.org/docs/06-networking/tcp-ip/
- UDP и надёжность поверх UDP: https://go.vbloher.org/docs/06-networking/udp/
- DNS: записи, резолвинг, кэширование, DNS в Go: https://go.vbloher.org/docs/06-networking/dns/
- Версии HTTP: 1.1, 2, 3: https://go.vbloher.org/docs/06-networking/http-versions/
- TLS: handshake, сертификаты, mTLS, производительность: https://go.vbloher.org/docs/06-networking/tls/
- WebSocket: upgrade, фреймы, масштабирование: https://go.vbloher.org/docs/06-networking/websocket/
- Пулы соединений: http.Transport, БД, утечки: https://go.vbloher.org/docs/06-networking/connection-pooling/
- Базы данных: https://go.vbloher.org/docs/07-databases/
- Архитектура PostgreSQL: https://go.vbloher.org/docs/07-databases/postgresql-architecture/
- Транзакции в PostgreSQL и Go (database/sql, pgx): https://go.vbloher.org/docs/07-databases/transactions/
- Уровни изоляции транзакций в PostgreSQL: https://go.vbloher.org/docs/07-databases/isolation-levels/
- MVCC в PostgreSQL: версии строк, видимость, VACUUM и bloat: https://go.vbloher.org/docs/07-databases/mvcc/
- Индексы в PostgreSQL: https://go.vbloher.org/docs/07-databases/indexes/
- Планирование и оптимизация запросов в PostgreSQL: https://go.vbloher.org/docs/07-databases/query-planning/
- Взаимоблокировки (Deadlocks) в PostgreSQL: https://go.vbloher.org/docs/07-databases/deadlocks/
- Пул соединений к PostgreSQL в Go: database/sql, pgx, pgxpool, PgBouncer: https://go.vbloher.org/docs/07-databases/connection-pooling-pgx/
- Партиционирование таблиц в PostgreSQL: https://go.vbloher.org/docs/07-databases/partitioning/
- Репликация в PostgreSQL: https://go.vbloher.org/docs/07-databases/replication/
- Шардирование (горизонтальное масштабирование): https://go.vbloher.org/docs/07-databases/sharding/
- Обзор NoSQL и Redis: https://go.vbloher.org/docs/07-databases/nosql-redis/
- Распределённые системы: https://go.vbloher.org/docs/08-distributed-systems/
- CAP теорема: https://go.vbloher.org/docs/08-distributed-systems/cap-theorem/
- Модели согласованности: https://go.vbloher.org/docs/08-distributed-systems/consistency/
- Eventual Consistency: https://go.vbloher.org/docs/08-distributed-systems/eventual-consistency/
- Идемпотентность в распределённых системах: https://go.vbloher.org/docs/08-distributed-systems/idempotency/
- Ретраи: backoff, jitter, budgets и идемпотентность: https://go.vbloher.org/docs/08-distributed-systems/retries/
- Circuit Breaker: https://go.vbloher.org/docs/08-distributed-systems/circuit-breaker/
- Гарантии доставки сообщений: at-most-once / at-least-once / exactly-once: https://go.vbloher.org/docs/08-distributed-systems/delivery-guarantees/
- Transactional Outbox: https://go.vbloher.org/docs/08-distributed-systems/outbox/
- Saga Pattern: https://go.vbloher.org/docs/08-distributed-systems/saga/
- Apache Kafka: https://go.vbloher.org/docs/08-distributed-systems/kafka/
- RabbitMQ: AMQP 0-9-1, маршрутизация, надёжность доставки и сравнение с Kafka: https://go.vbloher.org/docs/08-distributed-systems/rabbitmq/
- Консенсус и Raft: репликация состояния в присутствии отказов: https://go.vbloher.org/docs/08-distributed-systems/consensus-raft/
- Observability: https://go.vbloher.org/docs/09-observability/
- Метрики: RED, USE, Golden Signals: https://go.vbloher.org/docs/09-observability/metrics/
- Структурированное логирование (slog): https://go.vbloher.org/docs/09-observability/structured-logging/
- Distributed Tracing: https://go.vbloher.org/docs/09-observability/tracing/
- OpenTelemetry: https://go.vbloher.org/docs/09-observability/opentelemetry/
- Prometheus: https://go.vbloher.org/docs/09-observability/prometheus/
- Grafana: https://go.vbloher.org/docs/09-observability/grafana/
- SLI / SLO / SLA: https://go.vbloher.org/docs/09-observability/slo-sli/
- System Design: https://go.vbloher.org/docs/10-system-design/
- Фреймворк System Design интервью: https://go.vbloher.org/docs/10-system-design/framework/
- URL Shortener: https://go.vbloher.org/docs/10-system-design/url-shortener/
- Rate Limiter: https://go.vbloher.org/docs/10-system-design/rate-limiter/
- Chat System: https://go.vbloher.org/docs/10-system-design/chat/
- Notification Service: https://go.vbloher.org/docs/10-system-design/notification-service/
- Order Service: https://go.vbloher.org/docs/10-system-design/order-service/
- Payment Service: https://go.vbloher.org/docs/10-system-design/payment-service/
- Analytics Pipeline: https://go.vbloher.org/docs/10-system-design/analytics-pipeline/
- DevOps: https://go.vbloher.org/docs/11-devops/
- Docker для Go-разработчика: https://go.vbloher.org/docs/11-devops/docker/
- Kubernetes для Go-разработчика: https://go.vbloher.org/docs/11-devops/kubernetes/
- CI/CD: пайплайны, стадии, стратегии деплоя: https://go.vbloher.org/docs/11-devops/cicd/
- GitHub Actions и GitLab CI: https://go.vbloher.org/docs/11-devops/github-gitlab-ci/
- Terraform / Infrastructure as Code: https://go.vbloher.org/docs/11-devops/terraform/
- Облака (AWS / GCP) для бэкендера: https://go.vbloher.org/docs/11-devops/cloud-aws-gcp/
- Алгоритмы: https://go.vbloher.org/docs/12-algorithms/
- Асимптотическая сложность (Big-O): https://go.vbloher.org/docs/12-algorithms/complexity/
- Структуры данных в Go: https://go.vbloher.org/docs/12-algorithms/data-structures/
- Типовые алгоритмические задачи и паттерны: https://go.vbloher.org/docs/12-algorithms/common-problems/
- Специфика live-coding на Go: https://go.vbloher.org/docs/12-algorithms/go-specifics/
- Behavioral: https://go.vbloher.org/docs/13-behavioral/
- Как проходит senior-интервью: этапы, оценка, оффер: https://go.vbloher.org/docs/13-behavioral/interview-flow/
- Типовые поведенческие вопросы для Senior: https://go.vbloher.org/docs/13-behavioral/senior-questions/
- Конфликты, разногласия и работа со стейкхолдерами: https://go.vbloher.org/docs/13-behavioral/conflicts/
- Лидерство и менторство: https://go.vbloher.org/docs/13-behavioral/leadership-mentoring/


# encoding/json и теги структур
> Модуль: Core Go · Уровень: Middle+/Senior

## TL;DR
`encoding/json` отображает структуры Go в JSON через рефлексию, ориентируясь на **экспортируемые** поля и теги вида `json:"name,omitempty"`. При разборе неизвестные поля молча игнорируются (если не включён `DisallowUnknownFields`), а отсутствующее поле оставляет в структуре нулевое значение — отличить «не пришло», «пришло null» и «пришёл ноль» можно только указателем, `json.RawMessage` или отдельным флагом. `omitempty` опускает только «пустые» значения базовых типов, nil-указатели, пустые слайсы/мапы/строки, но **не** пустые структуры и не `time.Time` — для этого в Go 1.24 появился `omitzero`. Числа при разборе в `any` становятся `float64` (лечится `json.Decoder.UseNumber`), `[]byte` кодируется в base64, `time.Time` — в RFC 3339. Кастомное поведение задаётся `MarshalJSON`/`UnmarshalJSON` или `encoding.TextMarshaler`.

## Простыми словами

`encoding/json` превращает структуры Go в JSON и обратно, а управляется это тегами — строчками в обратных кавычках рядом с полями.

```go
type User struct {
    ID        int       `json:"id"`
    Name      string    `json:"name"`
    Email     string    `json:"email,omitempty"` // пропустить, если пусто
    passwordH string                              // не экспортируется — не попадёт в JSON вообще
    Internal  string    `json:"-"`                // явно исключено
}
```

Два правила, которые надо усвоить сразу. Первое: **сериализуются только поля с большой буквы**. Поле с маленькой буквы пакет `json` просто не видит — не по злому умыслу, а потому что для него оно недоступно. Второе: при разборе **лишние поля молча игнорируются**, а недостающие оставляют в структуре нулевое значение. Никаких ошибок не будет.

Отсюда вытекает главная практическая головная боль: отличить «поле не прислали», «прислали `null`» и «прислали 0» по обычному `int` невозможно — во всех трёх случаях там окажется ноль. Для операций частичного обновления это критично, и лечится указателем (`*int`): `nil` значит «не прислали», а указатель на ноль — «прислали ноль».

**Если ты с другого языка.** Аннотаций и настраиваемых мапперов уровня Jackson здесь нет — есть теги и, при необходимости, свои методы. Регистр имеет значение: приватное поле не сериализуется никак, обойти это рефлексией штатными средствами нельзя. Зато при разборе Go по умолчанию нечувствителен к регистру ключей, что иногда удивляет в обратную сторону.

**Словарь этой статьи:**

- **struct tag** — строка метаданных рядом с полем, которую читают библиотеки через рефлексию;
- **`omitempty`** — опустить поле, если значение «пустое»;
- **`json.RawMessage`** — отложенный кусок JSON, который разберут позже;
- **маршалинг / анмаршалинг** — кодирование в JSON и разбор из JSON.

## Теория

### Правила отображения

| Go | JSON |
|---|---|
| `struct` | объект (только экспортируемые поля) |
| `map[string]T` | объект (ключи сортируются) |
| `[]T` | массив; `nil`-слайс → `null`, пустой → `[]` |
| `[]byte` | строка в base64 |
| `time.Time` | строка RFC 3339 |
| `int`, `float64` | число |
| указатель | значение или `null` |
| `any` при разборе | `float64`, `string`, `bool`, `[]any`, `map[string]any`, `nil` |

Два пункта из этой таблицы стабильно всплывают в багах: `nil`-слайс превращается в `null`, а не в `[]` (фронтенд к такому обычно не готов), и любое число, разобранное в `any`, становится `float64` — на больших `int64` это теряет точность.

```go
// nil vs пустой слайс
var a []int
b := []int{}
json.Marshal(a) // null
json.Marshal(b) // []

// числа в any
var v any
json.Unmarshal([]byte(`{"id": 12345678901234567890}`), &v) // float64, точность потеряна

// лечение
d := json.NewDecoder(r)
d.UseNumber() // числа станут json.Number — строкой, которую можно разобрать точно
```

### Теги: полный синтаксис

```go
type Order struct {
    ID       string    `json:"id"`                    // переименование
    Total    int       `json:"total,omitempty"`       // опустить, если 0
    Note     string    `json:"-"`                     // никогда не сериализовать
    Dash     string    `json:"-,"`                    // поле с именем "-" (редкий трюк)
    Count    int       `json:"count,string"`          // число как строка в JSON
    Meta     any       `json:",omitempty"`            // имя по умолчанию (Meta), но с omitempty
}
```

Опция `,string` полезна при работе с языками, где большие целые числа не переживают JSON (JavaScript теряет точность после 2^53).

### omitempty и его границы

`omitempty` опускает поле, если значение — «пустое»: `false`, `0`, `""`, `nil`-указатель/интерфейс, пустой слайс, мапа или массив.

Чего он **не** делает:

```go
type Response struct {
    User    User      `json:"user,omitempty"`    // структура НИКОГДА не опускается
    When    time.Time `json:"when,omitempty"`    // time.Time — структура, тоже не опускается
}
```

Пустая структура — не «пустое значение» с точки зрения пакета, поэтому в JSON уедет `"user":{}` и `"when":"0001-01-01T00:00:00Z"`. Классические обходы: указатель на структуру (`*User`) или собственный `MarshalJSON`.

В Go 1.24 добавили опцию **`omitzero`**, которая проверяет именно нулевое значение типа и умеет спрашивать у типа метод `IsZero()`:

```go
type Response struct {
    When time.Time `json:"when,omitzero"` // теперь пропускается, если время нулевое
}
```

### Отсутствие, null и ноль

Самая частая архитектурная проблема при частичном обновлении (`PATCH`):

```go
type UpdateUser struct {
    Name  *string `json:"name"`  // nil = не прислали, &"" = прислали пустую строку
    Email *string `json:"email"`
}

if u.Name != nil {
    // поле пришло — обновляем, даже если пустое
}
```

Указатель различает два состояния из трёх («не пришло» и «пришло значение»), но не отличает `null` от отсутствия — в обоих случаях будет `nil`. Если нужны все три, берут `json.RawMessage` или структуру-обёртку с флагом:

```go
type Optional[T any] struct {
    Value T
    Set   bool   // поле присутствовало в JSON
    Null  bool   // и было равно null
}
```

### Свои правила кодирования

```go
type Money struct {
    Cents int64
}

func (m Money) MarshalJSON() ([]byte, error) {
    return json.Marshal(fmt.Sprintf("%d.%02d", m.Cents/100, m.Cents%100))
}

func (m *Money) UnmarshalJSON(b []byte) error {
    var s string
    if err := json.Unmarshal(b, &s); err != nil {
        return err
    }
    // ...разбор строки в центы
    return nil
}
```

Два правила: `MarshalJSON` объявляют на значении (иначе он не сработает для не-указателей), `UnmarshalJSON` — обязательно на указателе (иначе будет менять копию).

Для простых типов часто достаточно `encoding.TextMarshaler`/`TextUnmarshaler` — их дополнительно используют для ключей мапы и другие пакеты (`encoding/xml`, драйверы БД).

Ловушка бесконечной рекурсии:

```go
func (u User) MarshalJSON() ([]byte, error) {
    return json.Marshal(u) // рекурсия до переполнения стека!
}

// правильно — через тип-псевдоним без методов:
func (u User) MarshalJSON() ([]byte, error) {
    type alias User                      // у alias нет метода MarshalJSON
    return json.Marshal(alias(u))
}
```

### Строгий разбор

По умолчанию разбор всеядный: неизвестные поля игнорируются, регистр ключей не важен (`"name"` попадёт в поле с тегом `"Name"`). Для API это часто плохо — опечатка клиента остаётся незамеченной.

```go
d := json.NewDecoder(r.Body)
d.DisallowUnknownFields()
if err := d.Decode(&req); err != nil {
    // теперь лишнее поле — это ошибка
}
```

Для HTTP-хендлеров это же место, где ограничивают размер тела:

```go
r.Body = http.MaxBytesReader(w, r.Body, 1<<20) // 1 МБ
```

Без ограничения любой клиент может прислать гигабайтный JSON и выесть память сервера.

### Потоковая обработка

`json.Marshal` собирает весь результат в память. Для больших ответов и для последовательности объектов есть `Encoder`/`Decoder`:

```go
enc := json.NewEncoder(w)
for _, item := range items {
    enc.Encode(item)   // пишет прямо в ответ, по объекту за раз
}

dec := json.NewDecoder(r)
for dec.More() {
    var item Item
    dec.Decode(&item)  // разбирает поток, не держа всё в памяти
}
```

`Encoder.Encode` добавляет перевод строки после каждого объекта — это ровно формат JSON Lines, удобный для логов и потоковых API.

### Производительность

`encoding/json` работает через рефлексию, но кэширует разбор структуры типа: план кодирования строится один раз на тип и переиспользуется. Тем не менее это заметно медленнее ручного кода.

Практические ориентиры:

- переиспользуй `Encoder`/`Decoder` вместо `Marshal`/`Unmarshal` в горячих путях, чтобы не создавать промежуточные буферы;
- `json.RawMessage` откладывает разбор части документа — полезно, когда нужен только один ключ из большого тела;
- если профиль показывает, что сериализация стала узким местом, есть альтернативы: `bytedance/sonic` (JIT), `goccy/go-json`, кодогенераторы вроде `easyjson`. Но сначала — измерить;
- в Go 1.25 появился экспериментальный `encoding/json/v2` (включается через `GOEXPERIMENT=jsonv2`) с более строгим и более быстрым API. В прод его пока не тащат, но знать о его существовании полезно.

## Подводные камни / gotchas

- **Неэкспортируемые поля не сериализуются.** Никогда, ни с каким тегом.
- **`nil`-слайс даёт `null`.** Инициализируй `[]T{}`, если контракт обещает массив.
- **Числа в `any` — это `float64`.** Большие `int64` теряют точность; лечится `UseNumber()` или конкретным типом.
- **`omitempty` не работает для структур и `time.Time`.** Нужен указатель или `omitzero` (Go 1.24+).
- **Разбор нечувствителен к регистру ключей.** `{"NAME":"x"}` попадёт в поле с тегом `json:"name"`.
- **Ошибка в теге не заметна.** `json:"name, omitempty"` (с пробелом) — тег с именем `name` и опцией `" omitempty"`, которая не сработает. `go vet` это ловит.
- **`MarshalJSON` на указателе** не вызовется, если сериализуешь значение. Объявляй на значении.
- **Рекурсия в `MarshalJSON`** при вызове `json.Marshal` на том же типе.
- **Тело запроса без ограничения размера** — способ уронить сервис по памяти.
- **`json.Marshal` экранирует HTML** (`<`, `>`, `&` → `<`...) по умолчанию. Отключается через `Encoder.SetEscapeHTML(false)`.

## Вопросы на собеседовании

**В:** Как отличить «поле не прислали» от «прислали нулевое значение»?
**О:** Через указатель: `nil` означает отсутствие, ненулевой указатель — присланное значение, в том числе нулевое. Если нужно отличать ещё и явный `null`, берут `json.RawMessage` или обёртку с флагами присутствия.

**В:** Почему поле не попало в JSON?
**О:** Три типовые причины: поле неэкспортируемое, стоит тег `json:"-"`, или сработал `omitempty` на пустом значении.

**В:** Что происходит с неизвестными полями при разборе?
**О:** По умолчанию они игнорируются. Чтобы получать ошибку, нужен `Decoder.DisallowUnknownFields()`.

**В:** Почему `omitempty` не сработал на `time.Time`?
**О:** Потому что это структура, а `omitempty` не считает пустую структуру «пустым значением». Решения: указатель `*time.Time`, свой `MarshalJSON` или опция `omitzero` в Go 1.24+.

**В:** Во что превращается число при разборе в `any` и почему это опасно?
**О:** В `float64`. Целые числа больше 2^53 теряют точность, поэтому для идентификаторов это недопустимо. Лечится разбором в конкретный тип или `Decoder.UseNumber()`.

**В:** Как переопределить сериализацию своего типа?
**О:** Реализовать `MarshalJSON() ([]byte, error)` на значении и `UnmarshalJSON([]byte) error` на указателе. Для простых типов часто достаточно `encoding.TextMarshaler`, который заодно работает для ключей мапы и в других пакетах.

**В:** Чем `Decoder` лучше `Unmarshal` в HTTP-хендлере?
**О:** Он читает из потока, не требуя держать всё тело в памяти, позволяет включить строгий режим и обработать последовательность объектов. Дополнительно тело стоит ограничить `http.MaxBytesReader`.

**В:** Как `encoding/json` работает под капотом и почему он не самый быстрый?
**О:** Через рефлексию: пакет обходит поля типа, читает теги и строит план кодирования, кэшируя его по типу. Рефлексия не инлайнится и аллоцирует, отсюда отставание от кодогенерации и JIT-реализаций.

## На что копают на senior+

- Проектирование API поверх ограничений пакета: как выражается частичное обновление, что отдавать вместо `null` в массивах, как версионировать контракт.
- Понимание источника поведения: всё завязано на рефлексию и теги, отсюда и требование экспортируемости, и стоимость.
- Безопасность разбора: ограничение размера тела, строгий режим, отсутствие доверия к клиентскому вводу.
- Знание отличий `omitempty` и `omitzero` и умение объяснить, почему потребовалась вторая опция.
- Follow-up: «Как сериализовать интерфейс и разобрать обратно?» (нужен дискриминатор типа и ручной разбор через `RawMessage`), «Почему ключи мапы сортируются?» (детерминированный вывод), «Когда переходить на кодогенерацию?».