Четыре группы типов:

• Базовые - bool, строки, числовые (int, uint, float, complex), их псевдонимы byte и rune.
• Составные - array и struct: фиксированный размер, элементы лежат подряд.
• Дескрипторные (их и называют «ссылочными») - slice, map, chan, func, указатель *T.
• Интерфейсные - any и именованные интерфейсы: два слова (тип + данные).

Присвоил или передал в функцию: значение копируется побитово. Для struct и array копируются все данные, и получаются два независимых объекта. Для слайса копируется заголовок из трёх слов (ptr/len/cap), для мапы и канала - указатель на hmap/hchan, поэтому данные остаются общими.

type P struct {
    X int
}
a := P{1}; b := a; b.X = 9
// a.X == 1 - копия независима

s1 := []int{1, 2, 3}; s2 := s1; s2[0] = 9
// s1[0] == 9 - общий массив

arr1 := [3]int{1, 2, 3}; arr2 := arr1; arr2[0] = 9
// arr1[0] == 1 - массив копируется целиком

Размер int/uint/uintptr совпадает с машинным словом: 8 байт на amd64, arm64 и wasm, 4 байта на 386 и arm. Проверить: strconv.IntSize или unsafe.Sizeof(int(0)).

Смешивать нельзя даже при равном размере: компилятор потребует явной конверсии. Совместимость определяет тип, а не представление. На практике: в протоколах и БД фиксируй int64/int32, а int оставь для индексов, длин и внутренних счётчиков.

Переполнение

Ни знаковое, ни беззнаковое переполнение не паникует: это арифметика по модулю 2^N. Компилятор ловит только константное.

var i int8 = 127; i++            // -128
var u uint8 = 0;  u--            // 255

// Ловушка №1: обратный цикл по uint
for i := uint(3); i >= 0; i-- {  // бесконечный: uint всегда >= 0
}

// Ловушка №2: разность беззнаковых
var a, b uint = 2, 5
fmt.Println(a - b)               // 18446744073709551613

// Ловушка №3: проверка переполнения после операции
c := math.MaxInt64
c++                              // уже -9223372036854775808
if c < 0 { /* поздно, но так обычно и ловят */ }

Как правильно проверять переполнение

// знаковые - руками:
func addSafe(a, b int64) (int64, error) {
    if (b > 0 && a > math.MaxInt64-b) || (b < 0 && a < math.MinInt64-b) {
        return 0, errors.New("overflow")
    }
    return a + b, nil
}
// сейчас для беззнаковых есть math/bits:
sum, carry := bits.Add64(x, y, 0)   // carry == 1 при переполнении

0 для чисел, false для bool, "" для строк, nil для указателей, функций, интерфейсов, слайсов, мап и каналов; для массивов и структур - рекурсивно нулевые элементы/поля.

Почему так сделано

• Убирает класс UB из C: чтение мусора со стека невозможно.
• Можно проектировать типы, готовые к работе «из коробки»: var mu sync.Mutex, var buf bytes.Buffer, var wg sync.WaitGroup - все валидны без конструктора.
• Упрощает JSON/десериализацию: отсутствующее поле = нулевое значение.

Цена и подводные камни

• Неотличимо «не задано» от «задано нулём». Классика: omitempty выбросит false и 0, хотя пользователь их явно прислал. Помогают указатели (*bool) или sql.NullXxx / собственный тип с флагом.
• nil-мапа читается, но не пишется: паника assignment to entry in nil map.
• nil-канал блокирует навсегда (иногда это полезно: так «выключают» ветку в select).

var m map[string]int
fmt.Println(m["x"], len(m))  // 0 0 - чтение ок
m["x"] = 1                   // panic: assignment to entry in nil map

var s []int
s = append(s, 1)             // ок: append работает и с nil-слайсом

var ch chan int
<-ch                         // висит навсегда (deadlock, если спят все горутины)

Объявлены через =, то есть это те же самые типы под другим именем, а не новые типы. Поэтому var b byte = uint8(5) компилируется без конверсии.

Go хранит строки в UTF-8. По индексу получишь байт, а range по строке выдаст руну и её байтовое смещение. Это главный источник ошибок с не-ASCII текстом.

s := "Go♥"
fmt.Println(len(s))                    // 5: 'G','o' по 1 байту, '♥' - 3 байта
fmt.Printf("%T\n", s[0])               // uint8
for i, r := range s {
    fmt.Printf("%d:%c(%d) ", i, r, r)  // 0:G(71) 1:o(111) 2:♥(9829)
}
fmt.Println(utf8.RuneCountInString(s)) // 3
rs := []rune(s)                        // аллоцирует 3 × 4 = 12 байт
fmt.Println(len(rs))                   // 3

Единственное «неявное» поведение - нетипизированные константы, которые подстраиваются под контекст. Всё остальное требует T(v).

Аргументы, которые стоит назвать

1. Читаемость. Глядя на int64(x) * y, ты сразу видишь и стоимость, и намерение. В C всё это прошло бы молча.
2. Именованные типы как защита. type UserID int64 и type OrderID int64 нельзя перепутать, компилятор поймает. С неявными приведениями от этой защиты ничего не остаётся.
3. Нет signed/unsigned сюрпризов. В C при сравнении int с unsigned первое продвигается в беззнаковое, отсюда классические уязвимости.
4. Простота спецификации. Меньше правил - меньше расхождений между компиляторами и меньше кейсов на ревью.

Что конверсия всё же делает молча

// От константы такие конверсии не скомпилируются,
// компилятор ловит их ещё при сборке:
//   int8(300)   → constant 300 overflows int8
//   int(2.99)   → cannot convert 2.99 (untyped float constant) to type int
//   uint(-1)    → constant -1 overflows uint

// А вот от переменной те же конверсии проходят молча:
var a int32 = 300
var b float64 = 2.99
var c int = -1

fmt.Println(int8(a))   // 44   - старшие биты отрезаны молча
fmt.Println(int(b))    // 2    - обрезает, а не округляет
fmt.Println(int(-b))   // -2   - к нулю, а не «вниз»
fmt.Println(uint(c))   // 18446744073709551615

string(65)         // "A"  - go vet ругается: подозрительная конверсия int→string
string([]byte{65}) // "A"  - а так правильно

const (
    A = iota      // 0
    B             // 1  - выражение "iota" унаследовано
    C             // 2
)
const (
    D = iota      // 0 - новый блок, счётчик сброшен
)

// iota считает строки, а не константы:
const (
    X, Y = iota, iota * 10   // X=0, Y=0
    Z, W                     // Z=1, W=10
)

Идиомы

// 1) Перечисление статусов, строки для них сгенерирует stringer
type Status int
const (
    StatusUnknown Status = iota
    StatusPending
    StatusDone
)
//go:generate stringer -type=Status

// 2) Размеры
const (
    _  = iota
    KB = 1 << (10 * iota)   // 1024
    MB                       // 1048576
)

// 3) Битовые маски
type Flag uint
const (
    FlagRead Flag = 1 << iota
    FlagWrite
    FlagExec
)

// 4) Пропуск ненужных значений
const (
    _ = iota
    First   // 1 - чтобы zero value означал "не задано"
    Second
)

