Go: идиомы и паттерны проектирования

Предисловие

Изначально я хотел назвать эту книгу «Скучный Go», потому что Go — это и правда очень скучно.

Конечно, немного странно писать книгу на скучную тему, но я сейчас все объясню. Язык Go обладает небольшим набором возможностей, что идет вразрез с большинством других современных языков программирования. Хорошо написанная программа на Go, как правило, отличается простотой, а часто и некоторым однообразием. Здесь нет наследования, обобщенных типов (по крайней мере пока), аспектно-ориентированного программирования, перегрузки функций и уж точно нет перегрузки операторов. Здесь нет сравнения с паттерном, нет именованных параметров и исключений, зато есть пугающие многих указатели. Модель обмена данными в Go не похожа на ту, что применяется в других языках, и основана на идеях 1970-х годов, как и алгоритм, используемый для сборщика мусора. Другими словами, работа с Go выглядит откатом в прошлое.

Однако если Go скучен, это еще не значит, что он примитивен. Для правильного использования этого языка необходимо четко понимать, как его возможности сочетаются друг с другом. Хотя вы вполне можете написать на Go такой код, который будет выглядеть почти так же, как код на Java или Python, но результат вас не слишком обрадует, и вы так и не поймете, к чему была вся эта суета. Вот тут-то и пригодится эта книга. Она познакомит вас с возможностями Go и объяснит, как лучше их использовать для написания расширяемого идиоматического кода.

Когда речь идет о создании чего-то, что должно служить нам долгие годы, такое качество, как «обычность», становится не минусом, а плюсом. Никто не захочет первым прокатиться на своей машине по мосту, созданному с использованием непроверенных технологий, которые инженер посчитал «крутыми». Современный мир зависит от программного обеспечения так же, как и от мостов, если не больше. Тем не менее во многие языки программирования добавляют массу новых компонентов, не задумываясь об их влиянии на «ремонтопригодность» кодовой базы, в то время как Go рассчитан на создание надежных программ, которые смогут улучшать десятки программистов на протяжении десятилетий.

Так что да, Go скучный и это здорово! Я надеюсь, книга научит вас создавать с помощью такого «скучного» кода потрясающие проекты.

Для кого написана книга

Целевая аудитория — разработчики, желающие изучить второй (или пятый) язык программирования. Она подойдет как новичкам, которые знают лишь то, что у Go есть забавный талисман, так и тем, кто уже успел прочитать краткое руководство по этому языку или даже написать на нем несколько фрагментов кода. Эта книга не просто рассказывает, как следует писать программы на Go, она показывает, как можно делать это идиоматически. Более опытные Go-разработчики найдут здесь советы по использованию новых возможностей языка.

Предполагается, что читатель уже умеет пользоваться таким инструментом разработчика, как система контроля версий (желательно Git) и IDE. Читатель должен быть знаком с такими базовыми понятиями информатики, как конкурентность и абстракция, поскольку в книге мы будем касаться этих тем применительно к Go. Одни примеры кода можно скачать с GitHub, а десятки других — запустить в онлайн-песочнице The Go Playground. Наличие соединения с интернетом необязательно, однако с ним будет проще изучать исполняемые примеры кода. Поскольку язык Go часто используется для создания и вызова HTTP-серверов, для понимания некоторых примеров читатель должен иметь общее представление о протоколе HTTP и связанных с ним концепциях.

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

Условные обозначения

В этой книге используются следующие типографские обозначения.

Курсивный шрифт

Используется для выделения новых терминов.

Шрифт без засечек

Применяется для выделения URL-адресов, адресов электронной почты.

Моноширинный шрифт

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

Полужирный моноширинный шрифт

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

Курсивный моноширинный шрифт

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

Так обозначается совет или предложение.

Так обозначается примечание общего характера.

Так обозначается предупреждение.

Использование примеров программного кода

Вспомогательные материалы (примеры программного кода, упражнения и т.д.) доступны для скачивания по адресу https://github.com/learning-go-book.

При возникновении технических вопросов или проблем, связанных с использованием примеров кода, пожалуйста, обращайтесь по адресу электронной почты [email protected].

Книга призвана помочь вам в решении ваших задач. В большинстве случаев вы можете свободно использовать приводимые в этой книге примеры кода в своих программах и документации. Вам не нужно обращаться в издательство за разрешением, если вы не собираетесь воспроизводить существенную часть программного кода. Например, если вы разрабатываете программу и используете в ней несколько фрагментов кода из книги, вам не нужно обращаться за разрешением. Однако в случае продажи или распространения примеров из этой книги вы должны получить разрешение от издательства O’Reilly. Если вы отвечаете на вопросы, цитируя данную книгу или примеры из нее, то для этого не требуется разрешение. Но при включении значительного объема программного кода из этой книги в документацию вашего продукта необходимо получить разрешение издательства.

Мы не требуем, чтобы вы давали ссылку на первоисточник при цитировании, но будем признательны, если вы будете это делать. При этом обычно указывается название книги, имя ее автора, название издательства и номер ISBN. Например: «Go: идиомы и паттерны проектирования», Джон Боднер (Питер). Copyright 2021 Jon Bodner, 978-5-4461-1885-4».

Если у вас возникнут какие-либо сомнения относительно правомерности использования примеров кода, вы всегда можете связаться с нами по адресу [email protected].

Благодарности

Хоть и считается, что писательство — это индивидуальное занятие, книга не может появиться на свет без помощи множества других людей. Однажды я сказал Кармен Андо (Carmen Andoh), что собираюсь написать книгу по языку Go, и на конференции GopherCon 2019 она познакомила меня с Зан Маккуэйд (Zan McQuade) из компании O’Reilly. Зан помогла мне заключить договор с издательством, после чего регулярно консультировала меня по мере моего прогресса в написании книги. Мишель Кронин (Michele Cronin) редактировала мои тексты, высказывала замечания и выслушивала меня, когда я неизбежно сталкивался с трудностями. Технический редактор Тоня Трибула (Tonya Trybula) и литературный редактор Бет Келли (Beth Kelly) довели мою рукопись до пригодного для печати вида.

По мере написания книги я получал важные замечания (и слова поддержки) от многих людей, в числе которых были Джонатан Алтмэн (Jonathan Altman), Джонатан Амстердам (Jonathan Amsterdam), Джонни Рэй Остин (Johnny Ray Austin), Крис Фойербах (Chris Fauerbach), Крис Хайнс (Chris Hines), Билл Кеннеди (Bill Kennedy), Тони Нельсон (Tony Nelson), Фил Перл (Phil Pearl), Лиз Райс (Liz Rice), Аарон Шлезингер (Aaron Schlesinger), Крис Стаут (Chris Stout), Капил Тхангавелу (Kapil Thangavelu), Клер Тривисонно (Claire Trivisonno), Фолькер Уриг (Volker Uhrig), Джефф Уэндлинг (Jeff Wendling) и Крис Сарагоса (Kris Zaragoza). Особых слов признательности заслуживает Роб Лебовиц (Rob Liebowitz), подробные замечания и быстрые ответы которого сделали эту книгу гораздо лучше.

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

Наконец, хочется вспомнить о тех людях, которые направили меня по этому пути четыре десятилетия назад. Первым из них был отец моего друга детства Пол Голдштейн (Paul Goldstein). В 1982 году он показал нам компьютер Commodore PET, ввел команду PRINT2+2 и нажал клавишу ввода. Я был поражен, когда на экране появилась цифра 4, и заболел этим раз и навсегда. Спустя какое-то время Пол научил меня программировать и даже на несколько недель одолжил свой компьютер. А вторым человеком была моя мама, которую я должен поблагодарить за то, что она поощряла мой интерес к программированию и компьютерам, даже толком не понимая, что это такое. В свое время она купила мне картридж для игровой приставки Atari 2600, позволявший писать программы на языке BASIC, компьютеры Commodore VIC-20 и Commodore 64, а также книги по программированию, после прочтения которых у меня появилась мечта когда-нибудь написать свою собственную книгу.

Спасибо всем вам за то, что помогли мне сделать эту мечту реальностью!

От издательства

Ваши замечания, предложения, вопросы отправляйте по адресу [email protected] (издательство «Питер», компьютерная редакция).

Мы будем рады узнать ваше мнение!

На веб-сайте издательства www.piter.com вы найдете подробную информацию о наших книгах.

Согласно комментарию автора на странице книги на сайте O’Reilly, инструмент golint не поддерживается. По этой причине мы удалили из главы 1 подраздел, посвященный golint.

Глава 1. Настройка среды разработки для языка Go

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

Установка средств разработки для языка Go

Чтобы приступить к написанию кода на Go, нужно установить средства разработки. Последнюю версию этих инструментов можно скачать с официального сайта языка Go (https://golang.org/dl). Скачайте и установите версию, подходящую для вашей платформы. Установочные пакеты с расширением .pkg для Mac и с расширением .msi для Windows автоматически установят Go в нужном каталоге, удалят ранее установленные файлы и разместят двоичный файл языка Go в соответствии с путем по умолчанию для исполняемых файлов.

Для платформы Mac средства разработки для языка Go можно установить с помощью менеджера пакетов Homebrew (https://brew.sh), выполнив ­команду brew install go. Для Windows это можно сделать с помощью ме­неджера пакетов Chocolatey (https://chocolatey.org), выполнив команду choco install golang.

Версии установочных пакетов для Linux и FreeBSD представляют собой архивы с расширением .tar, которые распаковываются в каталог с именем go. Скопируйте этот каталог в /usr/local и добавьте путь /usr/local/go/bin в переменную среды $PATH, чтобы сделать доступной команду go:

$ tar -C /usr/local -xzf go1.15.2.linux-amd64.tar.gz

$ echo 'export PATH=$PATH:/usr/local/go/bin' >> $HOME/.profile

$ source $HOME/.profile

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

Чтобы убедиться, что ваша среда настроена правильно, откройте окно терминала или командной строки и введите команду:

$ go version

Если все было настроено правильно, то вы увидите что-то наподобие следу­ющего:

go version go1.15.2 darwin/amd64

Это сообщение говорит о наличии компилятора Go версии 1.15.2 для Mac OS. (Darwin — это название ядра в Mac OS, а amd64 — название 64-разрядной процессорной архитектуры от AMD и Intel.)

Если вместо сообщения с описанием версии вы увидите сообщение об ошибке, значит, у вас нет файла go в каталоге, заданном в качестве пути для исполняемых файлов, или в этом файле находится другая программа с таким же именем. В Mac OS или других Unix-подобных системах можно выяснить, какой файл go запускается и запускается ли вообще, с помощью команды whichgo. Если это не файл, расположенный по адресу /usr/local/go/bin/go, скорректируйте свой путь для исполняемых файлов.

Если вы работаете в Linux или FreeBSD, ошибка может состоять в том, что вы установили 64-разрядную версию средств разработки для языка Go в 32-разрядной системе или версию для другой процессорной архитектуры.

Рабочее пространство Go

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

Сегодня здесь действует простое правило: вы можете организовывать свои проекты любым удобным вам способом. Однако все же предполагается, что вы будете использовать единое рабочее пространство для сторонних инструментов Go, устанавливаемых с помощью команды goinstall (см. подраздел «Установка сторонних инструментов для Go» на с. 23). По умолчанию это рабочее пространство размещается в каталоге $HOME/go; при этом исходный код для этих инструментов хранится в каталоге $HOME/go/src, а скомпилированные двоичные файлы — в каталоге $HOME/go/bin. Вы можете использовать эти настройки по умолчанию или задать другое расположение рабочего пространства с помощью переменной среды $GOPATH.

Вне зависимости от того, какой вариант расположения вы решили использовать, рекомендуется явно определить переменную GOPATH и добавить каталог $GOPATH/bin в переменную, задающую путь для исполняемых файлов. Явное определение переменной GOPATH позволяет ясно указать, где находится рабочее пространство языка Go, а добавление каталога $GOPATH/bin в качестве дополнительного пути для исполняемых файлов упрощает запуск сторонних инструментов, которые устанавливаются с помощью команды goinstall и о которых мы поговорим чуть позже.

Если вы работаете с Unix-подобной системой, использующей командную оболочку bash, необходимо добавить следующие строки в файл .profile. (Если вы используете командную оболочку zsh, добавьте эти строки в файл .zshrc.)

export GOPATH=$HOME/go

export PATH=$PATH:$GOPATH/bin

Чтобы эти изменения вступили в силу, выполните команду source$HOME/.profile в текущем окне терминала.

Если вы работаете в Windows, выполните следующие команды в окне командной строки:

setx GOPATH %GOPATH%\go

setx path %path%;%USERPROFILE%\bin

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

Инструмент go принимает во внимание и ряд других переменных среды. Вы можете получить полный список этих переменных вместе с кратким описанием каждой из них, выполнив команду goenv. Многие из этих переменных управляют низкоуровневым поведением, которое можно спокойно проигнорировать, однако мы все же рассмотрим некоторые из них при обсуждении модулей и перекрестной компиляции.

В некоторых онлайн-источниках рекомендуется определить переменную среды GOROOT. В ней задается расположение установленных средств разработки для языка Go. Теперь в этом уже нет необходимости: инструмент go определяет расположение автоматически.

Команда go

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

Команды go run и go build

С помощью go мы можем выполнить две похожие команды: gorun и gobuild. Обе принимают на вход отдельный файл Go, список Go-файлов или имя пакета. Создадим простую программу и посмотрим, что произойдет, когда мы воспользуемся этими командами.

Команда go run

Начнем с команды gorun. Создайте каталог с именем ch1, после чего откройте текстовый редактор, введите следующий текст и сохраните его в файле с именем hello.go внутри каталога ch1:

package main

import fmt

func main() {

    fmt.Println(Hello, world!)

}

После этого откройте окно терминала или командной строки и выполните в нем следующую команду:

go run hello.go

На экран будет выведена фраза Hello,world!. Если вы проверите содержимое каталога после выполнения команды gorun, то увидите, что в нем не появился двоичный файл и он по-прежнему содержит только созданный нами файл hello.go. Здесь вы можете спросить: почему так происходит, ведь Go вроде бы компилируемый язык?

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

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

Команда go build

В большинстве случаев вам потребуется скомпилировать двоичный файл для последующего использования. Здесь вам поможет команда gobuild. Введите в окне терминала такую команду:

go build hello.go

Она создаст в текущем каталоге исполняемый файл с именем hello (или hello.exe в Windows). Если вы запустите его, то на экран, как и следовало ожидать, будет выведена фраза Hello,world!.

Имя этого двоичного файла совпадает с тем именем файла или пакета, которое вы передали команде. Если вам нужно сохранить приложение под другим именем или в другом каталоге, используйте флаг -o. Например, чтобы скомпилировать код в двоичный файл с именем hello_world, нужно ввести следующую команду:

go build -o hello_world hello.go

Используйте команду go build для создания распространяемого файла, который будет использоваться другими пользователями. Именно это требуется сделать в большинстве случаев. Используйте флаг -o, чтобы задать другое имя или расположение двоичного файла.

Установка сторонних инструментов для Go

Хотя некоторые Go-разработчики и предпочитают распространять свои программы в виде скомпилированных двоичных файлов, написанные на Go инструменты также можно скомпилировать из исходного кода и установить в свое рабочее пространство Go с помощью команды goinstall.

В Go применяется не такой, как в большинстве других языков, метод публикации кода. Вместо того чтобы использовать такой централизованный сервис, как Maven Central в случае Java или реестр NPM в случае JavaScript, Go-разработчики распространяют свои проекты посредством репозиториев исходного кода. В качестве аргумента команде goinstall передается расположение репозитория исходного кода интересующего вас проекта, за которым следует символ @ и нужная версия этого инструмента (если нужно установить последнюю версию, укажите @latest). Когда вы запустите эту команду, она скачает, скомпилирует и установит указанный инструмент в каталог $GOPATH/bin.

Рассмотрим небольшой пример, используя такой отличный Go-инструмент, как нагрузочное тестирование HTTP-серверов под названием hey. Эта программа позволяет протестировать любой выбранный вами сайт или написанное вами приложение. Установить ее можно следующим образом:

$ go install github.com/rakyll/hey@latest

go: downloading github.com/rakyll/hey v0.1.4

go: downloading golang.org/x/net v0.0.0-20181017193950-04a2e542c03f

go: downloading golang.org/x/text v0.3.0

Команда скачивает программу hey и все ее зависимости, компилирует ее и устанавливает двоичный файл в каталоге $GOPATH/bin.

Как будет подробно рассказано в разделе «Прокси-серверы модулей» на с. 248, содержимое Go-репозиториев кэшируется на прокси-серверах. В зависимости от конкретного репозитория и значений, заданных в переменной среды GOPROXY, команда go install может производить скачивание либо с прокси-сервера, либо непосредственно из репозитория. При скачивании непосредственно из репозитория эта команда использует установленные на вашей машине инструменты командной строки. Так, например, для скачивания из репозитория, расположенного на сайте GitHub, у вас должна быть установлена система контроля версий Git.

Теперь, когда мы уже скомпилировали и установили программу hey, можем запустить ее с помощью следующей команды:

$ hey https://www.golang.org

Summary:

  Total:        0.6864 secs

  Slowest:      0.3148 secs

  Fastest:      0.0696 secs

  Average:      0.1198 secs

  Requests/sec: 291.3862

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

go install github.com/rakyll/hey@latest

Разумеется, написанные на Go инструменты совсем не обязательно оставлять в рабочем пространстве Go: это обычные исполняемые двоичные файлы, которые можно разместить в любом каталоге. Точно так же вам не обязательно распространять написанные на Go программы посредством команды goinstall: вместо этого можно предложить для скачивания двоичный файл. Однако эту команду очень удобно использовать для распространения Go-программ среди разработчиков.

Форматирование кода

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

У этого подхода есть и еще одно преимущество. Разработчики раньше тратили очень много времени на «войну форматов». Благодаря тому, что Go определяет стандартный способ форматирования кода, Go-разработчикам не приходится спорить относительно того, какой стиль размещения фигурных скобок лучше использовать или как лучше задавать отступы: с помощью символов табуляции или с помощью пробелов. Так, например, для задания отступов в Go-коде используются символы табуляции, и, если открывающая фигурная скобка не находится в той же строке, что и начинающие этот блок команда или объявление, это считается ошибкой синтаксиса.

Среди Go-разработчиков бытует мнение, что создатели языка Go решили использовать стандартный формат для того, чтобы исключить споры в отношении формата, и уже после этого обнаружили преимущества данного подхода в плане создания инструментов. Однако Расс Кокс (Russ Cox) пуб­лично заявил о том, что его исходным мотивом было упрощение процесса создания инструментов (https://oreil.ly/rZEUv).

Правило вставки точки с запятой

Команда gofmt не исправляет ошибочное размещение фигурной скобки не в той строке, что объясняется наличием правила вставки точки с запятой. Подобно языкам C и Java, Go требует, чтобы каждый оператор заканчивался символом «точка с запятой». Однако Go-разработчики никогда не расставляют символы «точка с запятой» вручную, поскольку компилятор языка Go делает это автоматически в соответствии с очень простым правилом, суть которого изложена в кратком руководстве «Эффективный Go» (https://oreil.ly/hTOHU):

Если символу новой строки предшествует одна из следующих лексем, то лексический анализатор вставляет после нее символ «точка с запятой»:

• идентификатор (включая такие слова, как int и float64);

• один из базовых литералов, таких как число или строковая константа;

• одна из следующих лексем: break, continue, fallthrough, return, ++, ––, ), }.

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

func main()

{

    fmt.Println(Hello, world!)

}

то благодаря правилу вставки точки с запятой будет распознан символ ) в конце строки funcmain(), а код приведен к следующему виду:

func main();

{

    fmt.Println(Hello, world!);

};

что не будет корректным Go-кодом.

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

В набор средств разработки языка Go входит команда gofmt, которая автоматически форматирует ваш код в соответствии со стандартным форматом. Она позволяет исправить неверно заданные отступы, выравнивает поля в структурах и обеспечивает правильные интервалы между операторами.

Существует расширенная версия команды gofmt под названием goimports, которая также приводит в порядок операторы импорта. Она располагает их в алфавитном порядке, удаляет неиспользуемые операторы и добавляет операторы импорта недостающих, по ее мнению, пакетов. Поскольку она не всегда точно угадывает, каких пакетов вам не хватает, добавлять операторы импорта лучше вручную.

Скачать goimports можно с помощью команды goinstallgolang.org/x/tools/cmd/goimports@latest. Чтобы применить ее к файлам своего проекта, выполните следующую команду:

goimports -l -w .

Флаг -l дает goimports указание вывести в консоль список неправильно отформатированных файлов. Флаг -w дает указание непосредственно изменить эти файлы. Символ «точка» указывает, что нужно проверить все файлы, находящиеся в текущем каталоге и во всех подкаталогах.

Всегда используйте go fmt или программу goimports перед тем, как компилировать свой код!

Выбор инструментов

Хотя, как мы уже успели убедиться, написать небольшую программу на Go можно, используя только текстовый редактор и команду go, для работы над более крупными проектами вам, вероятно, потребуются более продвинутые инструменты. К счастью, к настоящему времени уже созданы отличные средства поддержки языка Go для большинства существующих текстовых редакторов и интегрированных сред разработки (https://oreil.ly/MwCWT). Если вы еще не определились с выбором среды разработки, то двумя наиболее популярными вариантами в случае языка Go являются редактор кода Visual Studio Code и интегрированная среда разработки Goland.

Visual Studio Code

Если вы хотите найти бесплатную среду разработки, то лучшим выбором будет редактор кода Visual Studio Code от компании Microsoft (https://oreil.ly/zktT8). За время, прошедшее с момента его появления в 2015 году, VS Code успел приобрести чрезвычайно большую популярность среди разработчиков. Хотя поддержка языка Go не входит в его «комплект поставки», его можно превратить в среду разработки для языка Go, скачав расширение для поддержки этого языка из галереи расширений.

Поддержка языка Go в редакторе VS Code обеспечивается с помощью сторонних инструментов. Это включает в себя комплект средств разработки языка Go, отладчик Delve (https://oreil.ly/sosLu) и gopls (https://oreil.ly/TLapT) — языковой сервер для языка Go, созданный командой разработчиков этого языка. При этом комплект средств разработки языка Go вы должны установить самостоятельно, а Delve и gopls для вас установит Go-расширение редактора.

Установив и настроив этот инструмент, можете открыть свой проект и приступить к работе над ним. Окно вашего проекта должно выглядеть примерно так, как показано на рис. 1.1. Основы работы с Go-расширением редактора VS Code демонстрируются во вводном видео «Приступая к работе с VS Code Go» (https://oreil.ly/XhoeB).

Рис. 1.1. Visual Studio Code

Что такое языковой сервер? Это стандартная спецификация API, позволяющего редакторам реализовать такие интеллектуальные функции редак­тирования, как автодополнение и статический анализ кода, поиск мест ­использования методов и т.д. Для большей информации ознакомьтесь с протоколом языкового сервера (https://oreil.ly/2T2fw).

GoLand

GoLand (https://oreil.ly/6cXjL) — это ориентированная на язык Go интегрированная среда разработки (IDE) от компании JetBrains. Хотя компания JetBrains в первую очередь славится своими инструментами для разработки на Java, это не мешает GoLand быть прекрасной средой разработки для языка Go. Как можно убедиться, взглянув на рис. 1.2, пользовательский интерфейс среды разработки GoLand выглядит практически так же, как интерфейс сред разработки IntelliJ, PyCharm, RubyMine, WebStorm и Android Studio или любой другой IDE от компании JetBrains. Поддержка Go в GoLand включает в себя такие вещи, как рефакторинг, выделение синтаксиса, автодополнение и навигация по коду, всплывающие подсказки с описанием типов и функций, отладчик, отслеживание покрытия кода и многое другое. Помимо поддержки языка Go, среда разработки

Рис. 1.2. GoLand

GoLand также предлагает инструменты для работы с JavaScript/HTML/CSS и базами данных SQL. В отличие от редактора кода VS Code, для использования среды разработки GoLand вам не потребуется скачивать никаких дополнительных инструментов.

Если у вас уже есть подписка на IntelliJ IDEA Ultimate (или право на бесплатное использование этого продукта), можете добавить поддержку Go в него, установив соответствующий плагин. В противном случае придется заплатить за среду разработки GoLand, у которой нет бесплатной версии.

Онлайн-песочница

Существует еще один важный инструмент для разработки на языке Go, который к тому же не требует установки. Перейдя по адресу http://play.golang.org, вы попадете на страницу онлайн-песочницы для языка Go, внешний вид которой показан на рис. 1.3. Если вам приходилось использовать такие инструменты командной строки, как irb, node или python, то вы увидите, что работа с этой онлайн-песочницей осуществляется во многом так же. Она позволяет вам запускать и показывать другим пользователям небольшие программы. Введите свою программу в поле ввода и нажмите кнопку Run (Выполнить) для ее выполнения. Нажатие кнопки Format (Форматировать) запустит для вашей программы

Рис. 1.3. Онлайн-песочница

команду gofmt и, если при этом будет установлен флажок Imports (Импорты), также приведет в порядок операторы импорта, как это делает утилита goimports. Кнопка Share (Поделиться) позволяет создать уникальный URL-адрес для того, чтобы предоставить ссылку на программу другим пользователям или вернуться к работе над ней в дальнейшем (хотя эти ссылки и сохраняются в течение долгого времени, я все же не стал бы использовать онлайн-песочницу в качестве репозитория исходного кода).

Как показывает рис. 1.4, вы даже можете сымитировать работу с несколькими файлами, отделив каждый файл с помощью строки вида ––filename.go--.

Используя онлайн-песочницу, не забывайте о том, что она работает на другой машине (а если быть точнее, на машине компании Google), что ограничивает вашу свободу действий. При этом всегда используется последняя стабильная версия языка Go. Вы не можете устанавливать сетевые соединения, и, кроме того, ваш процесс может быть остановлен, если он будет работать слишком долго или задействовать слишком много памяти. Если в вашей программе используется время, установите в качестве начала отсчета 10 ноября 2009 года, 23:00:00 UTC (это дата и время первой официальной презентации языка Go). Однако даже эти ограничения не мешают онлайн-песочнице быть очень полезным инструментом,

Рис. 1.4. Онлайн-песочница поддерживает использование нескольких файлов

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

Никогда не размещайте в онлайн-песочнице такую конфиденциальную информацию, как сведения о вашей личности, пароли и секретные ключи! Если вы нажмете кнопку Share (Поделиться), то эта информация будет сохранена на серверах компании Google и станет доступной для всех пользователей, получивших соответствующую ссылку. Если вы по ошибке предоставили доступ к такой информации, свяжитесь с компанией Google по адресу [email protected] и сообщите, какой URL-адрес вам нужно удалить и по какой причине это нужно сделать.

make-файлы

IDE удобно использовать, но трудно автоматизировать. Сегодня процесс программной разработки подразумевает использование воспроизводимых и автоматизируемых операций компиляции, которые может выполнять кто угодно, где угодно и когда угодно, что позволяет не обращать внимания на распространенную отговорку разработчиков: «На моей машине все работает!» Реализовать такой подход можно с помощью скрипта, в котором будут определены этапы процесса компиляции. Go-разработчики для этой цели используют утилиту make. Если вы не знакомы с этой утилитой, напомню, что она с 1976 года применяется для компиляции программ в операционных системах Unix.

Например, в случае нашего простого проекта можно использовать следующий make-файл:

.DEFAULT_GOAL := build

fmt:

        go fmt ./...

.PHONY:fmt

lint: fmt

        golint ./...

.PHONY:lint

vet: fmt

        go vet ./...

.PHONY:vet

build: vet

        go build hello.go

.PHONY:build

Даже если вам не приходилось использовать make-файлы раньше, будет совсем не трудно разобраться в том, что здесь происходит. Каждая из выполняемых операций называется целью. Директива цели по умолчанию .DEFAULT_GOAL указывает, какая цель должна выполняться в том случае, если не будет указано ни одной цели. В данном случае в качестве цели по умолчанию задана операция build. Далее следуют определения целей. В каждом из них сначала указывается имя цели, а за ним, после знака двоеточия (:), — имена целей, запущенных перед выполнением данной цели (как, например, vet в определении build:vet). Задачи, которые выполняются целью, находятся в строках с отступом после цели. (Директива фиктивной цели .PHONY не дает утилите make запутаться в том случае, если в вашем проекте будет создан каталог с таким же именем, как у цели.)

Разместив этот make-файл в каталоге ch1, выполните следующую команду:

make

На экран будет выведено следующее:

go fmt ./...

go vet ./...

go build hello.go

Таким образом, с помощью всего одной команды вы обеспечите правильное форматирование кода, проверите его на наличие неочевидных программных ошибок и скомпилируете его. Вы также можете запустить только линтер с помощью команды makelint, только утилиту vet с помощью команды makevet или только средство форматирования с помощью команды makefmt. Возможно, это и нельзя назвать большим улучшением, однако гарантированный запуск средств форматирования и статического анализа перед тем, как разработчик (или скрипт, запущенный сервером непрерывной интеграции) запустит операцию компиляции, означает, что вы никогда не пропустите ни одного шага.

Одним из недостатков make-файлов является то, что они требуют определенной внимательности: каждую из указанных для цели задач нужно обязательно снабдить отступом с помощью символа табуляции. Поддержка этих файлов также не входит в число стандартных возможностей операционной системы Windows. Если вы собираетесь писать Go-код на машине с Windows, вам сначала потребуется установить утилиту make. Самый простой способ это сделать сводится к тому, чтобы сначала установить менеджер пакетов наподобие Chocolatey (https://chocolatey.org), а затем установить утилиту make с его помощью (в случае Chocolatey это можно сделать с помощью команды chocoinstallmake).

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

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

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