Как скомпилировать go под linux
Обновлено: 06.07.2024
build компилирует пакеты, названные путями импорта, вместе с их зависимостями, но не устанавливает результаты.
Если аргументы для build представляют собой список файлов .go, build обрабатывает их как список исходных файлов, указывающих один пакет.
При компиляции единичного основного пакета (main package) build записывает полученный исполняемый файл в выходной файл, названный в честь первого исходного файла ("go build ed.go rx.go" записывает "ed" или "ed.exe") или в каталог исходного кода ("go build unix/sam" записывает "sam" или "sam.exe"). Суффикс ".exe" добавляется при записи исполняемого файла Windows.
При компиляции нескольких пакетов или одного неосновного пакета, build компилирует пакеты, но отбрасывает полученный объект, служа только для проверки возможности сборки пакетов.
При компиляции пакетов build игнорирует файлы, заканчивающиеся на "_test.go".
Флаг -o, разрешен только при компиляции одного пакета, он заставляет build записывать полученный исполняемый файл или объект в именованный выходной файл вместо поведения по умолчанию, описанного выше.
Флаг -i устанавливает пакеты, которые являются зависимостями от цели.
Флаги сборки (build flags) используются командами build, clean, get, install, list, run и test:
Подробнее об указании пакетов см. в разделе 'go help packages'. Чтобы узнать больше о том, где установлены пакеты и бинарные файлы, запустите 'go help gopath'. Чтобы узнать больше о вызовах между Go и C/C++, запустите 'go help c'.
Примечание: build придерживается определенных соглашений, таких как те, которые описаны в 'go help gopath'. Однако не все проекты могут следовать этим правилам. Установки, которые имеют свои собственные соглашения или используют отдельную систему сборки программного обеспечения, могут использовать вызовы более низкого уровня, такие как 'go tool compile' и 'go tool link', чтобы избежать некоторых накладных расходов и проектных решений инструмента сборки.
При разработке программного обеспечения важно учитывать операционную систему и базовую архитектуру процессора, для которой нужно скомпилировать двоичный файл. Поскольку запуск двоичного файла на платформе с другой ОС или архитектурой зачастую происходит медленно (если его вообще возможно обработать), принято собирать двоичный код для множества различных платформ, чтобы максимально увеличить аудиторию программы. Однако это может быть сложно, если платформа, которую вы используете для разработки, отличается от платформы, на которой вы хотите развернуть свою программу. В прошлом, например, разработка программы для Windows и ее развертывание на Linux или macOS требовали настройки компьютеров сборки для каждой из этих сред, для которых нужно было собрать двоичные файлы. Вам также необходимо синхронизировать инструменты, а также обратить внимание на ряд других аспектов, которые могут повысить расход ресурсов и затруднить совместное тестирование и распространение.
Go решает эту проблему путем встроенной поддержки нескольких платформ непосредственно в инструмент сборки go build (и в остальную часть цепочки инструментов Go). Используя переменные среды и теги сборки, вы можете контролировать, для какой ОС и архитектуры создается окончательный двоичный файл (а также объединить рабочий процесс, что позволит быстро переключать добавление зависимого от платформы кода без изменения вашей кодовой базы).
В этом мануале мы соберем тестовое приложение, которое объединяет строки в путь к файлу, создает и выборочно включает зависимые от платформы фрагменты и собирает двоичные файлы для нескольких операционных систем и архитектур в своей системе. Так вы научитесь использовать эту мощную возможность языка программирования Go.
Требования
Для работы вам понадобится среда разработки Go:
Доступные платформы для GOOS и GOARCH
Прежде чем учиться управлять процессом сборки бинарных файлов для разных платформ, давайте посмотрим, для каких платформ Go может собирать файлы и как Go ссылается на эти платформы с помощью переменных среды GOOS и GOARCH.
Инструментарий Go содержит команду, которая может вывести список доступных платформ для Go. Этот список может меняться с каждым новым релизом Go, поэтому обсуждаемые здесь комбинации могут не совпадать в другой версией Go. На момент написания этого мануала последней является версия Go 1.13.
Чтобы просмотреть список платформ, выполните следующую команду:
go tool dist list
Вы получите подобный вывод:
aix/ppc64 freebsd/amd64 linux/mipsle openbsd/386
android/386 freebsd/arm linux/ppc64 openbsd/amd64
android/amd64 illumos/amd64 linux/ppc64le openbsd/arm
android/arm js/wasm linux/s390x openbsd/arm64
android/arm64 linux/386 nacl/386 plan9/386
darwin/386 linux/amd64 nacl/amd64p32 plan9/amd64
darwin/amd64 linux/arm nacl/arm plan9/arm
darwin/arm linux/arm64 netbsd/386 solaris/amd64
darwin/arm64 linux/mips netbsd/amd64 windows/386
dragonfly/amd64 linux/mips64 netbsd/arm windows/amd64
freebsd/386 linux/mips64le netbsd/arm64 windows/arm
Эти выходные данные представляют собой набор пар ключ-значение, разделенных символом /. Первая часть комбинации, перед слешем – это операционная система. В Go операционные системы являются доступными значениями для переменной среды GOOS, что означает Go Operating System. Вторая часть, после слеша, это архитектура. Эта часть показывает доступные значения для переменной среды GOARCH, что означает Go Architecture.
Давайте разберем одну из этих комбинаций, чтобы понять, что она означает и как она работает. Для примера можно взять пару linux/386. Пара ключ-значение начинается с GOOS, в этом примере это linux, что ссылается на ОС Linux. GOARCH здесь – 386, что указывает на микропроцессор Intel 80386.
Существует много платформ, доступных с помощью команды go build, но в основном в качестве значения GOOS вы будете использовать linux, windows или darwin. Они охватывают три большие платформы ОС: Linux, Windows и macOS, которая основаны на операционной системе Darwin и поэтому называются darwin. Однако Go может охватывать и менее распространенные платформы, такие как nacl, Google’s Native Client.
Когда вы запускаете команду типа go build, Go использует GOOS и GOARCH текущей платформы, чтобы определить, как собирать двоичный файл. Чтобы узнать, какая комбинация подходит вашей платформе, вы можете использовать команду go env и передать GOOS и GOARCH в качестве аргументов:
go env GOOS GOARCH
Мы запустили эту команду на macOS, на машине с архитектурой AMD64, поэтому мы получили такой вывод:
Здесь выходные данные команды говорят нам, что система имеет переменные GOOS=darwin и GOARCH=amd64.
Теперь вы знаете, что такое GOOS и GOARCH в Go, а также можете определять их допустимые значения. Далее мы соберем тестовую программу, чтобы показать, как использовать эти переменные среды, и создадим теги для сборки двоичных файлов для других платформ.
Создание зависимой от платформы программы с помощью filepath.Join()
Прежде чем приступить к созданию бинарных файлов для других платформ, давайте создадим простую тестовую программу. Для этого можно использовать функцию Join, которая доступна в пакете path/filepath стандартной библиотеки Go. Эта функция принимает несколько строк и возвращает одну строку, которая соединяется правильным разделителем пути к файлу.
Это хорошая тестовая программа, потому что ее работа зависит от того, на какой ОС она запускается. В Windows в качестве разделителя пути используется обратный слеш, \, а в Unix-системах используется обычный слеш /.
Начнем с создания приложения, которое использует filepath.Join(). Позже вы напишете собственную реализацию функции Join(), которая настраивает код для двоичных файлов платформы.
Сначала в каталоге src создайте папку и назовите ее именем вашего приложения:
Перейдите в нее:
Затем создайте в текстовом редакторе новый файл по имени main.go.
Когда файл откроется, добавьте следующий код:
package main
import (
"fmt"
"path/filepath"
)
func main() s := filepath.Join("a", "b", "c")
fmt.Println(s)
>
Функция main() в этом файле использует filepath.Join() для объединения трех строк с помощью правильного, зависимого от платформы разделителя пути.
Сохраните и закройте файл, затем запустите программу:
При запуске этой программы вы получите уникальный вывод – он зависит от используемой вами платформы. В Windows вы увидите строки, разделенные обратным слешем, \:
В системах Unix, таких как macOS и Linux, вы получите следующее:
Как видите, из-за разных протоколов файловой системы, используемых в этих операционных системах, программе придется создавать разный код для разных платформ. Но поскольку программа уже использует разные разделители файлов в зависимости от ОС, мы знаем, что filepath.Join() уже учитывает разницу в платформах. Это связано с тем, что цепочка инструментов Go автоматически обнаруживает GOOS и GOARCH вашего компьютера и использует эту информацию для выбора фрагмента кода с правильными тегами сборки и разделителем файлов.
Давайте посмотрим, где функция filepath.Join() находит разделитель. Запустите следующую команду, чтобы проверить соответствующий фрагмент из стандартной библиотеки Go:
Эта команда вернет содержимое path_unix.go. Найдите в нем эту часть:
. . .
// +build aix darwin dragonfly freebsd js,wasm linux nacl netbsd openbsd solaris
package os
const (
PathSeparator = '/' // OS-specific path separator
PathListSeparator = ':' // OS-specific path list separator
)
. . .
В этом разделе определяется PathSeparator для всех разновидностей Unix-подобных систем, которые поддерживает Go. Обратите внимание на все теги сборки в верхней части, которые отображают все доступные платформы Unix GOOS,. Когда GOOS соответствует этим условиям, ваша программа выдает разделитель пути к файлу в стиле Unix.
Нажмите q, чтобы вернуться в командную строку.
Затем откройте файл, который определяет поведение filepath.Join() в Windows:
Вы увидите следующее:
. . .
package os
const (
PathSeparator = '\\' // OS-specific path separator
PathListSeparator = ';' // OS-specific path list separator
)
. . .
Хотя значение PathSeparator здесь \\, код будет отображать один обратный слеш (\), необходимый для файловых путей Windows, а первый слеш здесь используется только в качестве escape-символа.
Обратите внимание: в отличие от файла Unix, в верхней части этого файла нет тегов сборки. Это связано с тем, что GOOS и GOARCH можно также передать в сборку, добавив подчеркивание (_) и значение переменной среды в качестве суффикса к имени файла (о чем мы поговорим подробнее в следующих разделах мануала). Здесь часть _windows в path_windows.go заставляет файл действовать так, как если бы он имел тег сборки // +build windows в верхней части файла. Поэтому когда программа запускается в Windows, она будет использовать константы PathSeparator и PathListSeparator из фрагмента кода path_windows.go.
Чтобы вернуться в командную строку, нажмите q.
Итак, вы создали программу, которая показала, как Go автоматически преобразует GOOS и GOARCH в теги сборки. Имея это в виду, вы теперь можете обновить свою программу и написать собственную реализацию функции filepath.Join(), используя теги сборки, чтобы вручную установить правильный PathSeparator для платформ Windows и Unix.
Реализация функции, зависимой от платформы
Теперь, когда вы знаете, как стандартная библиотека Go реализует специфичный для платформы код, вы можете использовать теги сборки, чтобы сделать это в своей собственной программе. Для этого напишите собственную реализацию filepath.Join().
Откройте файл main.go:
Замените содержимое main.go на следующее, используя вашу собственную функцию Join():
package main
import (
"fmt"
"strings"
)
func Join(parts . string) string return strings.Join(parts, PathSeparator)
>
func main() s := Join("a", "b", "c")
fmt.Println(s)
>
Функция Join принимает несколько parts и соединяет их вместе, используя метод strings.Join() из пакета strings, чтобы объединить части пути в одну строку с помощью PathSeparator.
Вы еще не определили PathSeparator. Сделайте это сейчас в другом файле. Сохраните и выйдите из main.go, откройте ваш редактор и создайте новый файл path.go:
Определите PathSeparator и задайте разделитель пути файла Unix, /:
package main
const PathSeparator = "/"
Скомпилируйте и запустите приложение:
Вы получите следующий вывод:
Все работает, и вы можете получить путь к файлу в стиле Unix. Но это не все, чего мы хотим: сейчас выводится только a/b/c, независимо от того, на какой платформе работает программа. Чтобы добавить функциональность для создания файловых путей в стиле Windows, вам необходимо добавить версию PathSeparator для Windows и сообщить команде go build, какую версию использовать. В следующем разделе мы применим теги сборки для достижения этой цели.
Использование тегов сборки GOOS или GOARCH
Для учета платформ Windows мы создадим альтернативный файл path.go и будем использовать теги сборки, чтобы фрагменты кода выполнялись только тогда, когда в GOOS и GOARCH указана подходящая платформа.
Сначала добавьте тег сборки в path.go, чтобы обозначить, что он собирается для всех платформ, кроме Windows. Откройте файл:
Добавьте следующий выделенный тег сборки в файл:
// +build !windows
package main
const PathSeparator = "/"
Теги сборки Go позволяют инвертировать (то есть вы можете настроить Go для сборки этого файла для любой платформы, кроме Windows). Чтобы инвертировать тег сборки, поместите перед ним восклицательный знак.
Сохраните и закройте файл.
Теперь, если вы запустите эту программу в Windows, вы получите следующую ошибку:
./main.go:9:29: undefined: PathSeparator
В этом случае Go не может включить path.go для определения переменной PathSeparator.
Теперь, когда вы убедились, что path.go не будет работать, если в GOOS указана система Windows, добавьте новый файл windows.go:
В windows.go определите PathSeparator, а также тег сборки, чтобы команда go build знала, что это реализация Windows:
// +build windows
package main
const PathSeparator = "\\"
Сохраните файл и выйдите из текстового редактора. Теперь приложение может компилироваться одним способом для Windows, а другим – для всех других платформ.
Хотя двоичные файлы теперь будут правильно собираться для разных платформ, необходимо внести дополнительные изменения, чтобы скомпилировать файлы для платформы, к которой у вас нет доступа. Для этого нужно изменить локальные переменные среды GOOS и GOARCH.
Использование локальных переменных GOOS и GOARCH
Ранее вы запускали команду go env GOOS GOARCH, чтобы выяснить, с какой ОС и архитектурой вы работали. Запущенная нами команда go env искала две переменные окружения GOOS и GOARCH; если она находит значения, она их использует, но если их нет, Go установит в них информацию для текущей платформы. Так вы можете изменить GOOS или GOARCH и установить значения, которые не относятся к вашей локальной ОС и архитектуре по умолчанию.
Команда go build ведет себя аналогично команде go env. Вы можете установить переменные среды GOOS или GOARCH для сборки для другой платформы, используя go build.
Если на локальной машине вы не используете систему Windows, создайте двоичный файл приложения, установив для переменной среды GOOS значение windows при запуске команды go build:
GOOS=windows go build
Теперь просмотрите файлы в вашем текущем каталоге:
Вывод показывает, что в каталоге проекта теперь есть исполняемый файл app.exe для Windows:
app app.exe main.go path.go windows.go
С помощью команды file вы можете получить больше информации об этом файле, в том числе и о его сборке:
file app.exe
app.exe: PE32+ executable (console) x86-64 (stripped to external PDB), for MS Windows
Вы также можете установить одну или обе переменные среды во время сборки. Запустите следующее:
GOOS=linux GOARCH=ppc64 go build
Ваш исполняемый файл приложения будет заменен файлом для другой архитектуры. Запустите команду file для этого двоичного файла:
Вы получите подобный вывод:
app: ELF 64-bit MSB executable, 64-bit PowerPC or cisco 7500, version 1 (SYSV), statically linked, not stripped
Установив локальные переменные среды GOOS и GOARCH, вы можете создавать двоичные файлы для любой из совместимых платформ Go без сложной конфигурации или настройки. Далее вы научитесь использовать соглашения об именах файлов, чтобы ваши файлы были аккуратно организованы и автоматически собирались для конкретных платформ без тегов сборки.
Суффиксы имен GOOS и GOARCH
Как вы видели ранее, стандартная библиотека Go активно использует теги сборки для упрощения кода путем разделения реализаций разных платформ на разные файлы. Когда вы открыли файл os/path_unix.go, вы видели тег сборки, перечисляющий все возможные комбинации, которые считаются Unix-подобными платформами. Однако файл os/path_windows.go не содержал тегов сборки, поскольку суффикса имени файла было достаточно, чтобы указать Go, для какой платформы предназначен файл.
Давайте посмотрим на синтаксис этой функции. При именовании файла .go вы можете добавить GOOS и GOARCH в качестве суффиксов к имени файла в указанном порядке. Значение должно разделяться подчеркиванием (_). Если у вас есть файл Go по имени filename.go, вы можете указать ОС и архитектуру, изменив имя файла на filename_GOOS_GOARCH.go. Например, если вы хотите скомпилировать файл для Windows с 64-битной архитектурой ARM, вы должны указать имя filename_windows_arm64.go. Это соглашение об именах помогает поддерживать код в чистоте и порядке.
Обновите вашу программу, добавьте суффиксы имен файлов вместо тегов сборки. Сначала переименуйте файлы path.go и windows.go, чтобы использовать соглашение пакета os:
mv path.go path_unix.go
mv windows.go path_windows.go
Изменив имена двух фалов, вы можете удалить тег сборки, который вы добавили в path_windows.go:
Удалите // + build windows, чтобы ваш файл выглядел так:
package main
const PathSeparator = "\\"
Поскольку unix не является действительным значением GOOS, суффикс _unix.go ничего не значит для компилятора Go. Однако он передает предполагаемую цель файла. Как и в os/path_unix.go, в файле path_unix.go должны использоваться теги сборки, поэтому оставьте этот файл без изменений.
Следуя соглашению имен, вы можете удалить ненужные теги сборки из кода и сделать файловую систему чище.
Заключение
Возможность генерировать для нескольких платформ двоичные файлы, не требующие зависимостей – важная функция набора инструментов Go. В этом мануале вы научились использовать эту возможность через теги сборки и суффиксы имен файлов. Это позволяет пометить определенные фрагменты кода для компиляции только в файлах определенных архитектур. Вы создали свою собственную зависимую от платформы программу, а затем с помощью переменных среды GOOS и GOARCH сгенерировали двоичные файлы для других платформ. Это ценный навык, поскольку его можно использовать в процессе непрерывной интеграции: он автоматически читает переменные среды для создания двоичных файлов для всех платформ.
Установка Go из стандартных системных репозиториев в Debian, Kali Linux, Linux Mint, Ubuntu
Для установки выполните команду:
Для Debian также рекомендуется добавить экспорт следующих переменных окружения в файле
/.zshrc если у вас ZSH):
Эти изменения вступят в силу после перезагрузки. Вместо перезапуска компьютера выполните:
Если вы не уверены, какая у вас оболочка, то выполните команду:
Если будет выведено:
- /bin/bash — значит у вас Bash
- /usr/bin/zsh — значит у вас ZSH
Установка Go из стандартных системных репозиториев в Arch Linux, BlackArch и их производные
В Arch Linux и производные Go устанавливается следующим образом:
Для Arch Linux также рекомендуется добавить экспорт следующих переменных окружения в файле
Эти изменения вступят в силу после перезагрузки. Вместо перезапуска компьютера выполните:
Ручная установка самой последней версии компилятора Go
Ранее рекомендовалась именно ручная установка, поскольку она предусматривает добавление переменных окружения. Переменные окружения используются, например, в командах по установке, которые дают разработчики программ:
Без переменных окружения эта последовательность команд завершиться ошибкой.
Но эти переменные окружения можно добавить и при установке Go из репозитория, как это показано выше. Поэтому если вы это сделали (добавили экспорт переменных окружения), то каких либо преимуществ у ручной установки нет. Разве что, только если вам нужна самая последняя версия языка Go.
Если в источниках приложений для вашего дистрибутива отсутствует Go, либо вы хотите вручную установить самую последнюю версию компилятора, то следуйте этому руководству далее.
Следующая инструкция успешно протестирована в Kali Linux, Arch Linux, BlackArch, Linux Mint, Ubuntu. Также она должна работать в практически любом дистрибутиве Linux.
Если вы не уверены, какая у вас оболочка, то выполните команду:
Если будет выведено:
- /bin/bash — значит у вас Bash
- /usr/bin/zsh — значит у вас ZSH
Если у вас Bash оболочка (большинство систем), то следуйте инструкциям из этого раздела:
Откройте файл .bashrc в директории пользователя любым текстовым редактором:
И для создания новых переменных окружения добавьте следующие строки в этот файл:
Когда всё готово, сохраните изменения и закройте файл.
Эти изменения вступят в силу после перезагрузки. Вместо перезапуска компьютера выполните:
Если у вас ZSH оболочка (по умолчанию, например, в Kali Linux), то следуйте инструкциям из этого раздела:
/.zshrc в директории пользователя любым текстовым редактором:
И для создания новых переменных окружения добавьте следующие строки в этот файл:
Когда всё готово, сохраните изменения и закройте файл.
Эти изменения вступят в силу после перезагрузки. Вместо перезапуска компьютера выполните:
Дальше одинаково для всех оболочек и систем.
Следующая команда автоматически определит и скачает последнюю версию файлов языка программирования Go:
Язык программирования Go или как его еще называют Golang, это относительно новый язык от корпорации Google, который по своим возможностям стремится заменить Си и С++. Он создан одним из разработчиков Си и здесь уже были учтены все ошибки, допущенные при создании того языка. Go имеет улучшенную безопасность, мультипоточность, полностью кросплатформенен и многое другое. На Go можно даже писать приложения для Android.
В этой статье мы рассмотрим как выполняется установка Go в Ubuntu 20.04 и более поздних версиях. Рассмотрим установку компилятора с официального сайта или PPA, а также запустим небольшую программу чтобы проверить как все работает.
Что такое Go?
Сначала важно понять что же все-таки такое Go. Этот язык был создан сотрудниками корпорации Google в 2009 году. В этом процессе принимал участие Кен Томпсон, один из разработчиков Си. В первую очередь это компилируемый язык системного программирования, который подходит для создания высокоэффективных программ. Хотя в Go возможен запуск программ в интерпретаторе, они компилируются в объектный код и не требуют виртуальной машины.
Основные возможности языка - это строгая типизация, поддержка указателей, поддержка юникода, динамические массивы, хэш таблицы, автоматическое управление памятью, потоки для параллельного программирования, а также каналы для связи между потоками. Синтаксис Go очень похож на Си, с тем лишь отличием, что некоторые компоненты позаимствованы из других скриптовых языков. Язык постоянно развивается и получает новые возможности. А теперь рассмотрим как выполняется установка языка в Ubuntu.
Установка Go на Ubuntu
Есть несколько способов установки этого языка. Вы можете загрузить файл с бинарными файлами компилятора с официального сайта и распаковать его в какой-либо директории. Затем останется только установить несколько переменных окружения. Так вы можете получить самую последнюю версию.
1. Установка из официальных репозиториев
Сначала обновите систему до самой новой версии:
sudo apt update
sudo apt upgrade
Затем для установки достаточно выполнить такую команду:
sudo apt install golang
На этом установка завершена. Для просмотра версии выполните:
После этого вы можете переходить к настройке рабочего окружения для языка.
2. Установка из официального сайта
Как видите, на момент написания статьи в репозиториях находится версия 1.13. В то же время на официальном сайте уже можно найти версию 1.15. Если вы хотите получить именно её, надо устанавливать компилятор языка из официального сайта.
Просто выберите нужную операционную систему и дождитесь окончания загрузки. Для скачивания версии 1.15 можете воспользоваться такой командой:
После окончания загрузки расспакуйте полученный архив в папку /opt:
sudo tar -C /opt -xzf go1.15.2.linux-amd64.tar.gz
Тут тоже установка завершена. Осталось добавить путь к исполняемым файлам go в переменную среды PATH:
Теперь можно проверить версию Golang:
Если всё хорошо, отредактируйте файл /etc/environment и добавьте в строку объявления PATH путь /opt/go/bin:
Изменения будут применены только после перезагрузки.
3. Установка из PPA
В последнее время PPA один за другим перестают обновляться и поддерживать новые версии Ubuntu, но этот всё ещё работает и содержит довольно свежую версию компилятора Golang - 1.15. Для добавления PPA в систему выполните такие команды:
sudo add-apt-repository ppa:longsleep/golang-backports
Затем для установки достаточно выполнить:
sudo apt install golang
Тестирование языка Go
Особенность Go в том, что все пакеты, которые вы создаете должны находится в определённой папке. Go не будет искать пакеты сначала в текущей папке проекта, как это делается обычно, а будет пытаться их найти в папке указанной в переменной окружения GOPATH. Поэтому сначала создадим рабочую папку для исходников в домашней папке:
Дальше нужно сообщить Go, где находится наша папка для проектов, для этого с помощью GOPATH:
Эту же строку можно добавить в /etc/profile, чтобы не вводить её каждый раз. Обратите внимание, что в рабочей папке есть папка src, а уже в ней нужно создавать папки проектов, для каждого проекта отдельная папка. Дальше создадим небольшую программу, которая будет выводить только одну строчку на экран:
package main
import "fmt"
func main() fmt.Println("hello, world")
>
Теперь соберем программу:
Затем программу можно выполнить такой командой:
Программу можно не только собрать, но и установить с помощью команды install:
Тогда исполняемый файл программы будет создан не в текущей папке а в данном примере в $HOME/work/bin. Если эта папка не существует, то она будет создана.
Выводы
В этой статье мы рассмотрели как выполняется установка go на ubuntu, здесь есть целых два метода и вы обязательно подберете тот, который подходит для вас больше всего. Если у вас остались вопросы, спрашивайте в комментариях!
Оцените статью:
(10 оценок, среднее: 4,20 из 5)Об авторе
5 комментариев
вот такую фигню пишет:
adminofsystem@Admin-PC
/work/src/hello $ go install hello.go
go install: no install location for .go files listed on command line (GOBIN not set)
и что с этим делать?
go command [arguments]
build compile packages and dependencies
clean remove object files
doc show documentation for package or symbol
env print Go environment information
bug start a bug report
fix run go tool fix on packages
fmt run gofmt on package sources
generate generate Go files by processing source
get download and install packages and dependencies
install compile and install packages and dependencies
list list packages
run compile and run Go program
test test packages
tool run specified go tool
version print Go version
vet run go tool vet on packages
Use "go help [command]" for more information about a command.
Additional help topics:
c calling between Go and C
buildmode description of build modes
filetype file types
gopath GOPATH environment variable
environment environment variables
importpath import path syntax
packages description of package lists
testflag description of testing flags
testfunc description of testing functions
Смог решить эту проблему по этой статье.
Ключевой была эта строчка:
"Note: Set the GOBIN path to generate a binary file when go install is run.
Читайте также: