В статье познакомимся с рекомендациями по написанию чистого кода на Go. Разберемся на примерах с особенностями языка и применим на практике основные синтаксические конструкции.

Работа с данными

Отличие make и new

Make и new – это встроенные механизмы для выделения памяти. Они используются в разных ситуациях и имеют свои особенности.

• new инициализирует нулевое значение для данного типа и возвращает указатель на этот тип.
• make используется исключительно для создания и инициализации срезов, отображений и каналов, возвращает ненулевой экземпляр указанного типа.
• Основное отличие между ними состоит в том, что make возвращает инициализированный тип, готовый к использованию после создания, а new – указатель на тип с его нулевым значением.

         a := new(chan int)   // a имеет тип *chan int b := make(chan int)  // b имеет тип chan int      

Скрытые данные в слайсах

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

При работе со слайсами часто возникает задача их «перенарезки» на более мелкие. В итоге получившийся слайс будет ссылаться на массив исходного. Об этом не стоит забывать, иначе в программе может возникнуть непредсказуемое потребление памяти.

Рассмотрим эту особенность на конкретных примерах:

         // Плохая практика - непредсказуемое потребление памяти func cutSlice() []byte { 	slice := make([]byte, 256) 	fmt.Println(len(slice), cap(slice), &slice[0]) // 256 256 <0x...> 	return slice[:10] }  func main() { 	res := cutSlice() 	fmt.Println(len(res), cap(res), &res[0]) // 10 256 <0x...> }      

Для предотвращения возникшей ошибки следует удостовериться, что копирование производится из временного слайса:

         // Хорошая практика - данные скопированы из временного слайса func cutSlice() []byte { 	slice := make([]byte, 256) 	fmt.Println(len(slice), cap(slice), &slice[0]) // 256 256 <0x...> 	copyOfSlice := make([]byte, 10) 	copy(copyOfSlice, slice[:10]) 	return slice[:10] }  func main() { 	res := cutSlice() 	fmt.Println(len(res), cap(res), &res[0]) // 10 256 <0x...> }      

Библиотека Go разработчика Больше полезных материалов вы найдете на нашем телеграм-канале «Библиотека Go разработчика» Библиотека Go для собеса Подтянуть свои знания по Go вы можете на нашем телеграм-канале «Библиотека Go для собеса» Библиотека задач по Go Интересные задачи по Go для практики можно найти на нашем телеграм-канале «Библиотека задач по Go»

Функции

Функции с множественным возвратом

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

Пример объявления функции с множественным возвратом в Go:

         package main  import "fmt"  func swap(a, b int) (int, int) { 	return b, a }  func main() { 	x, y := swap(1, 2) 	fmt.Println(x, y) // 2 1  	a, _ := swap(3, 4) 	fmt.Println(a) // 4 }      

В приведенном примере функция swap принимает два аргумента типа int и возвращает два значения того же типа, меняя местами исходные переменные.

Можно также игнорировать одно или несколько возвращаемых значений, используя пустой идентификатор (_).

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

Приведенная ниже функция openFile возвращает два значения, одно из которых – ошибка или nil в случае ее отсутствия.

         func openFile(name string) (*File, error) { 	file, err := os.Open(name) 	if err != nil { 		return nil, err 	} 	return file, nil }      

Интерфейсы

В Go интерфейсы представляют собой набор методов, определяющих поведение объекта. Они позволяют абстрагироваться от конкретной реализации и работать с различными типами данных. То есть интерфейсы лишь определяют некоторый функционал, но сами его не реализуют.

Используем интерфейсы правильно

?Запомните важное правило Не стоит определять интерфейсы до их использования. Без реального примера сложно понять, действительно ли они необходимы, не говоря уже о методах, которые должны в них содержаться.

         package worker  // worker.go  type Worker interface { Work() bool }  func Foo(w Worker) string { ... }     

         package worker // worker_test.go  type secondWorker struct{ ... } func (w secondWorker) Work() bool { ... } ... if Foo(secondWorker{ ... }) == "value" { ... }     

Ниже представлен пример неправильного подхода при работе с интерфейсами:

         // Плохая практика package employer  type Worker interface { Worker() bool }  type defaultWorker struct{ ... } func (t defaultWorker) Work() bool { ... }  func NewWorker() Worker { return defaultWorker{ ... } }      

Верное решение с точки зрения Go — вернуть конкретный тип и позволить Worker имитировать реализацию employer:

         // Хорошая практика package employer  type Worker struct { ... } func (w Worker) Work() bool { ... }  func NewWorker() Worker { 	return Worker{ 		... 	} }     

Конкурентность и параллелизм

Отслеживание горутин

Горутины дешевы в запуске и эксплуатации, но у них есть конечная стоимость с точки зрения занимаемой памяти – вы не можете создать их бесконечное количество. В отличие от переменных, среда выполнения Go не может обнаружить, что горутина больше никогда не будет использоваться.

• Подробно горутины рассмотрены в статье «Горутины: что такое и как работают». Её прочтение поможет лучше разобраться в рассматриваемой теме.

? Запомните важное правило Каждый раз, когда вы используете ключевое слово go в своей программе для запуска горутины, вы должны знать, как и когда она завершится.

Если вы не знаете ответа на два приведённых вопроса, это может привести к возникновению утечек памяти.

Обратимся к примеру для иллюстрации данной ошибки:

         func leakGoroutine() { 	ch := make(chan int) 	go func() { 		received := <- ch 		fmt.Println("Полученное значение:", received) 	} }      

Здесь функция leakGoroutine запускает горутину, которая блокирует чтение из канала ch . В результате в него ничего не отправится, и сам он никогда не закроется. Горутина будет заблокирована навсегда, вызов функции fmt.Println никогда не произойдет.

Обнаружение утечек

Инженеры из Uber, которые принимают активное участие в развитии Go, создали детектор утечек горутин – пакет goleak, нацеленный на интеграцию с модульными тестами. Рассмотрим пример работы с этим инструментом на практике.

Пусть есть некая функция leakGoroutin с утечкой горутины:

         func leakGoroutine() { 	go func() { 		time.Sleep(time.Minute) 	}()  	return nil }      

И тест этой функции:

         func TestLeakGoroutine(t *Testing.T) { 	defer goleak.VerifyNone(t)  	if err := leak(); err != nil { 		t.Fatal("Fatal message") 	} }      

При запуске тестов появляется сообщение об ошибке found enexpected goroutines , где указывается вершина стека с проблемной горутиной, ее состояние и идентификатор.

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

Обработка ошибок и восстановление

Ошибки в Go представлены интерфейсом error, который определяет метод Error() string. Любой тип, реализующий этот метод, может быть использован как ошибка.

         type error interface {     Error() string }      

• Чтобы больше узнать об ошибках в Go, рекомендуется прочитать статью «Исключения в Go – это легко?». Из нее вы узнаете о том, как эффективно решать проблемные ситуации в программах.

Обрабатываем ошибки правильно

Игнорирование ошибок может привести к неопределенному поведению и усложнить отладку кода. Рассмотрим правильный способ обработки ошибок на примере работы с файлом:

         // плохо file, err := os.Open("filename.txt") if err == nil {     // операции с файлом }      

         // хорошо file, err := os.Open("filename.txt") if err != nil { 	log.Fatal(err) // обработка ошибки } defer f.Close() // отложенный вызов функции для закрытия файла      

Без паники, но с восстановлением

Классический способ сообщить об ошибке – вернуть тип error. Но что делать в тех случаях, когда её нельзя быстро восстановить? Тогда на помощь приходит встроенная функция panic (часто её называют просто «паника»), которая завершает программу и выводит настраиваемое сообщение об ошибке.

Ниже представлен пример простой функции с паникой:

         package main  import "fmt"  func examplePanic() {   panic("Паника - программа завершена")   fmt.Println("Функция examplePanic успешно завершилась")   }  func main() {   examplePanic()   fmt.Println("Функция main успешно завершилась") }      

При возникновении паники функция завершается и происходит запуск оставшихся отложенных функций с помощью defer, а также раскручивание стека горутин. В реальных условиях разработки следует избегать подобных ситуаций, так как это ставит под угрозу бесперебойную работу программы. К счастью, авторы Go предусмотрели этот недостаток и создали механизм восстановления после паники – recover. Он позволяет остановить раскручивание стека и вернуть разработчику контроль над программой.

Чтобы продемонстрировать работу данного механизма, обратимся к примеру:

         package main  import "fmt"  func Recovery() { 	if recoveryResult := recover(); recoveryResult != nil { 		fmt.Println(recoveryResult) 	} 	fmt.Println("Восстановление...") }  func Panic() { 	defer Recovery() 	panic("Паника") 	fmt.Println("Функция Panic успешно завершилась") }  func main() { 	Panic() 	fmt.Println("Функция main успешно завершилась") }      

В результате выполнения кода мы получим следующий вывод:

         Паника Восстановление... Функция main успешно завершилась      

Заметьте, что функция Panic не завершается после паники. Это происходит из-за того, что с помощью defer вызывается отложенная функция Recovery, которая восстанавливает работу программы. Далее исполнение передается в main, где происходит успешное завершение всего кода.

Заключение

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

Хочется верить, что статья вдохновит читателей применять описанные практики в разработке на Go и создавать программы, в которых будет нетрудно разобраться даже новичку. И помните, чистый код – это путь к успешному проекту!

Материалы по теме

• ? Golang для веб-разработки: примеры использования
• ? Параллельное программирование в Go
• ? Паттерны Go-кода на все случаи жизни