Привет, Хабр!

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

Речь пойдёт о:

• полезностях для конкурентного программирования

• приёмах в Go в целом, таких как использование iota, работа с ошибками, вывод интерфейса и т.д.

• методах оптимизации работы со слайсами

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

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

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

Поехали уже!

Полезные штуки для конкурентного программирования

Связка цикла for и select

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

func(s *sub) loop() {
  // ... определяем изменеяемое состояние ...
  for {
      // ... задаем каналы для  разных случаев ...
      select {
          case <-c1: // прочитать из канала без сохранения в переменную
           // ... прочитать/записать состояние ...
          case с2 <- x: // записать в канал
           // ... прочитать/записать состояние ...        
          case y := <-c3: // прочитать из канала в переменную
           // ... прочитать/записать состояние ...
      }
  }
}

Как видно, в этом нашем select мы обрабатываем все возможные случаи:

• если значение может быть прочитано из канала без сохранения в переменную

• если значение переменной может быть записано в канал

• если значение может быть прочитано из канала и сохранено в переменную

Поскольку цикл for бесконечный, оператор select будет выбирать один из случаев и выполнять соответствующий код. Затем цикл повторяется, и процесс повторяется снова.

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

Служебный канал, канал для ответа (chan chan error)

Когда мы используем горутины, проверка завершения выполнения по булеву флагу может привести к гонке данных. Состояние гонки можно увидеть при помощи go build -race main.go. Чтобы этого избежать создадим канал, передающий канал.

type sub struct {
  closing chan chan error // запрос ответ
}
// использование
func (s *sub) Close() {
  errChan = make(chan error)
  s.closing <- errChan
  return <-errChan
}
// Обработка сигнала закрытия в loop
func (s *sub) loop() {
  // ...
  var err error // задается когда в произошла ошибка во время выполнения основной работы
  for {
    select {
      case errChan := <-s.closing: // проверяем есть ли сигнал на завершение работы
        errChan <- err // вернем ошибку через предоставленный канал, может быть nil или объект error
        close(s.updates) // закрываем канал пересылки для данных в основную горутину
        return // завершим работу loop()
    }
  }
 // ...
}

Выглядит достаточно странно, канал с каналом ошибок. Эта конструкция позволяет сделать двунаправленный обмен между горутинами. Мы передаем канал через который vs можем вернуть ответ. Метод loop() это как небольшой сервер, и чтобы его остановить мы даем ему запрос на прекращение работы - пишем значение в канал sub.closing, в канал мы передаем канал в который сервер поместит ответ, когда закончит работу. В случае штатной остановки в канале будет nil, иначе канал вернет error.

Преимущества всей этой конструкции очевидны:

1. Синхронизация: при помощи каналов мы синхронизируем выполнение горутин, обеспечивая правильный порядок выполнения операций и предотвращая состояние гонки.

2. Безопасность: использование каналов обеспечивает безопасность доступа к данным при параллельном выполнении операций. Каналы гарантируют, что только одна горутина может получить доступ к данным в определенный момент времени.

3. Управление ошибками: каналы позволяют нам передавать информацию об ошибках между горутинами, что позволяет эффективно обрабатывать ошибки.

nil-каналы в выражениях select для временной приостановки

Если мы хотим отправлять в канал элементы по одному, то мы можем выбирать их из некой очереди, организовать это дело можно так:

var pending []Item // заполняется процедурой получения данных, очищается процедурой отправки отчетов о работе
// отправляем информацию о завершенной задаче в канал s.updates
for {
  select {
  case s.updates <- pending[0]: // отправляем первый элемент
    pending = pending[1:] // когда отправка удаласть, удаляем первый элемент из массива перерписваивая слайс без него
  }
}
// это будет падать с ошибкой

Почему это код завершается с ошибкой? В тот момент когда pending становится пустым мы не можем обратиться к его 1 элементу.

У каналов есть такая особенность: если каналу присвоить значение nil, то отправка и прием блокируется в этом канале. Мы его деинициализируем вручную.

