Как запустить файл go

Обновлено: 21.11.2024

Это второе руководство из нашей серии руководств по Golang. Пожалуйста, прочтите наше предыдущее руководство Введение и установка Golang, чтобы узнать, что такое Golang и как его установить.

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

Настройка среды разработки

Давайте создадим каталог, в котором мы хотим написать нашу программу hello world. Откройте терминал и выполните следующую команду.

Приведенная выше команда создаст каталог с именем Learngo внутри каталога Documents текущего пользователя. Не стесняйтесь создавать каталог там, где вы хотите разместить код.

Создание модуля Go

Модули Go используются для отслеживания зависимостей нашего приложения и их версий. Следующим шагом является создание модуля go с именем learninggo в папке ~/Documents/learngo/.

Запустите go mod init Learngo в каталоге ~/Documents/learngo/. Это создаст файл с именем go.mod. Содержимое файла представлено ниже.

Первая строка модуля learninggo указывает имя модуля. Следующая строка go 1.17 указывает, что файлы в этом модуле используют go версии 1.17

Мы обсудим модули Go более подробно, когда узнаем о пакетах.

Привет, мир

Создайте файл с именем main.go в каталоге Learngo с помощью вашего любимого текстового редактора со следующим содержимым.

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

Запуск программы go

Есть несколько способов запустить программу Go. Давайте рассмотрим их один за другим.

1. иди устанавливай

Первый способ запустить программу Go — использовать команду go install.
Давайте перейдем в только что созданный каталог Learngo.

Запустите следующую команду.

Приведенная выше команда скомпилирует программу и установит (скопирует) двоичный файл в папку ~/go/bin . Имя бинарника будет папкой, содержащей main.go. В нашем случае он будет называться Learngo .

При попытке установить программу вы можете столкнуться со следующей ошибкой.

Вышеупомянутая ошибка на самом деле означает, что go install не может найти место для установки скомпилированного двоичного файла. Итак, давайте продолжим и дадим ему место. Это расположение определяется переменной среды GOBIN.

Приведенная выше команда указывает, что go install должен скопировать скомпилированный двоичный файл по пути ~/go/bin/ . Это обычное место для бинарного файла Go, но вы можете изменить его на любое другое. Теперь попробуйте снова запустить go install, и программа должна скомпилироваться и запуститься без проблем.

Вы можете ввести ls -al ~/go/bin/learngo в терминале, и вы обнаружите, что на самом деле go install поместил двоичный файл в путь ~/go/bin

Теперь запустим скомпилированный двоичный файл.

Приведенная выше команда запустит двоичный файл Learngo и напечатает следующий вывод.

Поздравляем! Вы успешно запустили свою первую программу Go.

Если вы хотите не вводить весь путь ~/go/bin/learngo каждый раз при запуске программы, вы можете добавить ~/go/bin/ в свой PATH.

Теперь вы можете просто ввести в терминале learninggo, чтобы запустить программу.

Возможно, вам интересно, что произойдет, если каталог Learngo будет содержать несколько файлов go вместо main.go . Как пойдёт работа установки в этом случае? Пожалуйста, подождите, мы обсудим это, когда узнаем о пакетах и модулях go.

2. иди строй

Второй вариант запуска программы — использование go build . go build очень похож на go install, за исключением того, что он не устанавливает (копирует) скомпилированный двоичный файл по пути ~/go/bin/ , а создает двоичный файл внутри места, из которого был установлен go build.

Введите следующую команду в терминал

чтобы изменить текущий каталог на Learngo .

После этого введите следующую команду.

Приведенная выше команда создаст двоичный файл с именем Learngo в текущем каталоге. ls -al покажет, что создан файл с именем Learngo.

Введите ./learngo, чтобы запустить программу. Это также напечатает

Мы успешно запустили нашу первую программу Go с помощью go build :)

3. беги

Третий способ запустить программу — использовать команду go run.

Введите в терминале команду cd ~/Documents/learngo/, чтобы изменить текущий каталог на Learngo.

После этого введите следующую команду.

После ввода вышеуказанной команды мы можем увидеть вывод

Одно тонкое различие между командами go run и go build/go install заключается в том, что go run требует в качестве аргумента имя файла .go.

Под капотом go run работает так же, как go build . Вместо того, чтобы компилировать и устанавливать программу в текущий каталог, она компилирует файл во временное место и запускает файл из этого места.Если вам интересно узнать, куда go run компилирует файл, запустите go run с аргументом --work.

Выполнение приведенной выше команды в моем случае приводит к выводу

Значение ключа WORK указывает временное расположение, в которое будет скомпилирована программа.
В моем случае программа была скомпилирована в папку /var/folders/23/vdjz4kt972g5nzr86wzrj9740000gq/T/go-build698353814/b001/exe. В вашем случае это может отличаться :)

4. Перейти на игровую площадку

Последний способ запустить программу — использовать игровую площадку go. Хотя у этого есть ограничения, этот метод удобен, когда мы хотим запускать простые программы, поскольку он использует браузер и не требует установки Go на вашем локальном компьютере :). Я создал игровую площадку для программы hello world. Нажмите здесь, чтобы запустить программу онлайн.

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

Теперь, когда мы знаем 4 разных способа запуска программы, вы можете запутаться, какой метод использовать. Ответ: это зависит. Я обычно использую игровую площадку, когда хочу быстро проверить логику или узнать, как работает стандартная библиотечная функция. В большинстве других случаев я предпочитаю go install, так как это дает мне возможность запускать программу из любого каталога в терминале, поскольку он компилирует все программы в стандартный путь ~/go/bin/.

Краткое объяснение программы hello world

Вот программа hello world, которую мы только что написали

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

package main — каждый файл go должен начинаться с оператора имени пакета. Пакеты используются для обеспечения разделения кода и повторного использования. Здесь используется имя пакета main. Основная функция всегда должна находиться в основном пакете.

import "fmt" — оператор импорта используется для импорта других пакетов. В нашем случае импортируется пакет fmt, который будет использоваться внутри основной функции для вывода текста на стандартный вывод.

func main() — ключевое слово func отмечает начало функции. Основная — это специальная функция. Выполнение программы начинается с основной функции. Скобки < и >обозначают начало и конец основной функции.

fmt.Println("Hello World") — функция Println пакета fmt используется для записи текста в стандартный вывод. package.Function() — это синтаксис для вызова функции в пакете.

Код доступен для загрузки на github.

Теперь вы можете перейти к третьей части руководства по Golang: Переменные, чтобы узнать о переменных в Go.

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

Следующее руководство — Переменные

Навин Раманатан

Навин Раманатан (Naveen Ramanathan) — инженер-программист, интересующийся Go, Docker, Kubernetes, Swift, Python и Web Assembly. Если вы хотите нанять его, напишите по адресу naveen[at]golangbot[dot]com.

Традиционно первая программа, которую вы пишете на любом языке программирования, называется программой «Hello World». Это программа, которая просто выводит Hello World на ваш терминал. Давайте напишем его на Go.

Сначала создайте новую папку, в которой мы сможем хранить нашу программу. Создайте папку с именем ~/src/golang-book/chapter2. (Где ~ означает ваш домашний каталог) Из терминала вы можете сделать это, введя следующие команды:

В текстовом редакторе введите следующее:

Убедитесь, что ваш файл идентичен показанному здесь, и сохраните его как main.go в только что созданной папке. Откройте новый терминал и введите следующее:

Вы должны увидеть Hello World в своем терминале. Команда go run берет последующие файлы (разделенные пробелами), компилирует их в исполняемый файл, сохраняемый во временном каталоге, а затем запускает программу. Если вы не видите Hello World, возможно, вы допустили ошибку при наборе текста в программе. Компилятор Go подскажет, в чем заключается ошибка. Как и большинство компиляторов, компилятор Go крайне педантичен и не терпит ошибок.

Как читать программу на Go

Давайте рассмотрим эту программу более подробно. Программы Go читаются сверху вниз и слева направо. (как книга) Первая строка гласит:

Это известно как "объявление пакета". Каждая программа Go должна начинаться с объявления пакета. Пакеты — это способ организации и повторного использования кода в Go. Существует два типа программ Go: исполняемые файлы и библиотеки. Исполняемые приложения — это виды программ, которые мы можем запускать прямо из терминала. (в Windows они заканчиваются на .exe ) Библиотеки — это наборы кода, которые мы упаковываем вместе, чтобы мы могли использовать их в других программах. Мы рассмотрим библиотеки более подробно позже, а сейчас просто включите эту строку в любую программу, которую вы пишете.

Следующая строка — пустая. Компьютеры представляют новые строки специальным символом (или несколькими символами).Новые строки, пробелы и табуляции называются пробелами (потому что вы их не видите). Go в основном не заботится о пробелах, мы используем их, чтобы программы было легче читать. (Вы можете удалить эту строку, и программа будет вести себя точно так же)

Затем мы видим это:

Ключевое слово import определяет, как мы включаем код из других пакетов для использования в нашей программе. Пакет fmt (сокращение от format) реализует форматирование ввода и вывода. Учитывая то, что мы только что узнали о пакетах, как вы думаете, какие файлы пакета fmt будут содержаться вверху?

Обратите внимание, что fmt выше заключен в двойные кавычки. Использование подобных двойных кавычек известно как «строковый литерал», который является типом «выражения». В Go строки представляют собой последовательность символов (буквы, цифры, символы и т. д.) определенной длины. Строки более подробно описаны в следующей главе, но сейчас важно помнить, что за открывающим символом " должен в конце концов следовать другой символ ", и все, что находится между ними, включается в строку. (сам символ " не является частью строки)

Строка, начинающаяся с //, называется комментарием. Комментарии игнорируются компилятором Go и существуют только для вас (или для тех, кто берет исходный код вашей программы). Go поддерживает два разных стиля комментариев: // комментарии, в которых весь текст между // и концом строки является частью комментария, и /* */ комментарии, в которых все, что находится между символами *, является частью комментария. (И может включать несколько строк)

После этого вы увидите объявление функции:

Функции — это строительные блоки программы Go. У них есть входы, выходы и ряд шагов, называемых операторами, которые выполняются по порядку. Все функции начинаются с ключевого слова func, за которым следует имя функции (в данном случае main), список из нуля или более «параметров», заключенный в круглые скобки, необязательный тип возвращаемого значения и «тело», заключенное в фигурные скобки. Эта функция не имеет параметров, ничего не возвращает и имеет только один оператор. Имя main особенное, потому что это функция, которая вызывается при выполнении программы.

Последняя часть нашей программы — это строка:

Это заявление состоит из трех компонентов. Сначала мы обращаемся к другой функции внутри пакета fmt, которая называется Println (это часть fmt.Println, Println означает Print Line). Затем мы создаем новую строку, содержащую Hello World, и вызываем (также называемую вызовом или выполнением) эту функцию со строкой в качестве первого и единственного аргумента.

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

Создайте новую исполняемую программу, которая ссылается на библиотеку fmt и содержит одну функцию с именем main. Эта функция не принимает аргументов, ничего не возвращает и делает следующее: обращается к функции Println, содержащейся внутри пакета fmt, и вызывает ее, используя один аргумент — строку Hello World .

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

Среди прочего вы должны увидеть следующее:

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

Возвращаясь к рассматриваемой функции, эта документация говорит вам, что функция Println будет отправлять все, что вы ей введете, на стандартный вывод — имя для вывода терминала, в котором вы работаете. Именно эта функция вызывает Hello World для отображения.

В следующей главе мы рассмотрим, как Go хранит и представляет такие вещи, как Hello World, изучая типы.

Проблемы

Что такое пробел?

Что такое комментарий? Какие существуют два способа написания комментария?

Наша программа началась с пакета main . С чего должны начинаться файлы в пакете fmt?

Мы использовали функцию Println, определенную в пакете fmt. Если бы мы хотели использовать функцию Exit из пакета os, что бы нам нужно было сделать?

Измените написанную нами программу так, чтобы вместо Hello World она выводила Hello, после моего имени следует ваше имя.

Части этой страницы могут содержать изменения, основанные на работе, созданной и опубликованной Google, и используемые в соответствии с условиями, описанными в лицензии Creative Commons 3.0 Attribution.

До сих пор в нашей серии «Как кодировать на Go» вы использовали команду go run для автоматической компиляции исходного кода и запуска полученного исполняемого файла.Хотя эта команда полезна для тестирования вашего кода в командной строке, для распространения или развертывания вашего приложения требуется, чтобы вы встроили свой код в общедоступный двоичный исполняемый файл или в один файл, содержащий машинный байтовый код, который может запускать ваш заявление. Для этого вы можете использовать цепочку инструментов Go для сборки и установки вашей программы.

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

В этом руководстве вы будете использовать цепочку инструментов Go для запуска, сборки и установки примера Hello, World! программа, позволяющая эффективно использовать, распространять и развертывать будущие приложения.

Предпосылки

Чтобы следовать примеру из этой статьи, вам потребуется:

Шаг 1 — Настройка и запуск двоичного файла Go

Сначала создайте приложение, которое будет использоваться в качестве примера для демонстрации цепочки инструментов Go. Для этого вы будете использовать классический «Hello, World!» из учебника «Как написать свою первую программу на Go».

Создайте каталог с именем Greeter в вашем каталоге src:

Затем перейдите во вновь созданный каталог и создайте файл main.go в текстовом редакторе по вашему выбору:

Открыв файл, добавьте следующее содержимое:

При запуске эта программа напечатает фразу Hello, World! в консоль, после чего программа успешно завершится.

Сохраните и закройте файл.

Чтобы протестировать программу, используйте команду go run, как вы делали это в предыдущих руководствах:

Вы получите следующий результат:

Как упоминалось ранее, команда go run преобразовала исходный файл в исполняемый двоичный файл, а затем запустила скомпилированную программу. Тем не менее, это руководство направлено на создание двоичного файла таким образом, чтобы вы могли делиться им и распространять его по своему усмотрению. Для этого на следующем шаге вы воспользуетесь командой go build.

Шаг 2. Создание модуля Go для сборки двоичного файла Go

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

Чтобы сообщить Go, что это модуль Go, вам необходимо создать модуль Go с помощью команды go mod:

Это создаст файл go.mod , который будет содержать имя модуля и версию Go, которая использовалась для его сборки.

Шаг 3 — Сборка двоичных файлов Go с помощью go build

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

Попробуйте это с main.go . В вашем каталоге приветствия выполните следующую команду:

Если вы не укажете аргумент этой команде, go build автоматически скомпилирует программу main.go в вашем текущем каталоге. Команда будет включать все ваши файлы *.go в каталоге. Он также создаст весь вспомогательный код, необходимый для запуска двоичного файла на любом компьютере с такой же системной архитектурой, независимо от того, есть ли в этой системе исходные файлы .go или даже установка Go.

В этом случае вы встроили приложение приветствия в исполняемый файл, который был добавлен в ваш текущий каталог. Проверьте это, выполнив команду ls:

Если вы используете macOS или Linux, вы найдете новый исполняемый файл, названный в честь каталога, в котором вы создали свою программу:

Примечание. В Windows вашим исполняемым файлом будет Greeter.exe .

По умолчанию go build создает исполняемый файл для текущей платформы и архитектуры. Например, если он построен на системе linux/386, исполняемый файл будет совместим с любой другой системой linux/386, даже если Go не установлен. Go поддерживает сборку для других платформ и архитектур, о чем вы можете узнать больше в нашей статье Создание приложений Go для разных операционных систем и архитектур.

Теперь, когда вы создали исполняемый файл, запустите его, чтобы убедиться, что двоичный файл собран правильно. В macOS или Linux выполните следующую команду:

Вывод двоичного файла будет соответствовать выводу, когда вы запускали программу с помощью go run :

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

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

Шаг 4 — Изменение двоичного имени

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

Когда вы запускаете go build , по умолчанию Go автоматически выбирает имя создаваемого исполняемого файла. Это делается с помощью модуля, который вы создали ранее. Когда команда go mod init Greeter была запущена, она создала модуль с именем «greeter», поэтому сгенерированный двоичный файл, в свою очередь, называется «greeter».

Давайте подробнее рассмотрим модульный метод. Если в вашем проекте есть файл go.mod с объявлением модуля, например, следующим:

Тогда именем по умолчанию для сгенерированного исполняемого файла будет shark .

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

Чтобы проверить это, измените имя исполняемого файла, созданного в предыдущем разделе, на hello и поместите его в подпапку с именем bin . Вам не нужно создавать эту папку; Go сделает это самостоятельно в процессе сборки.

Выполните следующую команду go build с флагом -o:

Флаг -o заставляет Go сопоставлять вывод команды с любым выбранным вами аргументом. В этом случае результатом является новый исполняемый файл с именем hello в подпапке с именем bin .

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

Вы получите следующий вывод:

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

Шаг 5 — Установка программ Go с помощью go install

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

Чтобы понять, что это означает, вы будете использовать команду go install для установки вашего примера приложения.

Команда go install ведет себя почти так же, как и команда go build , но вместо того, чтобы оставить исполняемый файл в текущем каталоге или каталоге, указанном флагом -o, она помещает исполняемый файл в каталог $GOPATH/bin.

Чтобы узнать, где находится ваш каталог $GOPATH, выполните следующую команду:

Вывод, который вы получите, может отличаться, но по умолчанию используется каталог go внутри вашего каталога $HOME:

Поскольку go install помещает сгенерированные исполняемые файлы в подкаталог $GOPATH с именем bin , этот каталог необходимо добавить в переменную среды $PATH. Это описано в шаге «Создание рабочей области Go» в обязательной статье «Как установить Go и настроить локальную среду программирования».

Установив каталог $GOPATH/bin, вернитесь в каталог приветствия:

Теперь запустите команду установки:

Это создаст ваш двоичный файл и поместит его в $GOPATH/bin . Чтобы проверить это, выполните следующее:

Это покажет содержимое $GOPATH/bin :

Примечание. Команда go install не поддерживает флаг -o, поэтому для имени исполняемого файла будет использоваться имя по умолчанию, описанное ранее.

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

Для запуска программы используйте следующее:

Это даст следующее:

Теперь вы можете взять написанные вами программы и установить их в свою систему, что позволит вам использовать их где угодно и когда угодно.

Заключение

В этом руководстве вы продемонстрировали, как набор инструментов Go упрощает создание исполняемых двоичных файлов из исходного кода. Эти двоичные файлы можно распространять для запуска в других системах, даже в тех, в которых нет инструментов и сред Go. Вы также использовали go install для автоматической сборки и установки наших программ в виде исполняемых файлов в $PATH системы. Благодаря go build and go install у вас теперь есть возможность поделиться своим приложением и использовать его по своему усмотрению.

Теперь, когда вы знаете основы go build , вы можете узнать, как создавать модульный исходный код с помощью руководства по настройке двоичных файлов Go с помощью тегов сборки или как выполнять сборку для разных платформ с помощью создания приложений Go для разных операционных систем и архитектур. Если вы хотите узнать больше о языке программирования Go в целом, ознакомьтесь со всей серией статей How To Code in Go.

Хотите узнать больше? Присоединяйтесь к сообществу DigitalOcean!

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

Серия руководств: Как программировать на Go

Go (или GoLang) – это современный язык программирования, первоначально разработанный Google, в котором используется высокоуровневый синтаксис, аналогичный языкам сценариев. Он популярен благодаря минимальному синтаксису и инновационной обработке параллелизма, а также инструментам, которые он предоставляет для создания собственных двоичных файлов на иностранных платформах.

Я создал на рабочем столе папку с именем gocode, поместил в нее три папки с именами src, pkg и bin.

И код хранится в src, и когда я хочу запустить код, я получаю следующее сообщение.
моя команда была go run main.go
вывод, который я получил, был stat main.go: нет такого файла или каталога

Понятия не имею, почему он не находит каталог.

1 Ответ 1

Чтобы запустить файл .go, а не скомпилированный двоичный файл, необходимо указать go run относительный путь к исходному файлу. Попробуйте:

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

Это сработает, если.

можно найти; проверьте это с помощью команды go . Возвращает ли он путь?
Ваша среда GOPATH настроена правильно; проверьте это с помощью echo $GOPATH . Возвращает ли он каталог проекта? Советы см. на вики-странице go на GOPATH.

Откройте новое окно Terminal.app. Это приведет к отмене предыдущих команд экспорта, которые могут вызывать путаницу.

Тест можно найти. Используйте which go, чтобы убедиться, что двоичный файл доступен. Если нет, исправьте это с помощью команды экспорта.

Проверьте структуру каталогов вашего проекта. Убедитесь, что в именах нет ошибок, а ваши файлы .go имеют правильный суффикс. Finder может скрывать истинный суффикс. Выводит ли ls -lR ожидаемое содержимое?

Убедитесь, что вы находитесь в правильном каталоге. Команды go необходимо выполнять из каталога проекта. Используйте pwd, чтобы узнать, в каком каталоге вы находитесь? Это каталог проекта gocode/ ? Если нет, используйте команду cd, чтобы исправить это.

Макет проекта

Предположим, что ваша файловая структура соответствует минимальному соглашению go:

Три отдельные команды для запуска main.go:

Это запустит основную функцию в main.go . Чтобы собрать исполняемый файл, пригодный для распространения, используйте команду go build src/main.go .

Что касается управления гопатами и проектами, я добился успеха с подходом Герберта Фишера «Управление несколькими каталогами GOPATH с легкостью».

Этот файл содержит двунаправленный текст Unicode, который может быть интерпретирован или скомпилирован не так, как показано ниже. Для просмотра откройте файл в редакторе, который показывает скрытые символы Unicode. Подробнее о двунаправленных символах Юникода

// usr/bin/env go run $0 "$@"; выход

основной пакет

импорт (

"fmt"

"os"

)

func main()

фмт . Println ("Привет, мир!")

cwd, _ := os. Getwd()

fmt . Println("cwd:", cwd)

fmt. Println( "args:" , os .Args [ 1 :])

комментарий msoap от 13 марта 2015 г.

Установить первую строку (вместо shebang): //usr/bin/env go run $0 "$@"; выйдите
и запустите:

прокомментировал dlukes 9 июня 2015 г.

Очень приятно, большое спасибо! Я понятия не имел, что шебанги такие гибкие :) (я знаю, это все есть в википедии, но это казалось настолько тривиальной темой, что мне никогда не приходило в голову копнуть глубже. спасибо, что просветили меня!)

Прокомментировал AzTruLRD 29 декабря 2016 г. •

Мне нужно выполнить код GoLang как сценарий bash. Могу ли я использовать этот //usr/bin/env go run $0 "$@"; выйти, чтобы выполнить мой код без его компиляции?
Просто запустите его как ./my_file.go

Если ваш ответ «да», я пытался использовать его, но получил следующее //usr/bin/env: Нет такого файла или каталога и еще один вопрос, что означают цифры 1 и 2 после ./script.go ? ?

Комментарий msoap от 2 января 2017 г.

Использование /usr/bin/env — зависит от ОС. Что напечатано для какой среды или типа env ?

1 и 2 - это пример параметров скрипта.

estraph прокомментировал 3 мая 2017 г. •

@msoap Мне интересно, как это работает. Я копался в шебанге и магических числах, но, похоже, официальной поддержки магического числа // (0x2F 0x2F) не существует. Насколько я понимаю, при этом исполняемый файл будет запускаться как сценарий оболочки (каким-то образом по умолчанию?) и что он запускает всю первую строку (включая // ), который работает нормально ( //usr/bin/env действителен). Если бы это было магическое число, то // было бы пропущено.

Есть ли у вас какие-либо подробности о том, как это работает и насколько хорошо это будет поддерживаться в основных оболочках?

ОБНОВЛЕНИЕ, чтобы ответить на мой собственный вопрос: если нет шебанга и если тип исполняемого файла не может быть определен иначе с помощью подходящего магического числа, то устаревшее поведение UNIX заключается в запуске файла как скрипта с /bin/ ш . В данном случае это запуск скрипта с помощью sh , который, в свою очередь, запускает env и go run только для выхода после этого.

Читайте также: