❓ Как функция в Go возвращает несколько значений

Типы возвращаемых значений перечисляются в круглых скобках после списка аргументов, а в return передаются сами значения через запятую:

func calculateStats(numbers []int) (int, int, float64) {
    sum, max := 0, numbers[0]
    for _, n := range numbers {
        sum += n
        if n > max {
            max = n
        }
    }
    avg := float64(sum) / float64(len(numbers))
    return sum, max, avg
}

🐸 Библиотека Go для собеса

❓ Какой самый распространённый паттерн множественного возврата

Пара значение и ошибка. Функция возвращает результат и error, который вызывающий код обязан проверить. Это основа идиоматичной обработки ошибок в Go.

func divide(a, b int) (int, error) {
    if b == 0 {
        return 0, errors.New("деление на ноль")
    }
    return a / b, nil
}

🐸 Библиотека Go для собеса

❓ Что такое голый return и когда он опасен

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

🐸 Библиотека Go для собеса

❓ Чем Handler отличается от HandlerFunc

Handler это интерфейс с одним методом ServeHTTP(ResponseWriter, *Request). HandlerFunc это тип функции, у которого метод ServeHTTP уже реализован и просто вызывает саму функцию. Он нужен как адаптер, чтобы обычную функцию можно было отдать туда, где ждут интерфейс.

mux.Handle("/ping", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
  w.Write([]byte("pong"))
}))

🐸 Библиотека Go для собеса

❓ Как работает iota в блоке констант

iota начинает с нуля в начале блока const и увеличивается на единицу для каждой новой строки. После присвоения значения переменной, можно не указывать iota снова для следующих переменных, и Go самостоятельно применит инкремент.

const (
    A = iota
    B
    C
    D
)
// A = 0, B = 1, C = 2, D = 3

Важно помнить, что iota применяется только внутри блока const. Если создать второй блок const, то счетчик снова начинает с нуля. Каждый блок независим.

🐸 Библиотека Go для собеса

❓ Почему http.ListenAndServe(":8080", nil) считается плохой практикой

nil означает DefaultServeMux, глобальный роутер. В него может зарегистрировать хендлер любой импортированный пакет, например net/http/pprof делает это в init. Так наружу случайно утекают отладочные ручки.

У такого сервера нет тайм аутов. Правильнее создать свой Server и свой ServeMux.

Правильный вариант:

srv := &http.Server{
  Addr:              ":8080",
  Handler:           mux,
  ReadHeaderTimeout: 5 * time.Second,
  ReadTimeout:       10 * time.Second,
  WriteTimeout:      10 * time.Second,
  IdleTimeout:       120 * time.Second,
}
log.Fatal(srv.ListenAndServe())

🐸 Библиотека Go для собеса

❓ Что означает гарантия «фиксеры не должны менять поведение вашей программы»

Это про автоматические исправления кода — фиксеры (например, go fix, gofmt, suggested fixes из go vet / analysis-фреймворка, или --fix в линтерах вроде golangci-lint). Гарантия говорит, что такой фикс меняет только форму кода, но не его поведение во время выполнения.

Под поведением тут понимается наблюдаемая семантика: что программа возвращает, какие у неё сайд-эффекты — запись в файл, вызовы по сети, вывод, — как идёт control flow, какие ошибки и паники она порождает. То есть на тех же входных данных до и после фикса программа должна давать тот же результат и те же эффекты. Трансформация behavior-preserving, семантически нейтральная.

Пример: фиксер может переписать устаревший API на новый, переставить импорты через goimports, отформатировать код — но не должен, скажем, изменить условие в if так, что поменяется ветвление.

И тут ключевой момент — формулировка «should not», а не «will not». Это заявленное свойство по дизайну, а не строгая гарантия на все случаи. В Go, где есть интерфейсы, рефлексия, горутины и гонки, всегда найдётся пограничный кейс, где формально эквивалентная замена всё же меняет смысл. Поэтому на практике фиксы обычно делят на safe и unsafe: safe можно катить массово, unsafe применяют осознанно.

🐸 Библиотека Go для собеса

❓ Нужно ли создавать новый http.Client на каждый запрос

Нет. Client и его Transport безопасны для конкурентного использования и держат пул TCP соединений. Новый клиент на каждый запрос убивает keep alive, каждый вызов будет заново устанавливать соединение вместе с TLS рукопожатием.

Правильно создать один клиент на приложение и задать ему тайм аут, потому что у http.DefaultClient его нет.

🐸 Библиотека Go для собеса

❓ Освободится ли память после bigSlice = bigSlice[:5]

Нет, не обязательно. Операция [:5] создаёт новый слайс-заголовок с длиной 5, но он по-прежнему указывает на тот же самый underlying array. Пока хотя бы один слайс ссылается на этот массив, сборщик мусора не может его освободить. То есть даже если нам нужны первые 5 байт, за спиной может «висеть» все 10 MB:

Дело в том, что срез — это лишь тройка из указателя на массив, длины и ёмкости. Урезание длины меняет только заголовок и никак не влияет на память под ним. Capacity нового слайса по-прежнему указывает на конец исходного массива, поэтому GC считает его достижимым.

Чтобы отдать большой массив сборщику, нужные данные копируют в новый, компактный слайс, а ссылку на исходный обнуляют:

smallCopy := make([]byte, len(smallSlice))
copy(smallCopy, smallSlice)
bigSlice = nil

Тот же эффект короче — через append в nil-слайс, который выделит свежий массив под реальный объём данных:

smallCopy := append([]byte(nil), smallSlice...)

🐸 Библиотека Go для собеса

❓ Как отличить отсутствующий ключ от нулевого значения в мапе

Через второй возвращаемый параметр при обращении к мапе — так называемый comma-ok. Обычное чтение v := m[key] всегда вернёт значение: если ключа нет, это будет нулевое значение типа (0 для чисел, "" для строк, nil для указателей).

А значит, по одному только v нельзя понять, лежал ли там реальный ноль или ключа просто не было:

m := map[string]int{"a": 0}

v := m["a"] // 0 — но ключ есть
v = m["b"]  // 0 — а ключа нет

Форма с двумя переменными решает это: второе значение — булев флаг, который равен true, только если ключ действительно присутствует в мапе. Именно на него и нужно смотреть, а не на само значение:

v, ok := m["a"]
if ok {
    // ключ есть, v — реальное значение (даже если это 0)
}

_, ok = m["b"] // ok == false, ключа нет

Отсюда типичный идиоматичный паттерн — проверка и использование в одном if:

if v, ok := m[key]; ok {
    // работаем с v
}

🐸 Библиотека Go для собеса

❓ Как узнать, что канал закрыт

Обычное v := <-ch из закрытого канала не заблокируется и не паникует, а сразу вернёт нулевое значение типа.

Поэтому по одному v нельзя отличить «пришёл реальный ноль» от «канал закрыт и пуст — ровно как с мапой:

v := <-ch // 0 — но это может быть и настоящее значение, и признак закрытия

Второй параметр решает вопрос: флаг ok равен true, пока из канала можно прочитать отправленное значение, и становится false, когда канал закрыт и в нём не осталось буферизованных данных.

Важно, что закрытый канал сначала отдаёт всё, что в него успели записать, и только потом начинает возвращать false:

v, ok := <-ch
if !ok {
    // канал закрыт и пуст
}

На практике за приёмом из канала обычно стоит range, который сам корректно завершается при закрытии — отдельная проверка ok не нужна:

for v := range ch {
    // выполняется, пока канал не закрыт и не пустой
}

❓Как узнать, сколько элементов лежит в канале

Функция len(ch) возвращает количество элементов, которые сейчас лежат в буфере канала. Функция cap(ch) возвращает вместимость буфера, то есть сколько элементов канал может хранить, не блокируя отправителя.

Пример с буферизированным каналом:

ch := make(chan int, 5)
ch <- 1
ch <- 2

fmt.Println(len(ch)) // 2
fmt.Println(cap(ch)) // 5

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

ch := make(chan int)

fmt.Println(len(ch)) // 0
fmt.Println(cap(ch)) // 0

Значение len(ch) это снимок состояния на конкретный момент. Пока вы читаете результат и что-то с ним делаете, другая горутина уже могла записать или забрать элемент.

🐸 Библиотека Go для собеса