1. Нет провала. Тело case отработало, switch закончился. Явный fallthrough передаёт управление в тело следующего case, не проверяя его условие, и обязан быть последним оператором в case.
2. break не нужен для выхода из case. Внутри цикла break выйдет из switch, а чтобы прервать цикл, нужна метка.
3. Любые типы: строки, структуры (если comparable), не только целые.
4. Несколько значений в одном case: case "a", "b":.
5. Switch без выражения - эквивалент switch true, идиоматичная замена лестнице if / else if.
6. Инициализатор: switch v, err := f(); {, область видимости ограничена switch.
7. Type switch: switch v := i.(type) - только по интерфейсам. Внутри каждого case v получает свой конкретный тип; в case с несколькими типами v остаётся интерфейсом.
8. Порядок проверки - сверху вниз, первый совпавший case побеждает (в отличие от C, где switch может компилироваться в jump table и порядок не важен).

switch v := x.(type) {
case nil:
    fmt.Println("nil интерфейс")
case int, int64:
    fmt.Printf("целое, но v тут ещё any: %T\n", v)
case fmt.Stringer:
    fmt.Println(v.String())   // v уже fmt.Stringer
default:
    fmt.Printf("%T\n", v)
}

switch {                      // без выражения
case n < 0:  return "neg"
case n == 0: return "zero"
default:     return "pos"
}

switch n {
case 1:
    fmt.Println("один")
    fallthrough               // безусловно выполнит тело case 2
case 2:
    fmt.Println("два")
}
// при n == 1 вывод:
// один
// два

for i := 0; i < 3; i++ {
    switch i {
    case 1:
        break            // выходит из switch, НЕ из цикла
    }
    fmt.Print(i)
}

Отличия от переменных

• Вычисляются компилятором; в бинарнике их «нет», они подставлены в места использования.
• Нельзя взять адрес: &MaxSize - ошибка компиляции.
• Могут быть только базовых типов: булев, строковый, числовой. Нельзя const s = []int{1} или const t = time.Now().
• Не участвуют в escape analysis и не создают аллокаций.

Нетипизированные константы

Константа без явного типа хранится как «идеальное» значение произвольной точности (спецификация требует минимум 256 бит мантиссы) и приобретает тип только там, где используется: по правилу «тип по умолчанию» или по контексту.

const c = 1 << 100          // ок, пока не присвоено переменной
fmt.Println(c >> 98)        // 4

const half = 1 / 2          // 0 - целочисленное деление констант
const halfF = 1.0 / 2       // 0.5 - одна из констант вещественная

var f float64 = 3           // 3 подстроится под float64
var d time.Duration = 5     // ок: нетипизированная 5 станет Duration
var n int = 5
// var d2 time.Duration = n // ошибка: int → Duration неявно нельзя

// Типы по умолчанию, если контекста нет:
x := 42        // int
y := 4.2       // float64
z := 'a'       // rune (int32)
s := "hi"      // string
b := true      // bool

Comparable

• Comparable: числа, строки, bool, указатели, каналы, интерфейсы, массивы из comparable, структуры из comparable.
• Не comparable: slice, map, func и всё, что их содержит. Сравнение с nil для них разрешено, друг с другом - нет.
• Только comparable-типы могут быть ключами мапы, это то же ограничение.

type A struct {
    X int
    S string
}        // comparable
type B struct {
    Items []int
}            // не comparable
_ = A{1,"a"} == A{1,"a"}                // true
// _ = B{} == B{}                       // compile error

// С интерфейсным полем структура comparable, но в рантайме может запаниковать:
type C struct {
    V any
}
_ = C{1} == C{1}                        // true
_ = C{[]int{1}} == C{[]int{1}}          // panic: comparing uncomparable type []int

Выравнивание

Каждое поле кладётся по адресу, кратному его выравниванию (обычно = размеру: int64→8, int32→4, bool→1). Между полями появляется padding. Размер структуры округляется вверх до кратного максимальному выравниванию её полей, чтобы в []T все элементы были выровнены.

type Bad struct {           // 24 байта
    a bool                  // 1 + 7 padding
    b int64                 // 8
    c bool                  // 1 + 7 padding (добивка до кратного 8)
}
type Good struct {          // 16 байт
    b int64                 // 8
    a bool                  // 1
    c bool                  // 1 + 6 padding
}
unsafe.Sizeof(Bad{})        // 24
unsafe.Sizeof(Good{})       // 16
unsafe.Alignof(Bad{})       // 8
unsafe.Offsetof(Bad{}.b)    // 8

Когда это реально важно

• Структура живёт миллионами экземпляров (кэш, индекс в памяти, элементы большого слайса). Тогда −33 % размера дают и меньше давления на GC, и лучшую локальность в L1/L2.
• False sharing в конкурентном коде: два часто изменяемых поля попадают в одну 64-байтовую кэш-линию, ядра начинают гонять её друг у друга. Лечат вручную: padding или [64]byte-заполнитель между полями.

Анонимные структуры

• Табличные тесты - самый частый и самый идиоматичный случай.
• Одноразовый JSON на входе или выходе хендлера, когда тип не нужен в домене.
• Множества: map[string]struct{}, где значение занимает 0 байт.
• Сигнальные каналы: chan struct{}, где важен только факт события.
• Группировка полей внутри конфига: DB struct{ Host string; Port int } прямо в структуре Config.

cfg := struct {
    Host string
    Port int
}{"localhost", 8080}

var payload struct {
    Email string `json:"email"`
}
if err := json.NewDecoder(r.Body).Decode(&payload); err != nil { ... }

Анонимные функции (литералы функций)

• Замыкания захватывают переменные окружения по ссылке на переменную.
• defer с логикой: defer func(){ ... }().
• Горутины: go func(){ ... }().
• Функциональные опции: func WithTimeout(d time.Duration) Option { return func(c *Client){ c.timeout = d } }.
• Middleware: обёртка, возвращающая http.Handler.
• Немедленный вызов ограничивает область видимости переменных.

// функциональные опции: на собесах по архитектуре их спрашивают чаще всего
type Option func(*Server)

func WithTimeout(d time.Duration) Option { return func(s *Server) { s.timeout = d } }
func WithLogger(l *slog.Logger) Option   { return func(s *Server) { s.log = l } }

func New(addr string, opts ...Option) *Server {
    s := &Server{addr: addr, timeout: 5 * time.Second}
    for _, o := range opts { o(s) }
    return s
}