💡 Хватит считать индексы вручную

stringscut — это статический анализатор из пакета golang.org/x/tools/go/analysis. Он находит устаревшие паттерны с strings.Index и предлагает заменить их на strings.Cut, который появился в Go 1.18.

Раньше, чтобы разбить строку по разделителю, писали так:

idx := strings.Index(s, substr)
if idx >= 0 {
    return s[:idx]
}

Это работает, но здесь несколько проблем. Нужно держать в голове индекс, вручную считать срезы и помнить, что >= 0 означает «нашли». Это читается медленно и легко ломается при рефакторинге.

Паттерн 1. Разбивка строки по разделителю

До:

idx := strings.Index(s, substr)
if idx >= 0 {
    return s[:idx]
}

После:

before, _, ok := strings.Cut(s, substr)
if ok {
    return before
}

strings.Cut сразу возвращает часть до разделителя, часть после и булев флаг. Не нужно возиться с индексами.

Паттерн 2. Простая проверка наличия подстроки

До:

idx := strings.Index(s, substr)
if idx >= 0 {
    return
}

После:

found := strings.Contains(s, substr)
if found {
    return
}

Если индекс нигде не используется, анализатор предлагает strings.Contains. Это честнее читается и сразу видно намерение.

Анализатор обрабатывает не только strings.Index, но и:

• strings.IndexByte для поиска по одному байту
• пакет bytes. Те же паттерны, но для []byte

Автоматическая замена предлагается только если между определением и использованием idx, s или substr нет никаких изменений этих переменных. Если где-то в середине idx переопределяется или s мутирует, анализатор промолчит. Это осознанное решение, чтобы не ломать логику.

📍 Навигация: Вакансии • Задачи • Собесы

🐸 Библиотека Go-разработчика

#GoToProduction

🔄 Патчи с исправлениями безопасности

Вчера вышли Go 1.26.2 и 1.25.9. Релизы закрывают 10 дыр безопасности.

Ключевые проблемы

В Linux Root.Chmod мог выйти за root по симлинку, если цель меняли в процессе. Html/template неверно отслеживал контекст в JS-литералах с ветками и действиями, открывая XSS. Crypto/x509 игнорировал DNS-констрейнты для wildcard с разным регистром, плюс DoS от кучи intermediates или policy mappings.

сmd/compile пропускал overlap check в no-op конверсиях интерфейсов и bound check для индексов с overflow. Archive/tar жрал память на старом GNU sparse с тонной регионов; ввели лимиты. Crypto/tls 1.3 зависал на нескольких key update в record, DoS.

сmd/go позволял SWIG обходить trust с именами файлов; запретили такие имена.

➡️ Источник

📍 Навигация: Вакансии • Задачи • Собесы

🐸 Библиотека Go-разработчика

#GoLive

👀 maps.Equal медленнее reflect.DeepEqual

В Go есть два способа сравнить два map: maps.Equal из стандартной библиотеки и reflect.DeepEqual. Первый появился в Go 1.21 как типобезопасная замена второму. Логично предположить, что он и работает быстрее. Но это не так: по крайней мере в одном конкретном сценарии.

Что показывает бенчмарк:

var m = map[string]int{
    "alpha": 1, "beta": 2, "gamma": 3,
    "delta": 4, "epsilon": 5, "zeta": 6,
    "eta": 7, "theta": 8, "iota": 9,
    "kappa": 10,
}

func BenchmarkMapsEqual_SameMap(b *testing.B) {
    for i := 0; i < b.N; i++ {
        _ = maps.Equal(m, m) // передаём один и тот же map дважды
    }
}

func BenchmarkReflectDeepEqual_SameMap(b *testing.B) {
    for i := 0; i < b.N; i++ {
        _ = reflect.DeepEqual(m, m)
    }
}

Результаты на Go 1.25:

BenchmarkMapsEqual_SameMap-12                    4172912               292.3 ns/op             0 B/op          0 allocs/op
BenchmarkReflectDeepEqual_SameMap-12            10414143               111.3 ns/op             0 B/op          0 allocs/op

reflect.DeepEqual быстрее, хотя оба получают один и тот же указатель.

reflect.DeepEqual делает проверку в самом начале: если оба аргумента указывают на один и тот же объект, функция сразу возвращает true. Это классическая оптимизация идентичности: один == по указателю, и готово.

maps.Equal такой проверки не делает. Он всегда итерируется по всем ключам первой мапы и сверяет их значения со второй. Даже если оба аргумента одна и та же мапа.

📍 Навигация: Вакансии • Задачи • Собесы

🐸 Библиотека Go-разработчика

#GoDeep

💪 Топ-вакансий для Go-разработчиков за неделю

