← назад к разделу

В отличие от многих языков, где сборщик, тесты, форматтер и менеджер зависимостей — это отдельные сторонние программы, в Go всё это входит в одну команду go. Разберём, что в ней есть и как этим пользоваться с первого дня.

Зачем единый инструмент

Когда вы устанавливаете Go, вы получаете не только компилятор, но и весь набор для повседневной работы: сборку, запуск, тесты, форматирование, проверку кода и работу с зависимостями. Не нужно выбирать менеджер пакетов, спорить про линтер или настраивать форматтер — всё уже решено за вас и работает одинаково в любом проекте.

Короткая формула: одна команда go — весь цикл разработки.

Посмотреть список подкоманд можно так:

go help        # список всех команд
go help build  # подробности по конкретной команде

Модули: go mod, go.mod, go.sum

Модуль — это единица версионирования и распространения кода в Go. Грубо говоря, модуль — это ваш проект (или библиотека) с зафиксированным списком зависимостей. Новый проект начинается с создания модуля:

go mod init example.com/myapp

Эта команда создаёт файл go.mod — манифест проекта. Внутри он выглядит примерно так:

module example.com/myapp

go 1.22

require (
    github.com/google/uuid v1.6.0
)

• module — путь (имя) модуля; по нему другие будут импортировать ваш код.
• go — минимальная версия языка.
• require — прямые зависимости с их версиями.

Рядом появляется файл go.sum — это контрольные суммы скачанных зависимостей. Он гарантирует, что у вас и у коллеги скачается ровно один и тот же код. Оба файла — go.mod и go.sum — коммитятся в репозиторий.

Полезные команды для зависимостей:

go get github.com/google/uuid@v1.6.0  # добавить или обновить зависимость
go mod tidy      # привести go.mod и go.sum в порядок: добавить недостающее, убрать неиспользуемое
go mod download  # скачать зависимости в локальный кеш

go mod tidy стоит запускать после того, как вы добавили или убрали импорты — он сам разберётся, что нужно прописать в go.mod.

GOPATH остался в прошлом

Если вы встретите старые статьи про Go, там почти наверняка будет упоминаться GOPATH — единый каталог, внутри которого должен был лежать весь код, а зависимости различались только по пути импорта, без версий. Это было неудобно: проект нельзя было держать где угодно, а версии зависимостей толком не фиксировались.

Начиная с Go 1.16 модули (go.mod) — режим по умолчанию. Теперь проект лежит в любой папке, версии зависимостей записаны явно, а GOPATH остался лишь как место для кеша скачанных модулей. Запоминать про него ничего не нужно — просто работайте с go mod.

Сборка и запуск: build и run

Две основные команды:

go run .         # скомпилировать и сразу запустить (удобно при разработке)
go build         # собрать исполняемый файл в текущей папке
go build -o app  # собрать с конкретным именем файла

go run ничего не оставляет на диске — компилирует во временную папку и запускает; хорош для быстрой проверки. go build создаёт один самодостаточный исполняемый файл без внешних зависимостей — его можно просто скопировать на сервер и запустить. Это одна из причин, почему Go любят для backend и утилит.

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

живой пример

package main

import (
    "fmt"
    "runtime"
)

func main() {
    fmt.Println("собрано версией", runtime.Version())
    fmt.Println("ядер видит процесс:", runtime.GOMAXPROCS(0))
}

Тесты: go test

Тесты в Go — часть языка, отдельный фреймворк не нужен. Тестовый файл лежит рядом с кодом и называется <имя>_test.go, а функции начинаются с Test:

// файл math_test.go
package math

import "testing"

func TestAdd(t *testing.T) {
    got := Add(2, 3)
    if got != 5 {
        // t.Errorf помечает тест проваленным, но продолжает выполнение
        t.Errorf("Add(2, 3) = %d; хотим 5", got)
    }
}

Запуск:

go test ./...        # прогнать тесты во всех пакетах проекта
go test -v ./...     # то же, но подробно (видно каждый тест)
go test -run TestAdd # запустить только подходящие по имени

./... — это шаблон «текущая папка и все вложенные пакеты». Он встречается во многих командах go.

Форматирование — это норма, а не вкусовщина

В Go нет споров о расстановке скобок и отступов: есть один официальный стиль и инструмент gofmt, который к нему приводит. Команда:

gofmt -w .    # отформатировать файлы на месте
go fmt ./...  # то же через обёртку go, по всем пакетам

Практически весь код в экосистеме отформатирован одинаково, поэтому чужой проект читается как свой. Большинство редакторов запускают gofmt автоматически при сохранении — это общепринятая норма, а не личное предпочтение.

Рядом есть go vet — статический анализатор, который ловит подозрительные конструкции, которые компилируются, но почти наверняка являются ошибкой (например, неверные аргументы у форматирования строк):

go vet ./...  # проверить весь проект на типичные ошибки

Стандартная библиотека

Большая часть повседневных задач в Go решается стандартной библиотекой — она входит в поставку языка и не требует зависимостей. Несколько часто используемых пакетов:

• fmt — форматированный ввод-вывод (печать, сборка строк).
• strings, strconv — работа со строками и преобразование типов.
• errors — создание и обёртывание ошибок (подробнее — в статье про ошибки).
• time — время и длительности.
• encoding/json — сериализация в JSON и обратно.
• os, io — файлы, потоки ввода-вывода, аргументы запуска.

Импортируются они по имени, без добавления в go.mod, потому что поставляются вместе с компилятором:

import (
    "fmt"
    "strings"
)

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

Структура проекта

Для маленькой программы достаточно одной папки с main.go и go.mod. Когда проект растёт, код раскладывают по пакетам — это просто папки, каждая со своим набором .go-файлов и именем пакета вверху каждого файла. Минимальный пример:

myapp/
  go.mod
  main.go        // package main — точка входа
  internal/      // код, который нельзя импортировать извне модуля
    user/
      user.go    // package user

Папка internal/ — особая: пакеты внутри неё видны только внутри вашего модуля, что удобно для кода, который не хочется отдавать наружу как публичный API.

Это базовая раскладка на уровне языка. Как организовать структуру именно backend-сервиса (слои, зависимости, точка сборки) — разбирается в статье структура Go-проекта и сборка зависимостей в backend-разделе.

Глубже: что ещё умеет команда goрасширенное

Того, что выше, хватает на первую неделю. Дальше пригодятся ещё несколько подкоманд и флагов.

go doc strings.Builder   # документация по пакету или символу, без браузера
go test -race ./...      # тесты с детектором гонок данных
go test -cover ./...     # доля кода, покрытая тестами
go install golang.org/x/tools/cmd/stringer@latest  # поставить утилиту в $GOPATH/bin
go env GOPATH GOFLAGS    # где кеш модулей и какие флаги действуют по умолчанию

Строка go 1.22 в go.mod — не пожелание, а минимальная версия: с Go 1.21 инструмент, если он старше, сам скачает нужную и соберёт ею. Утилиты, от которых зависит проект (генераторы, линтеры), с Go 1.24 записывают в go.mod директивой tool через go get -tool, и запускают как go tool имя — версия у всей команды одна. Несколько модулей в одном репозитории связывают файлом go.work (go work init, go work use ./svc), чтобы правки в одном сразу видел другой.

go vet ловит явные ошибки, а стиль и запахи кода — внешний линтер: в экосистеме де-факто это golangci-lint, который запускает десятки проверок разом, включая staticcheck и errcheck. Его настраивают один раз в репозитории и гоняют в сборке рядом с go test.

Коротко

• Весь инструментарий Go — в одной команде go: сборка, запуск, тесты, форматирование, зависимости.
• Проект — это модуль; go mod init создаёт go.mod (манифест) и go.sum (контрольные суммы); оба коммитятся.
• go mod tidy приводит зависимости в порядок после изменения импортов.
• GOPATH в прошлом — модули работают из любой папки и фиксируют версии явно.
• go run — быстро запустить, go build — собрать один самодостаточный исполняемый файл.
• Тесты встроены: файлы *_test.go, функции TestXxx, запуск go test ./....
• gofmt — единый стиль для всех; форматирование это норма. go vet ловит типичные ошибки.
• Стандартная библиотека покрывает большинство задач без сторонних зависимостей.
• Дальше первой недели: go doc, go test -race -cover, go install, директива tool в go.mod (Go 1.24), go work для нескольких модулей и golangci-lint поверх go vet.

Что почитать дальше

• Синтаксис и типы Go — с чего начинается код на Go.
• Ошибки в Go — пакет errors и принятый подход к обработке.
• Интерфейсы в Go — как устроена абстракция в языке.