Что изменилось в Go: от 1.18 до 1.25

Можно писать обобщённые функции и типы: одна реализация для любого типа. Это убирает копипаст в контейнерах и утилитах. Цена — сложность чтения: применяйте дженерики там, где дублирование реально повторяется, а не «на всякий случай».

func Map[T, U any](s []T, f func(T) U) []U {
    out := make([]U, 0, len(s))
    for _, v := range s {
        out = append(out, f(v))
    }
    return out
}

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

func FuzzParse(f *testing.F) {
    f.Add("[]byte{1, 2}")
    f.Fuzz(func(t *testing.T, data []byte) {
        Parse(data) // упадёт — fuzzer сохранит вход в testdata
    })
}

Пустой интерфейс теперь можно писать как any — короче и читается как «любой тип». В остальном поведение не изменилось.

Вместо ручного atomic.AddInt64(&counter, 1) появились готовые типы atomic.Int64, atomic.Bool, atomic.Pointer[T]. Читать их можно обычным обращением — типобезопасно и без гонок.

var hits atomic.Int64

hits.Add(1)
fmt.Println(hits.Load())

arena.Arena позволяет выделять и освобождать пачку объектов разом. Эксперимент (GOEXPERIMENT=arenas), в обычном коде не нужен: GC в Go и так умеет собирать короткоживущие объекты.

Ошибки из нескольких источников (валидация полей, параллельные запросы) складываются в одну, а errors.Is находит любую из них. Раньше приходилось придумывать свой тип ошибки.

if err := validate(req); err != nil {
    return errors.Join(err, ctx.Err())
}

Срез можно превратить в массив или указатель на массив: a := (*[4]byte)(b). Это удобно для системных вызовов вроде unix.Read, которые требуют фиксированный буфер.

buf := make([]byte, 4)
n, err := unix.Read(fd, (*[4]byte)(buf))

Новые функции для работы с памятью без копирования. Полезно в высокопроизводительном коде и в обёртках над syscall, но требует понимания, что данные не меняются и живут дольше вызова.

Частые операции переехали в стандартную библиотеку: slices.Sort, slices.Contains, slices.Clip, maps.Keys, maps.Values. Код становится короче, а поведение — предсказуемым (keys возвращает слайс в случайном порядке — сортируйте, если нужен порядок).

slices.Sort(users)
slices.SortFunc(users, func(a, b User) int { return a.Name < b.Name })
keys := slices.Sorted(maps.Keys(m))

min(a, b), max(a, b) и clear(map) — без импорта и без аллокаций. Для срезов clear(s) обнуляет элементы, но сохраняет ёмкость.

Стандартный структурированный логгер: ключи и значения, уровни, JSON-вывод. Можно уйти с самописных логгеров на стандартную библиотеку и не тянуть зависимость.

slog.Info("order created",
    "order_id", id,
    "amount", amount,
)

В go.mod появилась директива toolchain: можно указать минимальную версию Go, и сборка сама подтянет нужный компилятор. Команда из разных версий перестаёт ломать сборку.

Самый обсуждаемый релиз Go. Раньше переменная цикла была одна на весь цикл, поэтому её часто ловили горутины (классическая утечка указателя). Теперь каждая итерация получает свою переменную — старый код работает корректно, а знание об этом стоит перепроверить.

for _, v := range values {
    go func() { process(v) }() // теперь v — своя на итерацию
}

Стандартный сервер умеет разбирать путь с параметрами: mux.HandleFunc("GET /items/{id}", h) и r.PathValue("id"). Для простых сервисов теперь не нужен внешний роутер.

mux := http.NewServeMux()
mux.HandleFunc("GET /items/{id}", func(w http.ResponseWriter, r *http.Request) {
    id := r.PathValue("id")
})

Раньше неиспользованный time.Timer удерживал объекты до срабатывания. Теперь таймеры, которые никто не ждёт, собираются сборщиком мусора — меньше утечек в сервисах с таймаутами.

for i := range 10 { ... } — цикл по числам без переменной-счётчика. Мелкая, но приятная деталь: код становится ближе к математической записи.

for i := range 10 {
    fmt.Println(i)
}

Итерируемые последовательности: можно писать свои конвейеры и ленивые структуры. Появился пакет iter с типами Seq и функциями, чтобы такие итераторы выглядели одинаково у всех.

func Count(n int) iter.Seq[int] {
    return func(yield func(int) bool) {
        for i := 0; i < n; i++ {
            if !yield(i) {
                return
            }
        }
    }
}

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

Теперь можно писать type MyMap[K comparable, V any] = map[K]V. Полезно для алиасов сложных обобщённых типов в публичных API.

Ограничивает работу с файловой системой каталогом-корнем: путь не выйдет за пределы папки, даже если в нём есть «..». Защита от path traversal в сервисах, которые принимают пути от пользователя.

root, err := os.OpenRoot("/var/data")
defer root.Close()

f, err := root.Open("uploads/1.txt")

AddCleanup — современная замена runtime.SetFinalizer: объект можно «освободить» детерминированно, когда он больше не нужен. Слабые ссылки позволяют не мешать сборщику мусора удерживать объект.

Карты переписаны на алгоритм швейцарских таблиц: меньше памяти и быстрее операции с большими картами. Изменение внутреннее — API не изменился, но бенчмарки на map стали заметно лучше.

Новый цикл бенчмарков: b.Loop() сам разгоняет тест, убирает ручную настройку b.N и корректнее работает с таймерами. Меньше шансов написать бенчмарк, который ничего не измеряет.

Вместо wg.Add(1); go func() { defer wg.Done(); ... }() теперь есть wg.Go(func() { ... }). Меньше шансов забыть Done и словить панику negative WaitGroup counter.

var wg sync.WaitGroup
for _, job := range jobs {
    wg.Go(func() { process(job) })
}
wg.Wait()

Пакет позволяет тестировать код с горутинами детерминированно: виртуальное время, никаких sleep и никаких флаки-тестов. Тесты конкурентного кода перестают быть лотереей.

func TestTimeout(t *testing.T) {
    synctest.Test(t, func(t *testing.T) {
        // виртуальное время: минута пройдёт мгновенно
    })
}

В контейнере Go учитывает лимиты CPU: GOMAXPROCS подстраивается под cgroup, а не под число ядер хоста. Сервис в лимите 2 CPU больше не создаёт планировщик на 64 ядра.

Новый алгоритм сборки мусора (эксперимент) снижает накладные расходы на сборку и уменьшает задержки. Включается через GOEXPERIMENT, в продакшене пока осторожно.