Middle Go-Developer — удаленно

Junior Golang — 100 000 ₽, гибрид в Москве

Senior Golang Developer — до 450 000 ₽, гибрид в Санкт-Петербурге

Бустер — удалённо по всему миру

➡️ Еще больше топовых вакансий — в нашем канале Go jobs

🐸 Библиотека Go-разработчика

#GoWork

⚡️ Логирование с уровнями для Go

Когда в проекте на Go растёт количество сервисов или усложняется бизнес-логика, стандартного log пакета начинает не хватать. Нет уровней серьёзности, нет гибкого управления verbosity, нет нормального разделения потоков вывода. Приходится либо городить обёртки, либо тащить тяжёлые зависимости.

glog это портированная на Go реализация логирования из C++ библиотеки glog, которую Google использует внутри. Пакет поддерживает уровни логирования, запись в файлы, управление verbosity через флаги и фильтрацию по файлам.

Что умеет

Четыре уровня серьёзности: Info, Warning, Error, Fatal. Плюс форматированные варианты: Infof, Errorf и так далее. Fatal после вывода сообщения вызывает os.Exit(1).

Отдельно есть V-логирование — способ включать детальные логи только там, где нужно, без изменения кода:

if glog.V(2) {
    glog.Info("Starting transaction...")
}

glog.V(2).Infoln("Processed", nItems, "elements")

Флаг -v=2 при запуске включает все вызовы с уровнем 2 и ниже. Если нужно точечно включить логи только в конкретном файле, используется -vmodule:

./myapp -vmodule=service=3,handler=1

Здесь service.go будет логировать на уровне 3, а handler.go на уровне 1.

Как подключить:

go get github.com/golang/glog

Минимальный пример:

package main

import (
    "flag"
    "github.com/golang/glog"
)

func main() {
    flag.Parse()
    defer glog.Flush()

    glog.Info("Сервис запущен")
    glog.Warningf("Свободной памяти мало: %d MB", 128)
    glog.Error("Не удалось подключиться к базе")
}

Важный момент: flag.Parse() нужно вызвать до любого лога, иначе флаги не применятся. glog.Flush() в defer гарантирует, что буферизованные записи попадут в файл перед завершением программы.

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

./myapp -logtostderr

Или в оба места сразу:

./myapp -alsologtostderr

Если нужна современная замена с поддержкой структуривоанного логирования, стоит смотреть в сторону zap или slog из стандартной библиотеки Go 1.21+. Для задач, где достаточно уровней и файлового вывода без лишних зависимостей, glog справляется хорошо.

➡️ Репозиторий

📍 Навигация: Вакансии • Задачи • Собесы

🐸 Библиотека Go-разработчика

#GoToProduction

🧑‍💻 Эмулятор AWS-сервисов

Kumo — это небольшой инструмент на Go для локальной имитации AWS-сервисов. Он помогает разработчикам тестировать приложения без облака.

Проект подходит для unit-тестов, где нужен мок для облачных вызовов. Устанавливается через go install github.com/sivchari/kumo@latest. Запускается как прокси, а SDK настраивается на локальный эндпоинт.

Поддерживает базовые операции над S3: создание бакетов, загрузку объектов, список файлов. Для DynamoDB эмулирует таблицы, put/get item. Конфиг через флаги или env.

➡️ Репозиторий

📍 Навигация: Вакансии • Задачи • Собесы

🐸 Библиотека Go-разработчика

#GoLive

🛠 ECS на Go

Entity Component System (ECS) это архитектурный паттерн, популярный в геймдеве и симуляциях. Идея простая: вместо объектов с данными и поведением используются сущности без данных, компоненты с данными и системы/запросы, которые обрабатывают сущности с нужным набором компонентов.

Ark это архетипная реализация ECS для Go. Архетипный подход означает, что сущности с одинаковым набором компонентов хранятся вместе в памяти, что максимизирует локальность данных при итерации.

Что внутри

Типобезопасный API с дженериками, никакого interface{} и рефлексии в горячих путях. Отношения между сущностями как first-class feature. Система событий с фильтрацией. Batch-операции для массовых изменений. Сериализация мира через ark-serde. Ноль внешних зависимостей, 100% покрытие тестами.

Никаких встроенных систем, только запросы. Структуру приложения выбираем сами, или используем ark-tools со scheduler'ом:

world := ecs.NewWorld()
mapper := ecs.NewMap2[Position, Velocity](world)
filter := ecs.NewFilter2[Position, Velocity](world)

query := filter.Query()
for query.Next() {
    pos, vel := query.Get()
    pos.X += vel.DX
    pos.Y += vel.DY
}

Свежий релиз v0.8.0

7 апреля вышла v0.8.0 с заметными изменениями. Добавлена итерация по таблицам, которая даёт примерно двукратное ускорение по сравнению с обычной итерацией:

for query.NextTable() {
    positions, velocities := query.GetColumns()
    for i := range positions {
        pos, vel := &positions[i], &velocities[i]
        pos.X += vel.X
        pos.Y += vel.Y
    }
}

Также очистка памяти компонентов через memclrNoHeapPointers вместо обнуления вручную, перемещение нетривиальных компонентов стало быстрее на 30% за счёт typedmemmove вместо рефлексии, добавлены регрессионные бенчмарки для сравнения PR с main-веткой.

➡️ Репозиторий

📍 Навигация: Вакансии • Задачи • Собесы

🐸 Библиотека Go-разработчика

#GoToProduction

❓ Что выведет код с картинки

strings.ContainsAny проверяет, содержит ли строка хотя бы один символ из набора. Но что происходит, когда оба аргумента пустые строки?

Подсказка: загляни в документацию к функции и обрати внимание на крайние случаи.

Ответ: в нашем канале с задачами

📍 Навигация: Вакансии • Задачи • Собесы

🐸 Библиотека Go-разработчика

#ReadySetGo

⚙️ Компилятор Go строит типы и ловит циклические зависимости

Go 1.26 принёс незаметное, но важное изменение в type checker. Команда Go опубликовала подробный разбор того, как именно компилятор конструирует типы и обнаруживает циклические зависимости.

Как устроена конструкция типов

Когда компилятор встречает объявление типа, он строит внутреннее дерево структур. Для простого случая:

type T []U
type U *int

Всё линейно: сначала строится T, внутри неё []U, внутри неё U, внутри неё *int. Каждый тип становится «завершённым» когда все его поля заполнены и все зависимые типы тоже завершены. Процесс идёт вглубь и разматывается обратно.

Рекурсивные типы

С рекурсией интереснее:

type T []U
type U *T

Здесь T встречается пока ещё строится. Компилятор просто ставит указатель на незавершённый T и движется дальше, рассчитывая что T завершится позже. Когда конструкция доходит до конца, весь "цикл" типов завершается одновременно.

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

type T [unsafe.Sizeof(T{})]int

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

В Go 1.26 переписали подход: вместо сложной bespoke-логики для каждого случая, компилятор теперь отслеживает неполные значения систематически. В каждом месте где может возникнуть значение неполного типа, вставлена проверка:

if !isComplete(T) {
    reportCycleErr(T)
    return invalid
}

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

➡️ Блог разработчиков

📍 Навигация: Вакансии • Задачи • Собесы

🐸 Библиотека Go-разработчика

#GoDeep

💡 Замените счётчики на итераторы

В Go давно есть идиоматичный способ обходить коллекции: range. Но многие стандартные типы исторически предлагали только Len() и At(i), и код превращался в ручной счётчик. Анализатор stditerators из golang.org/x/tools находит такие места и предлагает замену.

Типичный паттерн, который можно встретить в Go-проекте:

for i := 0; i < x.Len(); i++ {
    use(x.At(i))
}

Это работает, но многословно. Появились итераторы: метод All() у ряда стандартных типов возвращает iter.Seq, по которому можно пройтись через range. stditerators находит старые конструкции и предлагает переписать их вот так:

for elem := range x.All() {
    use(elem)
}

Анализатор понимает оба варианта счётчика — классический for i := 0; i < x.Len(); i++ и более новый for i := range x.Len().

Что покрывает

Анализатор работает с конкретными типами из стандартной библиотеки, у которых уже есть метод All(). Это не универсальный «переписыватель» для всего подряд, а точечный инструмент с заранее известным списком поддерживаемых типов.

Как запустить:

go install golang.org/x/tools/gopls@latest

Или через go vet с плагином:

go run golang.org/x/tools/go/analysis/passes/stditerators/cmd/stditerators@latest ./...

В большинстве редакторов с gopls анализатор подсветит проблемное место прямо в коде и предложит автоматический фикс.

📍 Навигация: Вакансии • Задачи • Собесы

🐸 Библиотека Go-разработчика

#GoToProduction

📍 Навигация: Вакансии • Задачи • Собесы

🐸 Библиотека Go-разработчика

#GoGiggle

🤩 Дайджест недели

Что прошло уже не вернуть, но стоит ознакомиться с нашей подборкой прошедшей недели.

— oaswrap/spec v0.4.0

— Патчи с исправлениями безопасности

— Эмулятор AWS-сервисов

— Entity Component System на Go

📍 Навигация: Вакансии • Задачи • Собесы

🐸 Библиотека Go-разработчика

#GoLive