Эту особенность можно применять для введения временной блокировки.

Пример кода:

a := make(chan string)
go func(){ a <- "a" }()
a = nil
select {
case s:=<-a: // тут канал будет заблокирован
  fmt.Println("s=", s)
}

Так мы можем временно отключать некоторые варианты исполнения в select.
Итак исправим проблему этим методом:

var pending []Item // заполняется процедурой получения данных, очищается процедурой отправки отчетов о работе
// отправляем информацию о завершенной задаче в канал s.updates
for {
  var first Item
  var updates chan Item
  if len(pending) > 0 {
    first = pending[0]
    updatesChan = s.updates // укажем реальный канал, чтобы разблокировать исполнение в select
  }

  select {
  case updatesChan <- first: // отправляем первый элемент, заблокируется, если канал s.updates = nil
    pending = pending[1:] // когда отправка удаласть, удаляем первый элемент из массива перерписваивая слайс без него
  }
}

Здесь мы используем бесконечный цикл for, в котором происходит отправка элементов из списка pending в канал updates. Если список pending не пустой, то из него извлекается первый элемент и сохраняется в переменной first, а также устанавливается канал updatesChan равным каналу s.updates.

Затем выполняется выражение select с одним случаем, соответствующим отправке элемента first в канал updatesChan. Если канал s.updates не равен nil, то отправка элемента в канал приведет к разблокировке горутины, которая ждет данные из этого канала. После успешной отправки элемента из списка pending удаляется первый элемент.

Если же канал s.updates равен nil, то отправка элемента в канал приведет к блокировке горутины, которая будет ждать, пока в канал не будет отправлен хотя бы один элемент. Таким образом, горутина приостанавливается до тех пор, пока не будет готов принять данные другой горутины, которая отправляет данные в этот канал.

Как-то так работает простая и эффективная синхронизация горутин в Go; мы используем каналы для передачи данных и select для ожидания событий.

Довольно простые и популярные приёмы Go

Проверка наличия ключа в map

Очевидная вещь, и многие это знают, но я просто обязан об этом упомянуть. Чтобы проверить, есть ли ключ в map, просто записываем результат взятия по ключу в 2 переменных, вторая переменная — error или bool:

_, keyIsInMap := myMap["keyToCheck"]
if !keyIsInMap {
  fmt.Println("key not in map")
}

Проверка при приведении типов переменной

Иногда нужно преобразовать переменную из одного типа в другой. Проблема в том, что в случае неверного типа код запаникует. Например, следующий код пытается привести переменную data к строковому типу string:

value := data.(string)

Если преобразование data в тип string не произойдет, код запаникует. Поэтому рассмотрим способ преобразования лучше.

Аналогично проверке наличия ключа в map: при приведении типов получаем логическое значение и проверяем, произошло приведение или нет:

value, ok := data.(string)

В этом примере ok —  логическое значение, которое сообщает, было ли приведение типов успешным или нет. Таким образом работа с несоответствием типов ведется более изящно, чем при механизме паники.

Указание размера массива при использовании append для оптимизации

Для добавления элементов в массив лучше всего задействовать append. Например:

for _, v := range inputArray {
  myArray = append(myArray, v)
}

Однако в случае больших массивов процесс добавления замедлится, потому что append потребуется постоянно увеличивать размер myArray для новых значений, это постоянная реаллокация памяти. Лучше сначала указать длину массива, а затем присвоить каждое значение напрямую:

myArray := make([]int, len(inputArray))
 for i, v := range inputArray {
  myArray[i] = v
 }
}

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

myArray := make([]int, 0, len(inputArray))
for _, v := range inputArray {
  myArray = append(myArray, v)
}

Здесь размер массива устанавливается равным 0, а максимальный размер задается равным длине входного массива. Поэтому append не потребуется менять размер на ходу.

Использование append и многоточия для объединения массивов

Вполне себе очевидная вещь, но я упомяну. Иногда бывает нужно объединить 2 слайса, и очень кстати, что append —  это функция с переменным числом аргументов. Посмотрите, как выглядит обычный вызов append:

myArray = append(myArray, value1)

И append позволяет добавлять несколько элементов одновременно:

myArray = append(myArray, value1, value2)

Но самое крутое  —  это распаковка слайса с помощью ... при передаче его в функцию. Итак, объединяем слайс inputArray с myArray:

myArray = append(myArray, inputArray...)

При этом происходит распаковка элементов inputArray и мы добавляем их в конец myArray.

Отображение имен и значений параметров при выводе структуры

Всё время теперь этим пользуюсь. Раньше для отображения имен и значений параметров в структуре я выполнял маршалинг в JSON и логировал это. Но есть гораздо более простой способ: при выполнении Printf добавлять + или # в формат, в зависимости от того, что вы хотите вывести.

package main
import "fmt"

func main() {
    MyStruct := struct{
        Value1 string
        Value2 int
    }{Value1:"first value", Value2:2}
    
    fmt.Printf("%v \n", MyStruct)  // {first value 2} 
    fmt.Printf("%+v \n", MyStruct) // {Value1:first value Value2:2}
    fmt.Printf("%#v \n", MyStruct) // struct { Value1 string; Value2 int }{Value1:"first value", Value2:2}
}

Задействование iota с пользовательскими типами при перечислении

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

type PossibleStates int

const (
 State1 PossibleStates = iota  // 0
 State2                        // 1
 State3                        // 2
)

Здесь мы создаём пользовательский тип PossibleStates как алиас над int, после чего каждое перечисление будет иметь тип PossibleState, значение которого присваивается ключевым словом iota.

В итоге State1, State2, State3 будут иметь значения 0, 1, 2 соответственно.

Использование в качестве параметров функций, соответствующих интерфейсным при создании имитированного интерфейса

Этот прием стал для меня откровением. Допустим, имеется интерфейс, который надо сымитировать:

type DataPersistence interface {
 SaveData(string, string) error
 GetData(string) (string, error)
}

Это интерфейс для нескольких различных типов этой persistence. Нужно протестировать код, поэтому создадим имитированную структуру DataPersistence для использования в тестах. Но вместо написания сложной имитированной структуры просто создадим структуру с параметрами, которые являются функциями, соответствующими интерфейсным функциям.

Вот как будет выглядеть имитация:

type MockDataPersistence struct {
 SaveDataFunc func(string, string) error
 GetDataFunc func(string) (string, error)
}

// SaveData просто вызывает параметр SaveDataFunc
func (mdp MockDataPersistence) SaveData(key, value string) error {
 return mdp.SaveDataFunc(key, value)
}

// GetData просто вызывает параметр GetDataFunc
func (mdp MockDataPersistence) GetData(key string) (string, error) {
 return mdp.GetDataFunc(key)
}

Это означает, что при тестировании функции настраиваются, как нам надо, прямо в этом же тесте:

func TestMyStuff(t *testing.T) {
 mockPersistor := MockDataPersistence{}
 // здесь устанавливаем SaveData, чтобы просто вернуть ошибку
 mockPersistor.SaveDataFunc = func(key, value string) error {
  return fmt.Errorf("error to check how your code handles an error")
 }

// теперь проверяем, как thingToTest (то, что тестируется) разбирается с тем, когда 
 // SaveData возвращает ошибку
 err := thingToTest(mockPersistor)
 assert.Nil(t, err)
}

Удобство восприятия действительно улучшается: теперь видно очень хорошо, на что способна имитация в каждом тесте. Кроме того, теперь у нас есть доступ к тестовым данным в имитированной функции без необходимости поддерживать внешние файлы данных.

Создание собственного интерфейса в случае его отсутствия

Допустим, вы используете другую библиотеку Go, и там есть структура, но интерфейса не сделано  —  создайте его сами. Вот, например, эта структура:

type OtherLibsStruct struct {}

func (ols OtherLibsStruct) DoCoolStuff(input string) error {
 return nil
}

Прямо в коде создаем нужный интерфейс:

type InterfaceForOtherLibsStruct interface {
 DoCoolStuff(string) error
}

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

Инстанцирование вложенных анонимных структур

А этот прием мне приходилось задействовать несколько раз при использовании сгенерированного кода. Иногда при кодогенерации получается вложенная анонимная структура. Скажем, что-то такое:

type GeneratedStuct struct {
  Value1 string `json:"value1"`
  Value2 int `json:"value2"`
  Value3 *struct {
    NestedValue1 string `json:"NestedValue1"`
    NestedValue2 string `json:"NestedValue2"`
  } `json:"value3,ommitempty"`
}

Допустим, теперь надо создать экземпляр этой структуры для использования. Как это сделать? С Value1 и Value2 всё просто, но как инстанцировать указатель на анонимную структуру Value3?

Первое, что приходит на ум: записать его в JSON, а затем маршализовать в структуру. Но это ужасно и как-то по-дилетантски. Оказывается, нужно использовать другую анонимную структуру при ее инстанцировании:

myGeneratedStruct := GeneratedStuct{
  Value3: &struct {
   NestedValue1 string `json:"NestedValue1"`
   NestedValue2 string `json:"NestedValue2"`
  }{
   NestedValue1: "foo",
   NestedValue2: "bar",
  },
 }

В целом очевидно, но имейте в виду, что эта анонимная структура должна точно соответствовать, вплоть до тегов JSON.

К примеру, из-за несоответствия типов не удастся скомпилировать вот это, хотя на первый взгляд всё то же самое:

myGeneratedStruct := GeneratedStuct{
  Value3: &struct {
   NestedValue1 string `json:"nestedValue1"`
   NestedValue2 string `json:"nestedValue2"`
  }{
   NestedValue1: "foo",
   NestedValue2: "bar",
  },
 }

Приёмы работы со слайсами

Фильтрация без аллокации памяти

Для избежания реаллокации мы используем факт, что срез слайса a[:0] указывает на тот же массив и имеет ту же ёмкость, что и оригинальный слайс a.

b := a[:0]
for _, x := range a {
    if f(x) {               // f() - некая фильтрующая функция
        b = append(b, x)
    }
}

b := a[:0] — создаём срез b нулевой длины, но с той же ёмкостью, что и слайс a.

Для элементов, которые должны быть удалены сборщиком мусора, можно использовать что-то в духе:

for i := len(b); i < len(a); i++ {
    a[i] = nil
}

Разворачивание слайса

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

for i := len(a)/2-1; i >= 0; i-- {
    opp := len(a)-1-i
    a[i], a[opp] = a[opp], a[i]
}

То же самое, только с двумя индексами:

for left, right := 0, len(a)-1; left < right; left, right = left+1, right-1 {
    a[left], a[right] = a[right], a[left]
}

Перемешиваем слайс

Перемешать элементы слайса можно так, тут мы используем алгоритм Фишера-Йетса и math/rand:

for i := len(a) - 1; i > 0; i-- {
    j := rand.Intn(i + 1)
    a[i], a[j] = a[j], a[i]
}

А вообще, начиная с Go 1.10, мы можем использовать готовую функцию math/rand.Shuffle:

rand.Shuffle(len(a), 
             func(i, j int) { a[i], a[j] = a[j], a[i] })

Создание батчей с минимальным выделением ресурсов

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

actions := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
batchSize := 3
batches := make([][]int, 0, (len(actions) + batchSize - 1) / batchSize)

for batchSize < len(actions) {
    actions, batches = actions[batchSize:], append(batches, actions[0:batchSize:batchSize])
}
batches = append(batches, actions)

// [[0 1 2] [3 4 5] [6 7 8] [9]]

Чуть подробнее, что у нас тут происходит:

1. Объявляем слайс actions с целыми числами от 0 до 9.

2. Задаём размер батча (размер подслайса) batchSize, равный 3.

3. Создаём пустой слайс batches для хранения батчей. Его ёмкость устанавливаем в (len(actions) + batchSize - 1) / batchSize, чтобы убедиться, что в нём будет достаточно места для всех батчей.

