Как мигрировать Go лайфхаки: от старого кода к идиоматическому Go

Миграция кода на Go — это не просто механическая замена синтаксиса. Часто это процесс рефакторинга, направленный на избавление от устаревших паттернов, заимствованных из других языков, и принятие идиоматических для Go подходов. В этой статье мы рассмотрим конкретные "лайфхаки" — приемы, которые помогут превратить старый, неоптимальный или небезопасный Go-код в чистый, эффективный и соответствующий духу языка.

Первый и самый частый случай — работа со срезами (slices) и картами (maps). Старый код часто грешит избыточными аллокациями. Лайфхак: предварительно выделять емкость (capacity). Если вы знаете ожидаемый размер среза, выделяйте память сразу. Это радикально снижает нагрузку на сборщик мусора из-за повторных копирований при расширении.

// Старый подход (плохо):
var items []string
for i := 0; i < 10000; i++ {
 items = append(items, fmt.Sprintf("item-%d", i)) // Многократные реаллокации
}

// Новый, идиоматический подход (хорошо):
items := make([]string, 0, 10000) // Выделяем память под 10000 элементов сразу
for i := 0; i < 10000; i++ {
 items = append(items, fmt.Sprintf("item-%d", i)) // Добавление в уже выделенную память
}

То же самое для карт: `make(map[string]int, expectedSize)`. Это простой, но мощный лайфхак для повышения производительности.

Вторая большая тема — обработка ошибок. Старый код может пытаться минимизировать количество строк с `if err != nil`, что приводит к запутанным цепочкам. Лайфхак миграции: не бояться явной обработки ошибок, но структурировать код так, чтобы успешный путь был виден четко. Используйте ранние возвраты (early returns).

// Запутанный старый подход:
func processFile(path string) error {
 file, err := os.Open(path)
 if err == nil {
 defer file.Close()
 data, err := io.ReadAll(file)
 if err == nil {
 result, err := parseData(data)
 if err == nil {
 return saveResult(result)
 }
 }
 }
 return err // Какая именно ошибка?!
}

// Идиоматический Go с ранними возвратами:
func processFile(path string) error {
 file, err := os.Open(path)
 if err != nil {
 return fmt.Errorf("open file: %w", err)
 }
 defer file.Close()

 data, err := io.ReadAll(file)
 if err != nil {
 return fmt.Errorf("read file: %w", err)
 }

 result, err := parseData(data)
 if err != nil {
 return fmt.Errorf("parse data: %w", err)
 }

 if err := saveResult(result); err != nil {
 return fmt.Errorf("save result: %w", err)
 }
 return nil
}

Оборачивание ошибок (`%w`) — еще один критически важный лайфхак для миграции, появившийся в Go 1.13. Он создает цепочку ошибок, которую можно распутать с помощью `errors.Is` и `errors.As`.

Третий лайфхак касается конкурентности. Старый код может злоупотреблять низкоуровневыми примитивами вроде `sync.Mutex` там, где достаточно каналов или `sync.WaitGroup`. А может быть наоборот: создавать сложные системы на каналах для простых задач. При миграции оценивайте задачу: для передачи данных и сигналов завершения — каналы и `context.Context`. Для защиты общего ресурса — мьютексы (`sync.RWMutex` для частого чтения). Для ожидания завершения группы горутин — `sync.WaitGroup`.

// Старый, небезопасный подход с глобальной переменной:
var counter int
var mu sync.Mutex
func increment() {
 mu.Lock()
 counter++
 mu.Unlock()
}

// Часто лучший подход при миграции - инкапсулировать состояние и канал:
type Counter struct {
 value int
 ch  chan int
}
func NewCounter() *Counter {
 c := &Counter{ch: make(chan int)}
 go c.run() // Запускаем горутину-обработчик
 return c
}
func (c *Counter) run() {
 for delta := range c.ch {
 c.value += delta
 }
}
func (c *Counter) Increment() { c.ch