Gopath golang: Всё, что вы хотели знать про GOPATH и GOROOT / Хабр
Всё, что вы хотели знать про GOPATH и GOROOT / Хабр
Несмотря на то, что Go считается одним из самых легких для входа языков, приходится регулярно слышать: «как-то все непонятно, какие-то переменные GOROOT и GOPATH нужно устанавливать». И хотя тема полностью раскрыта на официальном сайте Go, не будет лишним объяснить совсем простым языком.
TL;DR
Теперь чуть подробнее:
GOROOT
GOROOT — это переменная, указывающая, где лежит, собственно, вся бинарная сборка Go и исходные коды. Что-то вроде JAVA_HOME. Устанавливать эту переменную ручками нужно только в тех случаях, если вы ставите Go под Windows не с помощью MSI-инсталлера, а из zip-архива. Ну, или если вы хотите держать несколько версий Go, каждая в своей директории.
Раньше (до Go 1.0) эта переменная была нужна — её использовали скрипты сборки, равно как и GOARCH и GOOS. Но после Go 1.0 немного изменилась внутренняя логика работы go tool и сейчас значение GOROOT хардкодится на этапе сборки или инсталляции. Тоесть, go — дефолтно проинсталлированный — знает это значение и так. Его можно посмотреть с помощью команды:
go env GOROOT
В MacOS X это /usr/local/go/, в Linux тоже (хотя может зависеть от дистрибутива), в Windows — С:\Go.
GOPATH
А вот переменная GOPATH очень важна и нужна и её нужно установить обязательно, впрочем только один раз. Это ваш workspace, где будет лежать код и бинарные файлы всего с чем вы будете в Go работать. Поэтому выбирайте удобный вам путь и сохраняйте его в GOPATH. К примеру:
export GOPATH=~/go
export GOPATH=~/gocode
export GOPATH=~/Devel/go
export GOPATH=~/Projects/go
Ну и обязательно это сохраните в .profile или как вы там сохраняете переменные:
echo "export GOPATH=~/go" >> ~/.profile (или .bash_profile)
Всё, сделайте это один раз и забудьте. Создайте только эту директорию, если её еще и нет, и на этом готово. Теперь любой вызов go get github.com/someuser/somelib автоматически будет скачивать исходники в $GOPATH/src, а бинарный результат компиляции складывать в $GOPATH/pkg или $GOPATH/bin (для библиотек и исполняемых файлов соответственно).
PATH
Это опционально, но желательно сразу тоже сделать, раз уж вы взялись за настройку среды. Рано или поздно вы захотите пользоваться какими-то Go-программами, которые будут лежать в вашей GOPATH/bin. Чтобы их без лишних телодвижений использовать, добавьте к PATH директорию $GOPATH/bin:
export PATH=$PATH:$GOPATH/bin
Команда go install собирает и инсталлирует бинарник именно в эту директорию, поэтому это исключительно для удобства.
Структура Workspace
Теперь давайте посмотрим внимательно на структуру директории GOPATH. Возьму пример из официальной документации:
bin/
hello # программа hello
pkg/
linux_amd64/ # каталог этого уровня определяет ось и архитектуру для бинарных файлов
github.com/user/
stringutil.a # объектный бинарный файл пакета stringutil
src/
github.com/user/
hello/
hello.go # исходный код программы hello
stringutil/
reverse.go # исходный код библиотеки stringutil
Достаточно просто, не так ли? Важно понимать, что никто не обязывает называть директории в src/ по какому-то формату. Можно использовать и src/test/my_first_app/main.go и src/anyname/main.go — но если вы работаете с системами контроля версий (а вы таки работаете)), то вам это бесспорно станет удобно — утилиты go get/install используют это соглашения наименования, чтобы сделать работу с системами контроля версий безбожно простой.
Дополнительно
Переменная GOPATH аналогична стандартной PATH — можно указывать несколько директорий, через ‘:’. GOPATH=~/go:~/other_workspace. Это в очень редких случаях бывает полезно (например, для работы с внешними менеджерами зависимостей вроде gpm), но в 99% это не нужно, и просто так рекомендуется использовать только одну директорию в GOPATH.
В конце-концов, если вам нужны раздельные workspace-ы, всегда можно заменить переменную GOPATH на нужную (в скрипте сборки, к примеру). Так, собственно, и делают.
Ссылки
golang.org/doc/install
golang.org/doc/code.html
dave.cheney.net/2013/06/14/you-dont-need-to-set-goroot-really
Установка Go на Windows 10 Скриншоты + Видео
Go является простым языком программирования общего назначения, которого будет не лишним добавить в вашу коллекцию изученных языков. Проект стартовал в 2007 году, и благодаря усилиям разработчиков Google, стал тем языком Go, с которым мы можем работать сегодня. Внимание уделялось легкости и согласованности языка, его инструментов и стандартных библиотек, делая Go простым и занятным в использовании.
Содержание статьи
У Go открытый исходный код, что здорово. И не забывайте — данный язык чувствителен к регистру.
Форум Гоферов
Мы работаем над форумом для программистов на Golang. Очень нужны модераторы которые хотят помочь с ответами для новичков и помочь в развитии Go-сообщества.
Go на Форум
Уроки, статьи и Видео
Мы публикуем в паблике ВК и Telegram качественные обучающие материалы для быстрого изучения Go. Подпишитесь на нас в ВК и в Telegram. Поддержите сообщество Go программистов.
Go в ВК
Go в Telegram
Разберем процесс установки Go на Windows 10. Вы увидите, как это просто — достаточно базовых знаний о GitHub и работы с командной строкой. Конечно, это не единственный способ установки, однако он будет наиболее простым для тех, чьи знания кодирования ограничены. Просто придерживайтесь данных инструкций.
Следуйте указаниям, придерживаясь правильного порядка, чтобы потом не мучиться и не исправлять ошибки, возникшие во время процесса инсталляции.
Установка элементов в правильном порядке
- Так как зачастую Go использует бесплатные репозитории с открытым исходным кодом, сначала установить пакет Git, перейдя по ссылке;
- Перейдите на сайт инсталляции Go по ссылке. Скачайте и установите последний 64-битный набор Go для Microsoft Windows OS;
- Следуйте инструкциям по установке программы Go;
- Откройте командную строку
cmd
и наберитеgo version
; - Вывод после ввода
go version
должен выглядеть следующим образом (в зависимости от версии, она может быть у вас другая):
Создание рабочего пространства Go
Для начала подтвердим работоспособность Go. Откройте Панель Управления, затем следуйте в Система и безопасность > Система > Дополнительные параметры системы. Кликните на Переменные Среды с правой нижней стороны. Убедитесь, что у Path в Системные Переменные есть значение C:\Go\bin
.
Затем нужно создать рабочее пространство Go. Оно будет в отдельной новой папке от той, где сохранены и установлены файлы Go. К примеру, ваши установленные файлы Go могут находиться по пути C:\Go
, а создать рабочее пространство Go можно по адресу C:\Projects\Go
.
В новой папке рабочего пространства Go настраиваем три новые папки — bin
, pkg
, src
:
Создание переменной среды GOPATH
Создадим переменную GOPATH
и свяжем ее с недавно созданным рабочим пространством Go. Перейдите обратно в Панель Управления, затем в Система и потом на Переменные среды. Затем под Системные Переменные нажмите на Создать.
Рядом с Имя переменной введите GOPATH, а рядом с Значение переменной введите C:\Projects\Go:
Проверить, установлены ли пути верно можно через ввод echo %GOPATH%
в командной строке.
Тестирование установки Golang в Windows
Теперь можно проверить, действительно ли все работает правильно. Откройте командную строку и наберите: go get github.com/golang/example/hello
.
Подождите, когда код будет полностью скомпилировано (на это уйдет пару секунд), затем наберите следующую команду: %GOPATH%/bin/hello
.
Если установка была успешной, вы должны получить следующее сообщение: “Hello, Go examples!”
Надеюсь, у вас все получилось. Если же возникли какие-то ошибки или появились непонятные сообщения, наберите внизу результат командной строки: “go env”
.
При составлении данной статьи использовались указанные ниже ресурсы, которые также могут помочь при настройке Go на операционной системе Windows: Wade Wegner’s visually-simple & stylistic article.
Понравилась статья?
Поддержи наш проект, чтобы мы могли создать больше хорошего контента!
Инструкция установки Go на Ubuntu 20.04
Go является современным языком программирования, разработанным с участием Google. Он становится все более популярным в сфере разработки и предлагает обширный набор библиотек. В данном руководстве вы узнаете, как скачать и установить последнюю версию Go (версия Go 1.15 на момент публикации данного текста), а также как создать простое приложение Hello World.
Содержание статьи
Для использования данного руководства у вас должен быть доступ к системе Ubuntu 20.04, настроенной для пользователя без полномочий root
с привилегиями sudo
.
Форум Гоферов
Мы работаем над форумом для программистов на Golang. Очень нужны модераторы которые хотят помочь с ответами для новичков и помочь в развитии Go-сообщества.
Go на Форум
Уроки, статьи и Видео
Мы публикуем в паблике ВК и Telegram качественные обучающие материалы для быстрого изучения Go. Подпишитесь на нас в ВК и в Telegram. Поддержите сообщество Go программистов.
Go в ВК
Go в Telegram
Установка Go на Ubuntu
Для установки вам потребуется последняя версии Go 1.15, которую можно скачать на официальной странице. На сайте вы найдете URL для тарбола текущего бинарного релиза вместе с его хешем SHA256.
Посетите официальную страницу скачиваний Go и найдите URL для тарбола текущего бинарного релиза вместе с его хешем SHA256. Убедитесь, что вы находитесь в домашней директории и используйте curl
для получения тарбола:
cd ~
curl -O https://dl.google.com/go/go1.15.linux-amd64.tar.gz
cd ~ curl -O https://dl.google.com/go/go1.15.linux-amd64.tar.gz |
Затем вы можете использовать sha256sum
для утверждения тарбола:
sha256sum go1.15.linux-amd64.tar.gz
sha256sum go1.15.linux-amd64.tar.gz |
Образец вывода:
go1.15.linux-amd64.tar.gz
2d75848ac606061efe52a8068d0e647b35ce487a15bb52272c427df485193602 go1.15.linux-amd64.tar.gz
go1.15.linux-amd64.tar.gz 2d75848ac606061efe52a8068d0e647b35ce487a15bb52272c427df485193602 go1.15.linux-amd64.tar.gz |
Вы получите хеш, как тот, что выделен в выводе выше. Убедитесь, что он совпадает с тем, что находится на странице загрузок.
Затем, используйте команду tar
для извлечения файлов из тарбола. Флаг x
говорит tar
об извлечении, v
сообщает, что нам нужен полный вывод c подробной информацией о файлах (список извлеченных файлов), а f
говорит о том, что мы уточним название файла.
tar xvf go1.15.linux-amd64.tar.gz
tar xvf go1.15.linux-amd64.tar.gz |
Теперь в домашней папке у вас должна быть директория под названием go
. Рекурсивно измените владельца папки go
и группы к root
, и перейдите в /usr/local
:
sudo chown -R root:root ./go
sudo mv go /usr/local
sudo chown -R root:root ./go sudo mv go /usr/local |
На заметку: Хотя рекомендуется использовать локацию
/usr/local/go
, некоторые пользователи выбирают место по своему усмотрению.
Настройка GOPATH в Ubuntu
На данном этапе мы настроим некоторые пути вашей среды.
Для начала установим значение, которая сообщает Go, где искать файлы.
В конце файла добавьте следующую строку:
export GOPATH=$HOME/work
export PATH=$PATH:/usr/local/go/bin:$GOPATH/bin
export GOPATH=$HOME/work export PATH=$PATH:/usr/local/go/bin:$GOPATH/bin |
Если вы выберете альтернативное место установки Go, то и в файле выше должны быть указаны ваши пути к Go. Данный пример показывает настройки на тот случай, если Go установлен в домашней директории:
export GOROOT=$HOME/go
export GOPATH=$HOME/work
export PATH=$PATH:$GOROOT/bin:$GOPATH/bin
export GOROOT=$HOME/go export GOPATH=$HOME/work export PATH=$PATH:$GOROOT/bin:$GOPATH/bin |
Сохраните и закройте файл. Затем обновите профиль, выполнив:
Тестирование Go после установки
Теперь, когда Go установлен и пути настроены, вы можете провести тесты, чтобы убедиться, что Go работает должным образом.
Создайте новую директорию для рабочего пространства Go, куда Go будет размещать созданные файлы:
Затем создайте директорию иерархии данной папки через данную команду, чтобы создать тестовый файл. Вы можете заменить значение user
своим именем пользователя на GitHub, если вы планируете использовать Git для коммитов и хранения кода Go на GitHub. Если вы не планируете использовать GitHub для хранения и управления кодом, структура вашей папки можете отличаться, к примеру ~/my_project
.
mkdir -p work/src/github.com/user/hello
mkdir -p work/src/github.com/user/hello |
Затем создаем простой Go файл «Hello World».
nano ~/work/src/github.com/user/hello/hello.go
nano ~/work/src/github.com/user/hello/hello.go |
Внутри редактора вставьте нижеуказанный код, что использует пакеты Go, импортирует форматированные содержимого, и создает новую функцию для вывода “Hello, World” при запуске.
package main
import «fmt»
func main() {
fmt.Printf(«hello, world\n»)
}
package main
import «fmt»
func main() { fmt.Printf(«hello, world\n») } |
Данная программа выводит “hello, world”
при успешном запуске, что указывает на то, что программы Go скомпилированы верным образом. Сохраните и закройте файл, затем компилируйте его через вызов команды go install
:
go install github.com/user/hello
go install github.com/user/hello |
Вы можете запустить скомпилированный файл через простое выполнение команды:
Если программа возвращает “hello, world”
, тогда Go установлен успешно и является функциональным. Вы можете увидеть, что скомпилированный hello
установлен, использовав команду which
:
Вывод:
/home/user/work/bin/hello
/home/user/work/bin/hello |
Заключение
После скачивания и установки последней версии Go, а также настройки путей, вы получили систему, что можно использовать для Go-разработки.
Понравилась статья?
Поддержи наш проект, чтобы мы могли создать больше хорошего контента!
Прагматическое руководство / Блог компании OTUS. Онлайн-образование / Хабр
Всем привет. В преддверии старта курса «Разработчик Golang» подготовили для вас еще один интересный перевод.
Модули — это способ борьбы с зависимостями в Go. Изначально представленные в качестве эксперимента, модули предполагают вывести на поле в качестве нового стандарта для управления пакетами с версии 1.13.
Я нахожу эту тему достаточно необычной для новичков, пришедших с других языков, и поэтому я решил собрать здесь некоторые соображения и советы, чтобы помочь другим, таким же как я, получить представление об управлении пакетами в Go. Мы начнем с общего знакомства, а затем перейдем к менее очевидным аспектам, включая использование папки vendor, использование модулей с Docker в разработке, зависимости инструментов и т. д.
Если вы уже знакомы с модулями Go и знаете Wiki, как свои пять пальцев, эта статья, вероятно, не будет для вас очень полезной. Но для остальных, однако, она может сэкономить несколько часов проб и ошибок.
Так что если вам по пути, запрыгивайте и наслаждайтесь поездкой.
Быстрый запуск
Если в ваш проект уже интегрировано управление версиями, вы можете просто запустить
go mod init
Или указать путь к модулю вручную. Это что-то вроде имени, URL и пути импорта для вашего пакета:
go mod init github.com/you/hello
Эта команда создаст файл go.mod
, который одновременно определяет требования проекта и лочит зависимости на их правильные версии (в качестве аналогии для вас, это как package.json
и package-lock.json
, объединенные в один файл):
module github.com/you/hello
go 1.12
Запустите go get
, чтобы добавить новую зависимость в ваш проект:
Обратите внимание, что хотя вы не можете указать диапазон версий с помощью go get, то что вы здесь определяете, это не конкретная, а минимальная версия. Как мы увидим позже, есть способ изящно актуализировать зависимости в соответствии с semver.
# use Git tags
go get github.com/go-chi/[email protected]
# or Git branch name
go get github.com/go-chi/chi@master
# or Git commit hash
go get github.com/go-chi/chi@08c92af
Теперь наш файл go.mod
выглядит следующим образом:
module github.com/you/hello
go 1.12
require github.com/go-chi/chi v4.0.2+incompatible // indirect
Суффикс +incompatible
добавляется ко всем пакетам, которые еще не настроены под модули Go или нарушают их правила управления версиями.
Поскольку мы еще нигде в нашем проекте не импортировали этот пакет, он был помечен как // indirect
. Мы можем привести это в порядок с помощью следующей команды:
go mod tidy
В зависимости от текущего состояния вашего репозитория, она либо удалит неиспользуемый модуль, либо удалит комментарий // indirect
.
Если какая-либо зависимость сама по себе не имеет go.mod
(например, она еще не настроена под модули), тогда все ее зависимости будут записаны в родительский файл go.mod
(как вариант, ваш файл go.mod)
вместе с комментарием // indirect
, чтобы указать, что они там не от прямого импорта в ваш модуль.
В глобальном плане цель go mod tidy
состоит также в добавлении любых зависимостей, необходимых для других комбинаций ОС, архитектур и тегов сборки. Обязательно запускайте ее перед каждым релизом.
Следите также за тем, чтобы после добавления зависимости был создан файл go.sum
. Вам может показаться, что это lock-файл. Но на самом деле go.mod
уже предоставляет достаточно информации для на 100% воспроизводимых сборок. Файл go.sum
создается в проверочных целях: он содержит ожидаемые криптографические контрольные суммы содержимого отдельных версий модуля.
Отчасти потому, что go.sum
не является lock-файлом, он сохраняет записанные контрольные суммы для версии модуля даже после того, как вы перестанете использовать этот модуль. Это позволяет проверять контрольные суммы, если вы позже возобновите его использование, что обеспечивает дополнительную безопасность.
Только что мигрировали mkcert в модули (с vendor/ для обратной совместимости) и все прошло гладко
https://github.com/FiloSottile/mkcert/commit/26ac5f35395fb9cba3805faf1a5a04d260271291$ GO111MODULE=on go1.11rc1 mod init $ GO111MODULE=on go1.11rc1 mod vendor $ git add go.mod go.sum vendor $ git rm Gopkg.lock Gopkg.toml Makefile
FAQ: Должен ли я коммитить
go.sum
в git?
A: Определенно да. С ним обладателям ваших источников не нужно доверять другим репозиториям GitHub и владельцам пользовательских путей импорта. Уже на пути к нам нечто получше, ну а пока это та же модель, что и хэши в lock-файлах.
Команды go build
и go test
, автоматически загрузят все отсутствующие зависимости, хотя вы можете сделать это явно с помощью go mod download
, чтобы предварительно заполнить локальные кэши, которые могут оказаться полезными для CI.
По умолчанию все наши пакеты из всех проектов загружаются в каталог $GOPATH/pkg/mod
. Мы обсудим это подробнее позже.
Обновление версий пакетов
Вы можете использовать go get -u
или go get -u=patch
для обновления зависимостей до последней минорной версии или патча соответственно.
Но вы не можете обновиться так до мажорных версий. Код, включаемый в модули Go, должен технически соответствовать следующим правилам:
- Соответствовать semver (пример тега VCS v1.2.3).
- Если модуль версии v2 или выше, мажорная версия модуля должна быть включена как
/vN
в конце пути модуля, используемого в файлеgo.mod
, и в пути импорта пакета:
import "github.com/you/hello/v2"
По-видимому, это сделано для того, чтобы разные версии пакетов могли быть импортированы в одной сборке (см. diamond dependency problem).
В двух словах, Go ожидает, что вы будете очень осмотрительны при внесении мажорных версий.
Замена импортированных модулей
Вы можете указать необходимый модуль для своего собственного форка или даже локального пути к файлу, используя директиву replace
:
go mod edit -replace github.com/go-chi/chi=./packages/chi
Результат:
module github.com/you/hello
go 1.12
require github.com/go-chi/chi v4.0.2+incompatible
replace github.com/go-chi/chi => ./packages/chi
Вы можете удалить строку вручную или запустить:
go mod edit -dropreplace github.com/go-chi/chi
Попроектное управление зависимостями
Исторически весь код Go хранился в одном гигантском монорепозитории, потому что именно так Google организовывает свою кодовую базу, и это сказывается на дизайне языка.
Модули Go — это своего рода отступление от этого подхода. Вам больше не нужно хранить все свои проекты в $GOPATH
.
Тем не менее, технически все ваши загруженные зависимости все еще помещаются в $GOPATH/pkg/mod
. Если вы используете Docker-контейнеры при локальной разработке, это может стать проблемой, поскольку зависимости хранятся вне проекта. По умолчанию они просто не видны в вашей IDE.
Обычно это не проблема для других языков, но это то, с чем я впервые столкнулся при работе с кодовой базой Go.
К счастью, есть несколько (недокументированных) способов решения этой проблемы.
Вариант 1. Установите GOPATH внутри каталога вашего проекта.
На первый взгляд это может показаться нелогичным, но если вы запускаете Go из контейнера, вы можете переопределить его GOPATH, чтобы он указывал на каталог проекта для того, чтобы пакеты были доступны из хоста:
version: '3.7'
services:
app:
command: tail -f /dev/null
image: golang:1.12.6-stretch
environment:
# Все ваши зависимости будут расположены прямо здесь - /code/.go/pkg/mod
- GOPATH=/code/.go
ports:
- 8000:8000
volumes:
- ./:/code:cached
working_dir: /code
Популярные IDE должны иметь возможность установить GOPATH на уровне проекта (рабочей области):
Единственный недостаток этого подхода — отсутствие взаимодействия со средой выполнения Go на хост-компьютере. Вы должны выполнять все команды Go внутри контейнера.
Вариант 2: Вендоринг ваших зависимостей
Еще один способ — скопировать зависимости вашего проекта в папку vendor
:
go mod vendor
Следует сразу отметить: мы НЕ разрешаем Go прямую загрузку материалов в папку vendor: с модулями это невозможно. Мы просто копируем уже загруженные пакеты.
К тому же, если вы отвендорите свои зависимости, как в примере выше, затем очистите $GOPATH/pkg/mod
, а затем попробуйте добавить несколько новых зависимостей в ваш проект, вы увидите следующее:
- Go перестроит кэш загрузки для всех пакетов по
$GOPATH/pkg/mod/cache
. - Все загруженные модули будут скопированы в
$GOPATH/pkg/mod
. - И, наконец, Go скопирует эти модули в
vendor
папку, удаляя примеры, тесты и некоторые другие файлы, от которых вы напрямую не зависите.
Более того, в этой недавно созданной vendor-папке отсутствует много вещей:
Типичный файл Docker Compose выглядит следующим образом (обратите внимание на привязки томов):
version: '3.7'
services:
app:
command: tail -f /dev/null
image: golang:1.12.6-stretch
ports:
- 8000:8000
volumes:
# Это кэш модулей go, без него вам придется повторно загружать все зависимости после перезапуска контейнера
- modules:/go/pkg/mod/cache
- ./:/code:cached
working_dir: /code
volumes:
modules:
driver: local
Обратите внимание, что я НЕ комичу эту vendor -папку в систему контроля версий или не собираюсь использовать ее в продакшене. Это строго локальный сценарий разработки, который обычно можно найти в некоторых других языках.
Однако, когда я читаю комментарии от некоторых мейнтейнеров Go и некотроые предложения, связанные с частичным вендорингом (ЧЕ?), у меня складывается впечатление, что изначально эта фича предназначалась не для этого юзкейса.
Один из комментаторов на reddit помог мне пролить свет на это:
Обычно люди вендорят свои зависимости по таким причинам, как желание иметь герметичные сборки без доступа к сети, а также наличия копии готовых зависимостей в случае отказа github или исчезновения репозитория, и возможность более легкого аудита изменений в зависимостях с использованием стандартных инструментов VCS и т. д.
Да, не похоже на что-либо из того, что может меня заинтересовать.
Согласно команде Go, вы можете запросто подключить вендоринг, установив переменную среды GOFLAGS=-mod=vendor
. Я не рекомендую так делать. Использование флагов просто сломает go get
без предоставления каких-либо других преимуществ для вашего ежедневного рабочего процесса:
На самом деле, единственное место где вам нужно подключить вендоринг — это ваше IDE:
После нескольких проб и ошибок я пришел к следующей процедуре для добавления вендорных зависимостей в этом подходе.
Шаг 1. Требование
Вы можете потребовать зависимость с помощью go get
:
go get github.com/rs/[email protected]
Шаг 2. Импорт
Затем импортируйте его куда-нибудь в своем коде:
import (
_ "github.com/rs/zerolog"
)
Шаг 3. Вендоринг
Наконец, отвендорите ваши зависимости заново:
go mod vendor
Существует ожидающее рассмотрения предложение разрешить go mod vendor принимать определенные шаблоны модулей, которые могут решить (а могут и не решить) некоторые из проблем связанные с этим рабочим процессом.
go mod vendor
уже автоматически требует пропущенные импорты, поэтому шаг 1 является необязательным в этом рабочем процессе (если вы не хотите указывать ограничения версии). Однако, без шага 2 она не подхватит загруженный пакет.
Этот подход лучше взаимодействует с хост-системой, но он довольно запутан, когда дело доходит до редактирования ваших зависимостей.
Лично я думаю, что переопределение GOPATH является более чистым подходом, поскольку он не жертвует функциональность go get
. Тем не менее, я хотел показать обе стратегии, потому что папка vendor может быть привычнее для людей, пришедших с других языков, таких как PHP, Ruby, Javascript и т. д. Как вы можете увидеть из махинаций, описанных в этой статье, это не особенно хороший выбор для Go.
Зависимости инструментов
Нам может понадобиться установить некоторые инструменты на основе Go, которые не импортируются, а используются как часть среды разработки проекта. Простым примером такого инструмента является CompileDaemon, который может наблюдать за вашим кодом на предмет изменений и перезапускать ваше приложение.
Официально рекомендуемый подход заключается в добавлении tools.go
файла(имя не имеет значения) со следующим содержанием:
// +build tools
package tools
import (
_ "github.com/githubnemo/CompileDaemon"
)
- Ограничение
// +build tools
не позволяет вашим обычным сборкам фактически импортировать ваш инструмент. - Выражение import позволяет командам go точно записывать информацию о версии ваших инструментов в файл
go.mod
вашего модуля.
Ну вот и все. Я надеюсь, что вы не будете так же озадачены, как я, когда я впервые начал использовать модули Go. Вы можете посетить Go Modules wiki для получения более подробной информации.
Успеть на курс.
Как создать простой микросервис на Golang и gRPC и выполнить его контейнеризацию с помощью Docker
Привет, Хабр! представляю вашему вниманию перевод статьи «Go, gRPC and Docker» автора Mat Evans.
Существует множество статей о совместном использовании Go и Docker. Создавать контейнеры, способные взаимодействовать с клиентами и между собой, очень легко. Далее следует небольшой пример того, как это делается на базовом уровне.
Что мы создаем?
Мы будем создавать очень простые клиент и сервер, взаимодействующие между собой при помощи gRPC. Сервер при этом будет находиться внутри Docker-контейнера, чтобы его можно было легко развернуть.
Предположим, что нам нужен сервис, который принимает от клиента строку и возвращает в ответ строку с обращенным порядком символов. Например, посылаем «кот» и получаем в ответ «ток».
.proto-файл
.proto-файл описысывает, какие операции наш сервис будет осуществлять и какими данными он при этом будет обмениваться. Создаем в проекте папку proto, а в ней — файл reverse.proto
syntax = "proto3";
package reverse;
service Reverse {
rpc Do(Request) returns (Response) {}
}
message Request {
string message = 1;
}
message Response {
string message = 1;
}
Функция, которая вызывается удаленно на сервере и возвращает данные клиенту, помечается как rpc. Структуры данных, служащие для обмена информацией между взаимодействующими узлами, помечаются как message. Каждому полю сообщения необходимо присвоить порядковый номер. В данном случае наша функция принимает от клиента сообщения типа Request и возвращает сообщения типа Response.
Как только мы создали .proto-файл, необходимо получить .go-файл нашего сервиса. Для этого нужно выполнить седующую консольную команду в папке proto:
$ protoc -I . reverse.proto --go_out=plugins=grpc:.
Разумеется, сначала вам нужно выполнить сборку gRPC.
Выполнение вышеприведенной команды создаст новый .go-файл, содержащий методы для создания клиента, сервера и сообщений, которыми они обмениваются. Если мы вызовем godoc, то увидим следующее:
$ godoc .
PACKAGE DOCUMENTATION
package reverse
import "."
Package reverse is a generated protocol buffer package.
It is generated from these files:
reverse.proto
It has these top-level messages:
Request
Response
....
Клиент
Было бы неплохо, если бы наш клиент работал вот так:
reverse "this is a test"
tset a si siht
Вот код, который создает gRPC-клиент, используя структуры данных, сгенерированные из .proto-файла:
package main
import (
"context"
"fmt"
"os"
pb "github.com/matzhouse/go-grpc/proto"
"google.golang.org/grpc"
"google.golang.org/grpc/grpclog"
)
func main() {
opts := []grpc.DialOption{
grpc.WithInsecure(),
}
args := os.Args
conn, err := grpc.Dial("127.0.0.1:5300", opts...)
if err != nil {
grpclog.Fatalf("fail to dial: %v", err)
}
defer conn.Close()
client := pb.NewReverseClient(conn)
request := &pb.Request{
Message: args[1],
}
response, err := client.Do(context.Background(), request)
if err != nil {
grpclog.Fatalf("fail to dial: %v", err)
}
fmt.Println(response.Message)
}
Сервер
Сервер испозует тот же самый сгенерированный .go-файл. Однако он определяет только интерфейс сервера, логику же нам придется реализовать самостоятельно:
package main
import (
"net"
pb "github.com/matzhouse/go-grpc/proto"
"golang.org/x/net/context"
"google.golang.org/grpc"
"google.golang.org/grpc/grpclog"
)
func main() {
listener, err := net.Listen("tcp", ":5300")
if err != nil {
grpclog.Fatalf("failed to listen: %v", err)
}
opts := []grpc.ServerOption{}
grpcServer := grpc.NewServer(opts...)
pb.RegisterReverseServer(grpcServer, &server{})
grpcServer.Serve(listener)
}
type server struct{}
func (s *server) Do(c context.Context, request *pb.Request)
(response *pb.Response, err error) {
n := 0
// Сreate an array of runes to safely reverse a string.
rune := make([]rune, len(request.Message))
for _, r := range request.Message {
rune[n] = r
n++
}
// Reverse using runes.
rune = rune[0:n]
for i := 0; i < n/2; i++ {
rune[i], rune[n-1-i] = rune[n-1-i], rune[i]
}
output := string(rune)
response = &pb.Response{
Message: output,
}
return response, nil
}
Docker
Я предполагаю, что вы знаете, что такое Docker и для чего он нужен. Вот наш Dockerfile:
FROM golang:1.12
ADD . /go/src/github.com/matzhouse/go-grpc/server
RUN go install github.com/matzhouse/go-grpc/server
ENTRYPOINT ["/go/bin/server"]
EXPOSE 5300
Здесь прописан код сборки Docker-образа. Разберем его построчно.
FROM golang:1.12
Это команда обозначает, что мы хотим создать образ нашего приложения на основе заранее созданного образа, а именно golang. Это Docker-образ с уже настроенной средой для сборки и запуска программ, написанных на Go.
ADD . /go/src/github.com/matzhouse/go-grpc/server
Эта команда копирует исходный код нашего приложения в GOPATH/src контейнера.
RUN go install github.com/matzhouse/go-grpc/server
Эта команда собирает наше приложение из скопированных в контейнер исходников и устанавливает его в папку контейнера GOPATH/bin.
ENTRYPOINT ["/go/bin/server"]
Эта команда конфигурирует контейнер таким образом, чтобы он работал как исполнимая программа. В ней мы указываем путь к исполнимому файлу приложения и, при необходимости, аргументы командной строки.
EXPOSE 5300
Этой командой мы сообщаем контейнеру, какие порты должны быть доступны извне.
Запуск сервера
Нам нужно запустить контейнер с нашим серверным приложением.
Сначала необходимо построить образ на основе инструкций из Dockerfile:
$ sudo docker build -t matzhouse/grpc-server .
Sending build context to Docker daemon 31.76 MB
Step 1/5 : FROM golang
---> a0c61f0b0796
Step 2/5 : ADD . /go/src/github.com/matzhouse/go-grpc
---> 9508be6501c1
Removing intermediate container 94dc6e3a9a20
Step 3/5 : RUN go install github.com/matzhouse/go-grpc/server
---> Running in f3e0b993a420
---> f7a0370b7f7d
Removing intermediate container f3e0b993a420
Step 4/5 : ENTRYPOINT /go/bin/server
---> Running in 9c9619e45df4
---> fb34dfe1c0ea
Removing intermediate container 9c9619e45df4
Step 5/5 : EXPOSE 5300
---> Running in 0403390af135
---> 008e09b9aebd
Removing intermediate container 0403390af135
Successfully built 008e09b9aebd
Теперь мы можем увидеть данный образ в списке:
$ docker images
REPOSITORY TAG IMAGE ID
...
matzhouse/grpc-server latest 008e09b9aebd
...
Отлично! У нас есть образ нашего серверного приложения, при помощи которого можно запустить его контейнер с помошью следующей команды:
$ docker run -it -p 5300:5300 matzhouse/grpc-server
В данном случае выполняется т.н. проброс портов. Заметьте, что для него нам нужны как инструкция EXPOSE, так и аргумент -p.
Запуск клиента
Контейнеризация клиента не даст больших преимуществ, так что запустим его обычным способом:
$ go build -o reverse
$ ./reverse "this is a test"
tset a si siht
Спасибо за прочтение!
Как писать код Go (с GOPATH)
Введение
Если вы новичок в Go, просмотрите более свежие
Как написать код Go.
Этот документ демонстрирует разработку простого пакета Go и
представляет инструмент go, стандартный способ получения,
сборка и установка пакетов и команд Go.
Инструмент go
требует, чтобы вы организовали свой код в определенном
путь. Пожалуйста, прочтите этот документ внимательно.В нем объясняется самый простой способ начать установку Go.
Подобное объяснение доступно как
скринкаст.
Код организации
Обзор
- Программисты Go обычно хранят весь свой код Go в одной рабочей области .
- Рабочее пространство содержит множество хранилищ контроля версий
(например, под управлением Git). - Каждый репозиторий содержит один или несколько пакетов .
- Каждый пакет состоит из одного или нескольких исходных файлов Go в одном каталоге.
- Путь к каталогу пакета определяет его путь импорта .
Обратите внимание, что это отличается от других сред программирования, в которых каждый
проект имеет отдельную рабочую область, и рабочие области тесно привязаны к версии
управлять репозиториями.
Рабочие места
Рабочее пространство — это иерархия каталогов с двумя каталогами в корне:
-
src
содержит исходные файлы Go и -
bin
содержит исполняемые команды.
Инструмент go
создает и устанавливает двоичные файлы в каталог bin
.
Подкаталог src
обычно содержит несколько элементов управления версиями.
репозитории (например, для Git или Mercurial), которые отслеживают разработку одного
или более исходных пакетов.
Вот пример, чтобы дать вам представление о том, как выглядит рабочее пространство на практике:
bin / привет # исполняемый файл команды outyet # исполняемый файл команды src / github.com / golang / example / .git / # метаданные репозитория Git Здравствуйте/ hello.go # источник команды Outyet / main.go # источник команды main_test.go # тестовый источник stringutil / reverse.go # источник пакета reverse_test.go # тестовый источник golang.org/x/image/ .git / # метаданные репозитория Git BMP / reader.go # источник пакета writer.go # источник пакета ... (многие другие репозитории и пакеты опущены) ...
В дереве выше показано рабочее пространство, содержащее два репозитория.
(, пример
и изображение
).
Репозиторий example
содержит две команды ( hello
и outyet
) и одна библиотека ( stringutil
).
Репозиторий изображений
содержит пакет bmp
и несколько других.
Типичное рабочее пространство содержит множество исходных репозиториев, содержащих множество
пакеты и команды.Большинство программистов на Go сохраняют и все исходного кода Go.
и зависимости в единой рабочей области.
Обратите внимание, что символические ссылки , а не следует использовать для связывания файлов или каталогов в вашем рабочем пространстве.
Команды и библиотеки построены из различных типов исходных пакетов.
Мы обсудим это различие позже.
Переменная среды GOPATH
Переменная среды GOPATH
указывает местоположение вашего
Рабочее пространство.По умолчанию это каталог с именем go
внутри вашего домашнего каталога,
так что $ HOME / go
на Unix,
$ домой / вперед
на План 9,
и % USERPROFILE% \ go
(обычно C: \ Users \ YourName \ go
) в Windows.
Если вы хотите работать в другом месте, вам нужно будет
набор GOPATH
к пути к этому каталогу.
(Другой распространенный вариант — установить GOPATH = $ HOME
.)
Обратите внимание, что GOPATH
должен быть , а не .
тот же путь, что и ваша установка Go.
Команда go
env
GOPATH
печатает действующий ток GOPATH
;
он печатает местоположение по умолчанию, если переменная среды не установлена.
Для удобства добавьте подкаталог bin
рабочей области
на ваш PATH
:
$ экспорт PATH = $ PATH: $ (go env GOPATH) / bin
Сценарии в остальной части этого документа используют $ GOPATH
вместо $ (go env GOPATH) для краткости
.Чтобы скрипты выполнялись как написано
если вы не установили GOPATH,
вы можете заменить эти команды на $ HOME / go
или запустить:
$ экспорт GOPATH = $ (go env GOPATH)
Чтобы узнать больше о переменной среды GOPATH
, см.
«Помоги гопату»
.
Пути импорта
Путь импорта — это строка, которая однозначно идентифицирует пакет.
Путь импорта пакета соответствует его расположению внутри рабочей области
или в удаленном репозитории (объяснено ниже).
Пакеты из стандартной библиотеки получают короткие пути импорта, такие как
"fmt"
и "net / http"
.
Для ваших собственных пакетов вы должны выбрать базовый путь, который вряд ли
столкнуться с будущими дополнениями к стандартной библиотеке или другим внешним
библиотеки.
Если вы храните свой код где-нибудь в репозитории с исходными кодами, вам следует использовать
корень этого исходного репозитория в качестве базового пути.
Например, если у вас есть учетная запись GitHub по адресу
гитхаб.com / user
, это должен быть ваш базовый путь.
Обратите внимание, что вам не нужно публиковать свой код в удаленном репозитории перед тем, как
может построить это. Это просто хорошая привычка организовывать свой код так, как будто вы
опубликую это когда-нибудь. На практике вы можете выбрать любое произвольное имя пути,
при условии, что он уникален для стандартной библиотеки и большей экосистемы Go.
Мы будем использовать github.com/user
в качестве основного пути. Создать каталог
внутри вашего рабочего пространства, в котором будет храниться исходный код:
$ mkdir -p $ GOPATH / src / github.com / пользователь
Ваша первая программа
Чтобы скомпилировать и запустить простую программу, сначала выберите путь к пакету (мы будем использовать
github.com/user/hello
) и создайте соответствующий каталог пакета
внутри вашего рабочего пространства:
$ mkdir $ GOPATH / src / github.com / user / hello
Затем создайте внутри этого каталога файл с именем hello.go
,
содержащий следующий код Go.
основной пакет импорт "fmt" func main () { fmt.Println ("Привет, мир.") }
Теперь вы можете собрать и установить эту программу с помощью инструмента go
:
долларов иди и установи github.com/user/hello
Обратите внимание, что вы можете запустить эту команду из любой точки вашей системы. В
go Инструмент
находит исходный код, ища
github.com/user/hello
пакет внутри рабочей области, указанной
ГОПАТ
.
Вы также можете опустить путь к пакету, если вы запустите go install
из
каталог пакета:
$ cd $ GOPATH / src / github.com / user / hello $ иди и установи
Эта команда создает команду hello
, создавая исполняемый файл
двоичный. Затем он устанавливает этот двоичный файл в bin
рабочего пространства.
каталог как hello
(или в Windows hello.exe
).
В нашем примере это будет $ GOPATH / bin / hello
, что
$ HOME / go / bin / hello
.
Инструмент go
будет печатать вывод только при возникновении ошибки, поэтому, если
эти команды не производят никакого вывода, если они были успешно выполнены.
Теперь вы можете запустить программу, введя полный путь к ней в командной строке:
$ $ GOPATH / бункер / привет Привет мир.
Или, если вы добавили $ GOPATH / bin
в свой PATH
,
просто введите двоичное имя:
$ привет Привет мир.
Если вы используете систему управления версиями, сейчас самое подходящее время для инициализации
репозиторий, добавьте файлы и зафиксируйте первое изменение. Опять же, этот шаг
необязательно: вам не нужно использовать систему управления версиями для написания кода Go.
$ cd $ GOPATH / src / github.com / user / hello $ git init Инициализированный пустой репозиторий Git в /home/user/go/src/github.com/user/hello/.git/ $ git add hello.go $ git commit -m "начальная фиксация" [master (root-commit) 0b4507d] начальная фиксация 1 файл изменен, 7 прошивок (+) создать режим 100644 hello.go
Отправка кода в удаленный репозиторий оставлена в качестве упражнения для читателя.
Ваша первая библиотека
Напишем библиотеку и воспользуемся ею из программы hello
.
Опять же, первый шаг — выбрать путь к пакету (мы будем использовать
github.com/user/stringutil
) и создайте каталог пакета:
$ mkdir $ GOPATH / src / github.com / user / stringutil
Затем создайте в этом каталоге файл с именем reverse.go
с
следующее содержание.
// Пакет stringutil содержит служебные функции для работы со строками. пакет stringutil // Реверс возвращает строку аргументов, перевернутую по рунам слева направо.func Reverse (s string) string { r: = [] руна (и) для i, j: = 0, len (r) -1; яТеперь проверьте, что пакет компилируется с помощью
go build
:долларов на сборку github.com/user/stringutilИли, если вы работаете в исходном каталоге пакета, просто:
$ пойти сборкаЭто не создаст выходной файл.
Вместо этого он сохраняет скомпилированный пакет в локальном кэше сборки.После подтверждения сборки пакета
stringutil
,
измените исходныйhello.go
(который находится в
$ GOPATH / src / github.com / user / hello
), чтобы использовать его:основной пакет импорт ( "fmt" "github.com/user/stringutil" ) func main () { fmt.Println (stringutil.Reverse ("! oG, olleH")) }Установите программу
hello
:долларов иди и установи github.com/user/helloЗапустив новую версию программы, вы должны увидеть новое перевернутое сообщение:
$ привет Привет, вперед!После описанных выше шагов ваше рабочее пространство должно выглядеть так:
bin / привет # исполняемый файл команды src / github.com / user / Здравствуйте/ hello.go # источник команды stringutil / reverse.go # источник пакетаНазвания пакетов
Первый оператор в исходном файле Go должен быть
пакет наименованиегде
имя
- имя пакета по умолчанию для импорта.
(Все файлы в пакете должны использовать одно и то же имя.)
Соглашение Go заключается в том, что имя пакета является последним элементом
путь импорта: пакет импортирован как "crypto / rot13
"
следует называтьrot13
.Исполняемые команды всегда должны использовать
package main
.Не требуется, чтобы имена пакетов были уникальными.
во всех пакетах, связанных в один двоичный файл,
только то, чтобы пути импорта (их полные имена файлов) были уникальными.См. Effective Go, чтобы узнать больше о
Соглашения об именах в Go.Тестирование
Go имеет легкую среду тестирования, состоящую из
go test
команда и пакетtesting
.Вы пишете тест, создавая файл с именем, заканчивающимся на
_test.go
который содержит функции с именемTestXXX
с подписью
func (t * тестирование.T)
.
Среда тестирования запускает каждую такую функцию;
если функция вызывает функцию сбоя, напримерt.Error
или
т. Неисправность
, испытание считается несостоявшимся.Добавьте тест в пакет
stringutil
, создав файл
$ GOPATH / src / github.com / user / stringutil / reverse_test.идти
, содержащий
следующий код Go.пакет stringutil импортное "тестирование" func TestReverse (t * testing.T) { case: = [] struct { в, хочу строку } { {"Привет, мир", "dlrow, olleH"}, {"Привет,", "界 世, olleH"}, {"", ""}, } for _, c: = range case { получил: = обратный (c.in) if got! = c.want { t.Errorf ("Обратный (% q) ==% q, хочу% q", c.in, got, c.want) } } }Затем запустите тест с помощью
go test
:$ пройти тест на github.com / user / stringutil хорошо github.com/user/stringutil 0.165sКак всегда, если вы используете инструмент
go
из пакета
каталог, вы можете не указывать путь к пакету:$ пройти тест хорошо github.com/user/stringutil 0.165sЗапустите
go help test
и посмотрите
документация пакета тестирования для более подробной информации.Удаленные пакеты
Путь импорта может описывать, как получить исходный код пакета с помощью
система контроля версий, такая как Git или Mercurial.Инструментgo
использует
это свойство для автоматической загрузки пакетов из удаленных репозиториев.
Например, примеры, описанные в этом документе, также хранятся в
Репозиторий Git, размещенный на GitHub
github.com/golang/example
.
Если вы включите URL-адрес репозитория в путь импорта пакета,
go get
загрузит, соберет и установит его автоматически:долларов и получите github.com/golang/example/hello $ $ GOPATH / бункер / привет Привет, идут примеры!Если указанный пакет отсутствует в рабочей области,
перейти и получить
поместит его в первое рабочее пространство, указанное вGOPATH
.(Если пакет уже существует,go get
пропускает удаленный
fetch и ведет себя так же, какgo install
.)После выполнения вышеуказанной команды
go get
каталог рабочей области
дерево теперь должно выглядеть так:bin / привет # исполняемый файл команды src / github.com/golang/example/ .git / # метаданные репозитория Git Здравствуйте/ hello.go # источник команды stringutil / обеспечить регресс.go # источник пакета reverse_test.go # тестовый источник github.com/user/ Здравствуйте/ hello.go # источник команды stringutil / reverse.go # источник пакета reverse_test.go # тестовый источникКоманда
hello
, размещенная на GitHub, зависит от
stringutil
в том же репозитории. Импорт в
hello.go
файл использует то же соглашение о пути импорта, поэтому
go get Команда
может найти и установить зависимый
пакет тоже.импортировать "github.com/golang/example/stringutil"Это соглашение - самый простой способ сделать ваши пакеты Go доступными для
другие использовать.
Вики Сообщества
и godoc.org
предоставить списки внешних проектов Go.Для получения дополнительных сведений об использовании удаленных репозиториев с инструментом
go
см.
go help importpath
.Что дальше
Подпишитесь на
голанг-анонс
список рассылки, чтобы получать уведомления о выходе новой стабильной версии Go.См. Советы по написанию в Effective Go.
ясный идиоматический код Go.Совершите экскурсию по Go, чтобы выучить язык
собственно.Посетите страницу документации для получения подробных
статьи о языке Go, его библиотеках и инструментах.Получение помощи
Если вам нужна помощь в режиме реального времени, обратитесь к полезным сусликам
.
GOROOT и GOPATH - Справка
Инструменты
Go ожидают определенного макета исходного кода. GOROOT и GOPATH - переменные среды, которые определяют этот макет.
GOROOT - это переменная, определяющая, где находится ваш Go SDK. Вам не нужно изменять эту переменную, если вы не планируете использовать другие версии Go.
GOPATH - это переменная, определяющая корень вашего рабочего пространства. По умолчанию каталог рабочей области - это каталог с именем
go
в домашнем каталоге вашего пользователя (~ / go для Linux и MacOS,% USERPROFILE% / go для Windows).GOPATH хранит вашу базу кода и все файлы, необходимые для вашей разработки. Вы можете использовать другой каталог в качестве рабочего пространства, настроив GOPATH для разных областей. GOPATH является корнем вашей рабочей области и содержит следующие папки:
src /: расположение исходного кода Go (например, .go, .c, .g, .s).
pkg /: расположение кода скомпилированного пакета (например, .a).
bin /: расположение скомпилированных исполняемых программ, созданных Go.
GOROOT
Настройка GOROOT
Выберите локальную копию Go SDK
Убедитесь, что указанный путь к папке с Go SDK включает папки bin и src.
Откройте настройки ( Ctrl + Alt + S ) и перейдите к.
Нажмите кнопку «Добавить SDK» и выберите «Локальный».
В браузере файлов перейдите к версии SDK, которая находится на жестком диске.
Нажмите «Открыть».
Загрузите Go SDK
Откройте настройки ( Ctrl + Alt + S ) и перейдите к.
Нажмите кнопку «Добавить SDK» () и выберите «Загрузить».
В списке «Версия» выберите версию SDK.
В поле «Местоположение» укажите путь к SDK. Чтобы использовать файловый браузер, щелкните значок «Обзор».
Нажмите ОК.
GOPATH
Настройка GOPATH для разных областей действия
Вы можете настроить GOPATH для следующих областей: Global, Project и Module. Если вы указали все три области действия, GoLand сначала выберет самую узкую область.
Откройте настройки ( Ctrl + Alt + S ) и перейдите к.
В зависимости от области действия, которую вы хотите применить, выберите соответствующий раздел (Global GOPATH, Project GOPATH, Module GOPATH) и нажмите кнопку «Добавить».
Перейдите в каталог, который вы хотите связать с GOPATH.
Нажмите ОК.
Последнее изменение: 19 августа 2020 г.
.
Golang Установка, настройка, GOPATH и Go Workspace
Go - это статически типизированный компилируемый язык программирования с открытым исходным кодом, созданный Google.
Он сочетает в себе лучшее из языков со статической и динамической типизацией и дает вам правильное сочетание эффективности и простоты программирования. Он в первую очередь подходит для создания быстрых, эффективных и надежных серверных приложений.
Ниже приведены некоторые из наиболее заметных особенностей Go -
.
- Безопасность: как безопасность типа, так и безопасность памяти.
- Хорошая поддержка параллелизма и коммуникации.
- Эффективная сборка мусора без задержек
- Высокая скорость компиляции
- Превосходная опора для инструментов
Это первая часть нашей серии руководств по Go. В этой статье вы узнаете, как установить Go в вашу систему и настроить среду разработки для проектов Go.
Установка Go
Двоичные дистрибутивы
Go доступны для всех основных операционных систем, таких как Linux, Windows и MacOS.Установить Go из бинарных дистрибутивов очень просто.
Если бинарный дистрибутив для вашей операционной системы недоступен, вы можете попробовать установить Go из исходников.
Mac OS X
Использование Homebrew
Самый простой способ установить Go в Mac OS - использовать Homebrew -
brew install go
Использование установщика пакетов macOS
Загрузите файл последнего пакета Go (
.pkg
) с официальной страницы загрузок Go.Откройте пакет и следуйте инструкциям на экране, чтобы установить Go. По умолчанию Go будет установлен в/ usr / local / go
.Linux
Загрузите дистрибутив Linux с официальной страницы загрузки Go и распакуйте его в каталог
/ usr / local
.sudo tar -C / usr / local -xzf go $ VERSION. $ OS- $ ARCH.tar.gz
Затем добавьте каталог
/ usr / local / go / bin
в переменную среды PATH. Вы можете сделать это, добавив следующую строку в свой~ /.bash_profile
файл -экспорт PATH = $ PATH: / usr / local / go / bin
Вы также можете использовать любой другой каталог, например
/ opt / go
вместо/ usr / local
для установки Go.Окна
Загрузите установочный файл Windows MSI с официальной страницы загрузки Go. Откройте программу установки и следуйте инструкциям на экране, чтобы установить Go в вашей системе Windows. По умолчанию программа установки устанавливает Go в
C: \ Go
Дистрибутив Go поставляется в комплекте с инструментом go.Это инструмент командной строки, который позволяет автоматизировать общие задачи, такие как загрузка и установка зависимостей, создание и тестирование кода и многое другое.
После установки
Go
, следуя инструкциям в предыдущем разделе, вы сможете запустить инструмент Go , набравgo
в командной строке -$ перейти Go - это инструмент для управления исходным кодом Go. Применение: команда go [аргументы] Команды следующие: сборка компилируемых пакетов и зависимостей очистить удалить объектные файлы doc показать документацию для пакета или символа env print Go информация о среде ошибка запустить отчет об ошибке исправить, запустить инструмент, исправить пакеты fmt запустить gofmt для источников пакетов генерировать генерировать файлы Go, обрабатывая источник получить загрузку и установку пакетов и зависимостей установить компилировать и установить пакеты и зависимости список списков пакетов запустить компиляцию и запустить программу Go тестовые тестовые пакеты инструмент запустить указанный инструмент go версия печать Go версия ветеринар беги иди инструмент ветеринар на упаковках Используйте «go help [команда]» для получения дополнительной информации о команде.Дополнительные разделы справки: c звонки между Go и C buildmode описание режимов сборки тип файла типы файлов переменная среды gopath GOPATH переменные среды среды importpath синтаксис пути импорта пакеты описание списков пакетов testflag описание флагов тестирования testfunc описание функций тестирования Используйте «go help [topic]» для получения дополнительной информации по этой теме.
GOPATH, рабочее пространство Go и организация кода Go
Go требует, чтобы вы организовали свой код определенным образом -
По соглашению весь ваш код Go и код, который вы импортируете, должны находиться в одном рабочем пространстве .Рабочее пространство - это не что иное, как каталог в вашей файловой системе, путь к которому хранится в переменной среды
GOPATH
.Обратите внимание, что после введения модулей Go в Go 1.11 вам больше не нужно хранить код Go в рабочей области Go. Вы можете создать свой проект Go в любом каталоге за пределами GOPATH. Следующее объяснение рабочего пространства Go дано по историческим причинам и потому, что оно все еще актуально. Вы можете пропустить этот раздел, если хотите.
Каталог рабочей области содержит в своем корне следующие подкаталоги -
src
: содержит исходные файлы Go .Каталог
src
обычно содержит множество репозиториев управления версиями, содержащих один или несколько пакетов Go. Каждый исходный файл Go принадлежит пакету. Обычно вы создаете новый подкаталог внутри своего репозитория для каждого отдельного пакета Go.
bin
: содержит двоичные исполняемые файлы .Инструмент Go создает и устанавливает двоичные исполняемые файлы в этот каталог. Все программы Go, которые должны быть исполняемыми, должны содержать исходный файл со специальным пакетом
main
и определять точку входа программы в специальной функцииmain ()
.
pkg
: содержит архивы пакетов Go (.a
) .Все неисполняемые пакеты (разделяемые библиотеки) хранятся в этом каталоге. Вы не можете запускать эти пакеты напрямую, поскольку они не являются двоичными файлами. Обычно они импортируются и используются внутри других исполняемых пакетов.
# Типичное рабочее пространство Go bin / myapp # Исполняемый двоичный файл hello # Исполняемый двоичный файл пкг / github.com / callicoder / пример / numbers.a # Архив пакетов strings.a # Архив пакета github.com/gorilla/ mux.a # Архив пакета go.uber.org/ zap.a # Архив пакетов src / github.com/callicoder/example/ # Репозиторий проектов .git / myapp / app.go # Исполняемая программа, содержащая основной пакет и функцию numbers / # Go Package (содержит служебные функции для работы с числами) премьер.идти prime_test.go strings / # Go Package (содержит служебные функции для работы со строками) reverse.go trim.go github.com/gorilla/mux/ # Сторонний пакет #... содержимое пакета go.uber.org/zap/ # Сторонний пакет #... содержимое пакета hello / # Локальный пакет (нигде не опубликован) привет.го # ... (другие репозитории и пакеты опущены) ...
Настройка GOPATH
Переменная среды GOPATH указывает расположение вашей рабочей области.По умолчанию предполагается, что
GOPATH
составляет$ HOME / go
в системах Unix и% USERPROFILE% \ go
в Windows. Если вас устраивает этот путь, вам не нужно ничего делать. Вы можете просто создать каталог своей рабочей области с именемgo
внутри домашней папки и начать писать код Go.Если вы хотите использовать настраиваемое местоположение в качестве рабочего пространства, вы можете установить переменную среды
GOPATH
, следуя инструкциям ниже -Системы Unix (Linux и macOS)
Для установки
GOPATH
в оболочках bash добавьте следующую строку в файл~ /.bash_profile
файл -экспорт GOPATH = $ HOME / go
Если вы используете оболочку Zsh , вам нужно добавить указанную выше строку в файл
~ / .zshrc
.Система Windows
Допустим, вы хотите, чтобы каталог вашей рабочей области находился по адресу
C: \ go-workspace
. Вот как вы можете установить переменную средыGOPATH
для использования этого местоположения рабочего пространства -
Создайте папку рабочей области по адресу
C: \ go-workspace
.Щелкните правой кнопкой мыши Пуск → щелкните Панель управления → Выберите Система и безопасность → щелкните Система .
В меню слева выберите Дополнительные системные настройки .
Нажмите кнопку Переменные среды внизу.
Щелкните Новый из раздела Пользовательские переменные .
Введите
GOPATH
в поле Имя переменной .Введите
C: \ go-workspace
в поле Значение переменной .Нажмите ОК.
Обратите внимание, что путь
GOPATH
должен отличаться от пути вашей установки Go.Тестирование вашей установки Go с помощью программы
Hello World
Во-первых, убедитесь, что вы создали каталог рабочей области Go по адресу
$ HOME / go
. Затем создайте новый каталогsrc / hello
внутри вашей рабочей области.Наконец, создайте файл с именемhello.go
со следующим кодом -.
Примечание. Начиная с версии Go 1.11, вы также можете создавать и запускать программу вне рабочего пространства Go.
пакет основной импорт "fmt" func main () { fmt.Printf ("Привет, мир \ n") }
$ cd $ HOME / go / src / привет $ ls привет.го
Самый простой способ запустить указанную выше программу - использовать команду
go run
-$ иди, беги, привет.идти Привет мир
Создание исполняемого двоичного файла с использованием сборки
go
go run Команда
компилирует и запускает вашу программу за один раз. Однако, если вы хотите создать двоичный файл из исходного кода Go, который можно запустить как отдельный исполняемый файл без использования инструмента Go, используйте командуgo build
-$ cd $ HOME / go / src / привет $ идти строить $ ls привет привет. го
Команда
go build
создает исполняемый двоичный файл с тем же именем, что и имя вашего непосредственного пакета (hello
).Вы можете запустить двоичный файл так -$. / Привет Привет мир
Установка пакета в каталог
bin
с помощьюgo install
Вы можете использовать команду
go install
для создания и установки исполняемого двоичного файла в каталогbin
вашей рабочей области -$ cd $ HOME / go / src / привет $ go install
$ cd $ HOME / go / bin $ ls Здравствуйте $ ./hello Привет мир
Вы также можете добавить каталог
$ HOME / go / bin
в переменнуюPATH
для запуска исполняемых файлов go из любого места.Не забудьте проверить:
go help run
,go help build
,go help install
.Заключение
На этом все, ребята! Я надеюсь, что вы готовы погрузиться в глубокое погружение и узнать больше о языке программирования Go. Вы можете найти все руководства, написанные на Go, на странице категорий Golang.
Спасибо за внимание, до встречи в следующей статье.
Следующая статья: Здравствуйте, Голанг: напишите свою первую программу для Голанга
Примеры кода: github.com / callicoder / golang-tutorials
Дополнительные ресурсы
.
Как написать код Go
Введение
Этот документ демонстрирует разработку простого пакета Go внутри
модуль и представляет инструмент go, стандартный способ
получать, собирать и устанавливать модули, пакеты и команды Go.Примечание. В этом документе предполагается, что вы используете Go 1.13 или новее и
GO111MODULE
переменная среды не задана. Если вы ищете
более старая версия этого документа до модулей, она заархивирована
Вот.Код организации
Программы Go организованы в пакеты. Пакет - это коллекция
исходных файлов в одном каталоге, которые скомпилированы вместе. Функции,
типы, переменные и константы, определенные в одном исходном файле, видны всем
другие исходные файлы в том же пакете.Репозиторий содержит один или несколько модулей. Модуль - это сборник
связанных пакетов Go, которые выпускаются вместе. Репозиторий Go обычно
содержит только один модуль, расположенный в корне репозитория.Файл с именем
go.mod
там объявляет путь модуля : путь импорта
префикс для всех пакетов в модуле. Модуль содержит пакеты в
каталог, содержащий его файлgo.mod
, а также подкаталоги
этого каталога до следующего подкаталога, содержащего другой
go.mod
файл (если есть).Обратите внимание, что вам не нужно публиковать свой код в удаленном репозитории перед тем, как
может построить это. Модуль может быть определен локально без принадлежности к репозиторию.Однако хорошей привычкой является систематизация кода так, как будто вы его публикуете.
когда-нибудь.Путь каждого модуля не только служит префиксом пути импорта для его пакетов,
но также указывает, куда должна искать командаgo
, чтобы загрузить ее.
Например, чтобы скачать модульgolang.org/x/tools
,
командаgo
будет обращаться к репозиторию, указанному
https://golang.org/x/tools
(подробнее здесь).Путь импорта - это строка, используемая для импорта пакета.Пакет
путь импорта - это путь к модулю, соединенный с его подкаталогом в модуле.
Например, модульgithub.com/google/go-cmp
содержит пакет
в каталогеcmp /
. Путь импорта этого пакета
github.com/google/go-cmp/cmp
. Пакеты в стандартной библиотеке делают
не иметь префикса пути к модулю.Ваша первая программа
Чтобы скомпилировать и запустить простую программу, сначала выберите путь к модулю (мы будем использовать
example.com/user/hello
) и создайтеgo.mod
, который
заявляет об этом:$ mkdir hello # Или клонируйте его, если он уже существует в системе контроля версий. $ cd привет $ go mod init example.com/user/hello go: создание нового go.mod: module example.com/user/hello $ cat go.mod модуль example.com/user/hello перейти 1.14 $Первый оператор в исходном файле Go должен быть
упаковка наименование
. Исполняемые команды всегда должны использовать
основной пакет
.Затем создайте файл с именем
hello.перейдите
внутрь этого каталога, содержащего
следующий код Go:основной пакет импорт "fmt" func main () { fmt.Println ("Привет, мир.") }Теперь вы можете собрать и установить эту программу с помощью инструмента
go
:$ иди и установи example.com/user/hello $Эта команда создает команду
hello
, создавая исполняемый файл
двоичный. Затем он устанавливает этот двоичный файл как$ HOME / go / bin / hello
(или,
под Windows% USERPROFILE% \ go \ bin \ hello.exe
).Каталог установки контролируется
GOPATH
иGOBIN
среда
переменные. Если установленGOBIN
, бинарные файлы устанавливаются на него.
каталог. Если установленGOPATH
, двоичные файлы устанавливаются в
подкаталогbin
первого каталога в
списокGOPATH
. В противном случае двоичные файлы устанавливаются в
подкаталогbin
по умолчаниюGOPATH
($ HOME / go
или% USERPROFILE% \ go
).Вы можете использовать команду
go env
для переносимой установки значения по умолчанию
для переменной среды для будущих командgo
:$ go env -w GOBIN = / где-то / еще / bin $Чтобы отключить переменную, ранее установленную
go env -w
, используйтеgo env -u
:$ go env -u ГОБИН $Команды вроде
go install
применяются в контексте модуля.
содержащий текущий рабочий каталог.Если рабочий каталог находится вне
модульexample.com/user/hello
,go install
может дать сбой.Для удобства команды
go
принимают пути относительные
в рабочий каталог, а по умолчанию - пакет в
текущий рабочий каталог, если не указан другой путь.
Итак, в нашем рабочем каталоге все следующие команды эквивалентны:$ go install example.com/user/hello$ go install.$ go installДалее запустим программу, чтобы убедиться, что она работает.Для дополнительного удобства мы
добавьте каталог установки в нашPATH
, чтобы запустить исполняемые файлы
легко:# Пользователи Windows должны проконсультироваться по https://github.com/golang/go/wiki/SettingGOPATH # для установки% PATH%. $ экспорт PATH = $ PATH: $ (dirname $ (go list -f '{{.Target}}'.)) $ привет Привет мир. $Если вы используете систему управления версиями, сейчас самое подходящее время для инициализации
репозиторий, добавьте файлы и зафиксируйте первое изменение. Опять же, этот шаг
необязательно: вам не нужно использовать систему управления версиями для написания кода Go.$ git init Инициализированный пустой репозиторий Git в /home/user/hello/.git/ $ git add go.mod hello.go $ git commit -m "начальная фиксация" [master (root-commit) 0b4507d] начальная фиксация 1 файл изменен, 7 прошивок (+) создать режим 100644 go.mod hello.go $Команда
go
находит репозиторий, содержащий заданный путь к модулю, запрашивая соответствующий URL-адрес HTTPS и считывая метаданные, встроенные в ответ HTML (см.
go help importpath
).Многие службы хостинга уже предоставляют эти метаданные для репозиториев, содержащих
Код Go, поэтому самый простой способ сделать ваш модуль доступным для использования другими - это
обычно для того, чтобы путь к модулю соответствовал URL-адресу репозитория.Импорт пакетов из вашего модуля
Напишем пакет
morestrings
и воспользуемся им из программыhello
.
Сначала создайте каталог для пакета с именем
$ HOME / hello / morestrings
, а затем файл с именем
реверс.перейдите в этот каталог
со следующим содержимым:// Пакет morestrings реализует дополнительные функции для управления UTF-8 // закодированные строки сверх того, что предусмотрено в стандартном пакете "strings". пакет morestrings // ReverseRunes возвращает строку аргументов, перевернутую по рунам слева направо. func ReverseRunes (s строка) строка { r: = [] руна (и) для i, j: = 0, len (r) -1; яПоскольку наша функция
ReverseRunes
начинается с верхнего регистра
письмо, это экспорт ,
и может использоваться в других пакетах, которые импортируют нашиmorestrings
пакет.Давайте проверим, что пакет компилируется с
go build
:$ cd $ HOME / hello / morestrings $ пойти сборка $Это не создаст выходной файл. Вместо этого он сохраняет скомпилированный пакет в
локальный кеш сборки.Убедившись, что пакет
morestrings
компилируется, давайте воспользуемся им.
из программыhello
. Для этого измените исходный
$ HOME / hello / hello.go
для использования пакета morestrings:основной пакет импорт ( "fmt" "пример.com / user / hello / morestrings " ) func main () { fmt.Println (morestrings.ReverseRunes ("! oG, olleH")) }Установите программу
hello
:$ иди и установи example.com/user/helloЗапустив новую версию программы, вы должны увидеть новое перевернутое сообщение:
$ привет Привет, вперед!Импорт пакетов из удаленных модулей
Путь импорта может описывать, как получить исходный код пакета с помощью
система контроля версий, такая как Git или Mercurial.Инструментgo
использует
это свойство для автоматической загрузки пакетов из удаленных репозиториев.
Например, чтобы использоватьgithub.com/google/go-cmp/cmp
в вашей программе:основной пакет импорт ( "fmt" "example.com/user/hello/morestrings" "github.com/google/go-cmp/cmp" ) func main () { fmt.Println (morestrings.ReverseRunes ("! oG, olleH")) fmt.Println (cmp.Diff ("Hello World", "Hello Go")) }Когда вы запускаете такие команды, как
go install
,go build
или
go run
, командаgo
автоматически загрузит
удаленный модуль и запишите его версию на свойgo.Файл mod
:$ go install example.com/user/hello go: поиск модуля для пакета github.com/google/go-cmp/cmp перейти: загрузка github.com/google/go-cmp v0.4.0 go: нашел github.com/google/go-cmp/cmp в github.com/google/go-cmp v0.4.0 $ привет Привет, вперед! строка ( - "Привет мир", + "Hello Go", ) $ cat go.mod модуль example.com/user/hello перейти 1.14 требуется github.com/google/go-cmp v0.4.0 $Зависимости модулей автоматически загружаются в
pkg / mod
.
подкаталог каталога, указанного средойGOPATH
переменная.Загруженное содержимое для данной версии модуля является общим
среди всех других модулей, которыетребуют
этой версии, поэтому
командаgo
отмечает эти файлы и каталоги как доступные только для чтения. Чтобы
удалить все загруженные модули, можно передать флаг-modcache
доочистить
:$ go clean -modcache $Тестирование
Go имеет легкую среду тестирования, состоящую из
go test
.
команда и пакетtesting
.Вы пишете тест, создавая файл с именем, заканчивающимся на
_test.go
который содержит функции с именемTestXXX
с подписью
func (t * testing.T)
.
Среда тестирования запускает каждую такую функцию;
если функция вызывает функцию сбоя, напримерt. Ошибка
или
т. Отказ
, испытание считается неудавшимся.Добавьте тест в пакет
morestrings
, создав файл
$ HOME / привет / morestrings / reverse_test.идти
, содержащий
следующий код Go.пакет morestrings импортное "тестирование" func TestReverseRunes (t * testing.T) { case: = [] struct { в, хочу строку } { {"Привет, мир", "dlrow, olleH"}, {"Привет,", "界 世, olleH"}, {"", ""}, } for _, c: = range case { получил: = ReverseRunes (c.in) if got! = c.want { t.Errorf ("ReverseRunes (% q) ==% q, хочу% q", c.in, got, c.want) } } }Затем запустите тест с
go test
:$ пройти тест ПРОХОДИТЬ хорошо пример.com / user / morestrings 0.165s $Запустите
go help test
и посмотрите
документация пакета тестирования для более подробной информации.Что дальше
Подпишитесь на
голанг-анонс
список рассылки, чтобы получать уведомления о выходе новой стабильной версии Go.См. Советы по написанию в Effective Go.
ясный идиоматический код Go.Взять
Экскурсия по го
выучить язык
собственно.Посетите страницу документации для получения подробных
статьи о языке Go, его библиотеках и инструментах.Получение помощи
Если вам нужна помощь в реальном времени, спросите полезных сусликов в сообществе.
сервер Slack сусликов
(возьмите приглашение здесь).Официальный список рассылки для обсуждения языка го:
Сходить с ума.Сообщайте об ошибках с помощью
Перейти в систему отслеживания проблем..