4. Запускаем цикл for, который работает, пока размер батча batchSize меньше длины слайса actions. Внутри цикла:

   • Обновляем слайс actions, отбрасывая первые batchSize элементов с помощью операции actions[batchSize:].

   • Обновляем слайс batches путём добавления нового батча, созданного из первых batchSize элементов слайса actions с помощью операции append(batches, actions[0:batchSize:batchSize]).

5. После окончания цикла, когда длина actions меньше или равна batchSize, добавляем оставшиеся элементы в batches с помощью операции append(batches, actions).

Выкидываем дубли (дедупликация)

import "sort"

in := []int{3,2,1,4,3,2,1,4,1} // любой элемент можно отсортировать
sort.Ints(in)
j := 0
for i := 1; i < len(in); i++ {
	if in[j] == in[i] {
		continue
	}
	j++
	// сохраняем исходные данные
	// in[i], in[j] = in[j], in[i]
	// устанавливаем только то, что требуется
	in[j] = in[i]
}
result := in[:j+1]
fmt.Println(result) // [1 2 3 4]

Чуть подробнее:

1. Сортируем срез in с помощью sort.Ints(in) в возрастающем порядке.

2. Создаём j для отслеживания позиции, где поместим следующий уникальный элемент.

3. Внутри цикла проверяем, равен ли текущий элемент in[j]. Если равен, то пропускаем текущую итерацию цикла с помощью continue, не изменяя j.

4. А если текущий элемент не равен in[j], увеличиваем j на 1 и копируем текущий элемент в позицию in[j]. Это означает, что in[j] теперь содержит уникальное значение, и j указывает на следующую позицию, где следует поместить следующий уникальный элемент.

Как-то так можно насобирать в слайс result все уникальные значения из in.

Перемещение элемента на передний план или вставка, если элемент отсутствует

// moveToFront перемещает needle в начало среза
func moveToFront(needle string, haystack []string) []string {
    if len(haystack) != 0 && haystack[0] == needle {
        return haystack
    }
    prev := needle
    for i, elem := range haystack {
        switch {
        case i == 0:
            haystack[0] = needle
            prev = elem
        case elem == needle:
            haystack[i] = prev
            return haystack
        default:
            haystack[i] = prev
            prev = elem
        }
    }
    return append(haystack, prev)
}

haystack := []string{"a", "b", "c", "d", "e"} // [a b c d e]
haystack = moveToFront("c", haystack)         // [c a b d e]
haystack = moveToFront("f", haystack)         // [f c a b d e]

В целом, код довольно прозрачный:

1. Если первый элемент слайса равен needle, функция возвращает слайс без изменений.

2. Иначе, функция проходит по слайсу помощью цикла for и перемещает элементы, пока не найдет needle.

3. Когда needle найден, функция помещает предыдущий элемент в текущую позицию и прерывает цикл, возвращая измененный слайс.

4. Если needle не найден, функция добавляет prev (последний элемент слайса) в конец и возвращает измененный слайс.

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

Скользящее окно

Нарезаем наш слайс на пересекающиеся куски нужного размера.

func slidingWindow(size int, input []int) [][]int {
    // возвращает входной срез как первый элемент
    if len(input) <= size {
        return [][]int{input}
    }

    // выделяем срез точного размера, который нам нужен
    r := make([][]int, 0, len(input)-size+1)

    for i, j := 0, size; j <= len(input); i, j = i+1, j+1 {
        r = append(r, input[i:j])
    }

    return r
}

a:=[]int{1,2,3,4,5}
aa := slidingWindow(3, a)
fmt.Println(aa) // [[1 2 3] [2 3 4] [3 4 5]]

Вообще, вся эта история с нарезанием слайса активно используется в обработке сигналов, анализе временных рядов и особенно в ML.

The end

Что ж, это мы рассмотрели полезные фишки и приёмы в Go. Некоторые штуки я регулярно использую, надеюсь они упростят жизнь и вам.

Пишите, с чем доводилось сталкиваться на практике — будет интересно почитать)