Skip to content

Instantly share code, notes, and snippets.

@5kr1p7

5kr1p7/VSCode-Go.md

Created March 7, 2025 08:44
Show Gist options
  • Save 5kr1p7/b4739bb7ac89fc80f97d3a17823ec204 to your computer and use it in GitHub Desktop.
Save 5kr1p7/b4739bb7ac89fc80f97d3a17823ec204 to your computer and use it in GitHub Desktop.
Download ZIP
Raw
VSCode-Go.md

VS Code — Go линтинг и форматирование

В экосистеме GoLang существуют инструменты, аналогичные Prettier и ESLint, которые помогают форматировать код, проверять его на ошибки и поддерживать единый стиль. Основные инструменты для Go — это gofmt (форматирование) и golint/staticcheck (линтинг). Для более современной и мощной проверки стиля и ошибок часто используется golangci-lint, который объединяет множество линтеров в одном инструменте.

Ниже приведена подробная инструкция по настройке этих инструментов в проекте Go и их интеграции с VS Code, включая автоматическое форматирование и линтинг при сохранении.

1. Инструменты для GoLang, аналогичные Prettier и ESLint

Форматирование (аналог Prettier):

  • gofmt: Это стандартный инструмент форматирования кода в Go, встроенный в стандартную библиотеку Go. Он автоматически форматирует код в соответствии с официальными рекомендациями Go. Обычно используется как часть команды go fmt.
  • goimports: Расширение для gofmt, которое не только форматирует код, но и автоматически управляет импортами (добавляет нужные, удаляет неиспользуемые). Это более популярный выбор для автоматического форматирования.

Линтинг (аналог ESLint):

  • golangci-lint: Это наиболее популярный инструмент линтинга для Go. Он объединяет множество линтеров (например, golint, staticcheck, errcheck, govet и другие) в одном инструменте, предоставляя мощную проверку кода на ошибки, стиль и потенциальные проблемы.
  • golint: Устаревший инструмент для проверки стиля кода. Сейчас рекомендуется использовать golangci-lint, так как golint больше не поддерживается.
  • staticcheck: Современный инструмент для статического анализа кода, который проверяет код на ошибки, неэффективности и потенциальные баги. Он интегрирован в golangci-lint, но может использоваться отдельно.

2. Установка инструментов

Перед настройкой VS Code установите необходимые инструменты в вашей системе.

2.1. Установите Go

Убедитесь, что у вас установлен Go (скачать можно с golang.org). Проверьте версию:

go version

2.2. Установите goimports

Установите goimports для форматирования и управления импортами:

go install golang.org/x/tools/cmd/goimports@latest

2.3. Установите golangci-lint

Установите golangci-lint для линтинга:

go install github.com/golangci/golangci-lint/cmd/golangci-lint@latest

После установки убедитесь, что golangci-lint доступен в вашей системе:

golangci-lint --version

2.4. Настройте проект

Для использования golangci-lint в проекте создайте файл конфигурации .golangci.yml в корне проекта. Пример минимальной конфигурации:

run:
  timeout: 5m

linters:
  enable:
    - gofmt
    - goimports
    - golint
    - staticcheck
    - errcheck
    - vet
    - unused
    - ineffassign

issues:
  exclude-rules:
    - linters: [golint]
      text: "should have comment"

Эта конфигурация включает несколько популярных линтеров и задает базовые правила. Вы можете настроить ее под свои нужды, добавив или отключив линтеры (см. документацию golangci-lint).

2.5. Добавьте скрипты в Makefile или package.json (опционально)

Для удобства можно добавить команды для форматирования и линтинга в ваш проект. Если вы используете Makefile:

.PHONY: fmt lint

fmt:
        goimports -w .
        go fmt ./...

lint:
        golangci-lint run

Или, если вы используете package.json (например, в проекте с фронтендом и бэкендом на Go):

{
  "scripts": {
    "fmt": "goimports -w . && go fmt ./...",
    "lint": "golangci-lint run"
  }
}

Теперь вы можете запускать форматирование и линтинг командами make fmt, make lint или npm run fmt, npm run lint.

3. Настройка VS Code для GoLang

Теперь настроим VS Code для автоматического форматирования и линтинга при сохранении, а также для отображения ошибок в реальном времени.

3.1. Установите расширение Go

  1. Откройте панель расширений в VS Code (Ctrl+Shift+X).
  2. Найдите расширение Go (разработчик: Go Team at Google) и установите его.
  3. После установки перезапустите VS Code, чтобы активировать расширение.

Расширение Go предоставляет поддержку Go в VS Code, включая автодополнение, отладку, линтинг и форматирование. При первом использовании оно может предложить установить дополнительные инструменты (например, gopls — Go language server). Согласитесь на установку.

3.2. Настройте форматирование при сохранении

Чтобы код автоматически форматировался с помощью goimports при сохранении:

  1. Откройте настройки VS Code (Ctrl + ,).

  2. Найдите настройку Editor: Format On Save и включите ее (если еще не включена).

  3. Настройте Go для использования goimports как форматтера:

    • В строке поиска настроек введите "go format tool".
    • Найдите Go: Format Tool и выберите goimports.

  4. Откройте файл настроек VS Code в формате JSON:

    • Нажмите Ctrl + Shift + P, введите "Preferences: Open Settings (JSON)" и выберите этот пункт.
    • Или откройте файл вручную: C:\Users\<ВашПользователь>\AppData\Roaming\Code\User\settings.json (в Windows).

  5. Добавьте следующие настройки в settings.json:

    {
  "editor.formatOnSave": true,
  "go.formatTool": "goimports",
  "go.useLanguageServer": true,
  "[go]": {
    "editor.formatOnSave": true,
    "editor.defaultFormatter": "golang.go"
  }
}

    Объяснение настроек:

    • "editor.formatOnSave": true — включает форматирование при сохранении для всех типов файлов.
    • "go.formatTool": "goimports" — указывает, что для форматирования Go-файлов используется goimports.
    • "go.useLanguageServer": true — включает Go language server (gopls) для автодополнения, линтинга и других функций.
    • "[go]": { ... } — задает настройки форматирования только для Go-файлов, чтобы избежать конфликтов с другими языками.

3.3. Настройте линтинг с помощью golangci-lint

Расширение Go поддерживает интеграцию с golangci-lint для линтинга. Чтобы включить линтинг и отображение ошибок в реальном времени:

  1. Убедитесь, что golangci-lint установлен (см. шаг 2.3 выше).
  2. Настройте расширение Go для использования golangci-lint:
    • Откройте настройки VS Code (Ctrl + ,).
    • В строке поиска введите "go lint tool".
    • Найдите Go: Lint Tool и выберите golangci-lint.

. Включите линтинг при сохранении и в реальном времени:

  • Откройте файл настроек settings.json (см. выше).

  • Добавьте следующие настройки:

    {
  "go.lintTool": "golangci-lint",
  "go.lintOnSave": "file",
  "go.lintFlags": ["--fast"],
  "editor.codeActionsOnSave": {
    "source.fixAll": true
  }
}

Объяснение настроек:

  • "go.lintTool": "golangci-lint" — указывает, что для линтинга используется golangci-lint.
  • "go.lintOnSave": "file" — включает линтинг при сохранении файла (можно установить "package" для линтинга всего пакета или "workspace" для линтинга всего рабочего пространства).
  • "go.lintFlags": ["--fast"] — добавляет флаги для golangci-lint, чтобы ускорить линтинг (опционально, можно настроить под свои нужды).
  • "editor.codeActionsOnSave": { "source.fixAll": true } — включает автоматическое исправление ошибок, если golangci-lint поддерживает исправления (некоторые линтеры в golangci-lint, например gofmt или goimports, могут автоматически исправлять код).

3.4. Настройте отображение ошибок в реальном времени

Чтобы ошибки линтинга отображались в редакторе в реальном времени (подчеркивание красным, подсказки и т.д.):

  1. Убедитесь, что Go language server (gopls) включен:

    • В settings.json должна быть настройка:

      {
  "go.useLanguageServer": true
}

  2. Убедитесь, что golangci-lint интегрирован с gopls:

    • gopls автоматически использует golangci-lint для диагностики, если он настроен как инструмент линтинга (go.lintTool).
    • Если вы видите сообщение "No linting diagnostics", проверьте, что golangci-lint установлен и доступен в PATH.

  3. Настройте уровень диагностики:

    • Если вы хотите видеть не только ошибки, но и предупреждения, добавьте в settings.json:

      {
  "go.diagnostic.vulncheck": "Imports"
}

    Это включит дополнительные проверки безопасности (опционально).

3.5. Настройте горячие клавиши (опционально)

Для удобства можно настроить горячие клавиши для выполнения линтинга или форматирования вручную:

  1. Откройте панель команд (Ctrl + Shift + P) и выберите "Preferences: Open Keyboard Shortcuts (JSON)".

  2. Добавьте свои сочетания клавиш, например:

    [
  {
    "key": "ctrl+alt+l",
    "command": "go.lint.file",
    "when": "editorTextFocus && editorLangId == 'go'"
  },
  {
    "key": "ctrl+alt+f",
    "command": "editor.action.formatDocument",
    "when": "editorTextFocus && editorLangId == 'go'"
  }
]
    • Ctrl+Alt+L — запуск линтинга текущего файла.
    • Ctrl+Alt+F — запуск форматирования документа.

3.6. Проверьте интеграцию с Git хуками

Чтобы минимизировать отклонение коммитов из-за ошибок линтинга, убедитесь, что VS Code работает в связке с Git хуками (например, настроенными через husky, если вы используете его в проекте с фронтендом, или через стандартные Git хуки для Go-проектов). Если вы настроили автоматическое исправление при сохранении, большинство ошибок будет исправлено до того, как вы сделаете коммит.

  1. Настройте Git хук pre-commit для запуска golangci-lint:

    • Создайте файл .git/hooks/pre-commit (или используйте husky, если он настроен).

    • Добавьте в него:

      #!/bin/sh
golangci-lint run
if [ $? -ne 0 ]; then
  echo "Linting failed, commit aborted"
  exit 1
fi

    • Сделайте файл исполняемым (если вы работаете в Windows, используйте Git Bash или WSL для выполнения этой команды):

      chmod +x .git/hooks/pre-commit

  2. Проверьте, что при сохранении файлов в VS Code ошибки исправляются автоматически:

    • Откройте Go-файл, добавьте код с ошибками (например, неиспользуемый импорт или неправильное форматирование).
    • Нажмите Ctrl + S (сохранить) и убедитесь, что код форматируется, а импорты исправляются.

3.7. Решение возможных проблем

Если что-то работает не так, вот несколько шагов для устранения неполадок:

  1. Форматирование не работает при сохранении:

    • Убедитесь, что goimports установлен и доступен в PATH (goimports --version).
    • Проверьте, что в настройках VS Code указан правильный инструмент форматирования (go.formatTool).
    • Убедитесь, что опция editor.formatOnSave включена.

  2. Линтинг не показывает ошибки в редакторе:

    • Убедитесь, что golangci-lint установлен и доступен в PATH (golangci-lint --version).
    • Проверьте, что в настройках VS Code указан правильный инструмент линтинга (go.lintTool).
    • Перезапустите Go language server: нажмите Ctrl + Shift + P, выберите "Go: Restart Language Server".
    • Убедитесь, что в корне проекта есть файл .golangci.yml, если вы используете кастомные настройки.

  3. Конфликты между форматированием и линтингом:

    • Убедитесь, что golangci-lint настроен для использования goimports и gofmt как линтеров (они включены в .golangci.yml).
    • Если вы видите дублирующиеся ошибки, отключите лишние линтеры в .golangci.yml.

  4. Проблемы с производительностью:

    • Если golangci-lint работает медленно, добавьте флаг --fast в go.lintFlags или настройте .golangci.yml, чтобы отключить ненужные линтеры.

3.8. Пример полной конфигурации settings.json

Для удобства вот пример полной конфигурации settings.json для Go-проекта:

{
  "editor.formatOnSave": true,
  "go.formatTool": "goimports",
  "go.useLanguageServer": true,
  "go.lintTool": "golangci-lint",
  "go.lintOnSave": "file",
  "go.lintFlags": ["--fast"],
  "editor.codeActionsOnSave": {
    "source.fixAll": true
  },
  "[go]": {
    "editor.formatOnSave": true,
    "editor.defaultFormatter": "golang.go"
  }
}

Итог

После выполнения всех шагов ваш VS Code будет настроен для Go-разработки следующим образом:

  • Код будет автоматически форматироваться с помощью goimports при сохранении (аналог Prettier).
  • Ошибки и предупреждения линтинга будут отображаться в реальном времени с помощью golangci-lint (аналог ESLint).
  • Некоторые ошибки будут автоматически исправляться при сохранении (например, неиспользуемые импорты).
  • Git хуки (если настроены) будут запускать линтинг перед коммитами, минимизируя вероятность ошибок в репозитории.
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment