Wie setze ich die Umgebungsvariable GOPATH unter Ubuntu? Welche Datei muss ich bearbeiten?

Ich versuche ein go get:

go get github.com/go-sql-driver/mysql

und es schlägt mit dem folgenden Fehler fehl:

package github.com/go-sql-driver/mysql: cannot download, $GOPATH not set. For more details see: go help gopath

Wenn ich a mache go env, wird eine Liste von Go-Werten wie folgt angezeigt:

ubuntu@ip-xxx-x-xx-x:~$ go env
GOARCH="amd64"
GOBIN=""
GOCHAR="6"
GOEXE=""
GOHOSTARCH="amd64"
GOHOSTOS="linux"
GOOS="linux"
GOPATH=""
GORACE=""
GOROOT="/usr/lib/go"
GOTOOLDIR="/usr/lib/go/pkg/tool/linux_amd64"
CC="gcc"
GOGCCFLAGS="-g -O2 -fPIC -m64 -pthread"
CGO_ENABLED="1"

klar ist der GOPATH nicht eingestellt, wie und wo stelle ich ihn ein?

Ich sehe viele Threads, die diesen Fehler erwähnen, aber keinen, der eine Antwort auf meine Frage liefert. Welche Datei muss bearbeitet werden, um einen Wert für diesen Pfad bereitzustellen?

Neuer Weg:

Schauen Sie sich diese Antwort an.

Alter Weg:

Fügen Sie einfach die folgenden Zeilen zu ~ / .bashrc hinzu, und dies bleibt bestehen. Sie können jedoch andere Pfade verwenden, die Sie als GOPATH anstelle von $ HOME / go in meinem Beispiel mögen .

export GOPATH=$HOME/go
export PATH=$PATH:$GOROOT/bin:$GOPATH/bin

Ubuntu 14.04

export GOPATH=$HOME/go

Zusätzlich können Sie diese Zeichenfolge zur Datei hinzufügen

$HOME/.bashrc

GOPATH sollte auf ein neu erstelltes leeres Verzeichnis gesetzt werden. Dies ist der "Arbeitsbereich", in dem Pakete usw. heruntergeladen werden. Ich benutze ~ / .go.

Beispielsweise:

mkdir ~/.go
echo "GOPATH=$HOME/.go" >> ~/.bashrc
echo "export GOPATH" >> ~/.bashrc
echo "PATH=\$PATH:\$GOPATH/bin # Add GOPATH/bin to PATH for scripting" >> ~/.bashrc
source ~/.bashrc

Quelle: http://www.larry-price.com/blog/2013/12/15/setting-up-a-go-environment-in-ubuntu-12-dot-04/

Neuer Weg: Go Module

Seit Go 1.11 müssen Sie GOPATH nicht mehr verwenden. Gehen Sie einfach in Ihr Projektverzeichnis und machen Sie dies einmal:

go mod init github.com/youruser/yourrepo

• Damit erstellt Go ein Modulstammverzeichnis in diesem Verzeichnis.
• Sie können beliebig viele Module erstellen.
• Eine schrittweise Anleitung finden Sie auch in dieser Antwort .

Alter Weg: GOPATH

Wenn Sie darauf bestehen, mit GOPATH zu arbeiten, beachten Sie Folgendes:

• Seit Go 1.8 müssen Sie weder GOPATH noch GOROOT einstellen.
• GOPATH befindet sich standardmäßig in Ihrem Benutzer- / Home-Verzeichnis.

Aus der Dokumentation :

Wenn kein GOPATH festgelegt ist, wird auf Unix-Systemen $ HOME / go und unter Windows% USERPROFILE% \ go angenommen. Wenn Sie einen benutzerdefinierten Speicherort als Arbeitsbereich verwenden möchten, können Sie die Umgebungsvariable GOPATH festlegen.

Wenn es sich zum Beispiel nach der Installation der Pakete um ein Ubuntu handelt:

$sudo apt install golang -y

Fügen Sie einfach die folgenden Zeilen zu ~ / .bashrc (Ihres Benutzers) hinzu.

export GOROOT=/usr/lib/go
export GOPATH=$HOME/go
export PATH=$PATH:$GOROOT/bin:$GOPATH/bin

export GOPATH=/path/desired/here

Es ist nicht erforderlich, eine Datei zu bearbeiten. Sie können einfach den obigen Befehl verwenden, um die Go-Umgebungsvariablen direkt zu bearbeiten.

Schreiben Sie diesen Code in Terminal.

export GOPATH=path/to/your/gopath/directory

Hinweis : Dies wird bei jedem neuen Terminalfenster oder Systemneustart zurückgesetzt.

Um dauerhaft zu sein, fügen Sie den folgenden Code entsprechend Ihrer Shell in Ihre .zshrcoder .bashrc-Datei ein. Diese Dateien in Ihrem Home-Verzeichnis . Es wird wie unten sein.

export PATH=path/to/some/other/place/composer/for/example
export GOPATH=path/to/your/gopath/directory
export PATH=$PATH:$GOPATH/bin

Sie werden GOPATH auch später brauchen. Also füge es hinzu ~/.bashrc.

Wenn Sie etwas eingerichtet haben, das geändert werden muss, z. B. Java, Go usw., ist dies sehr vertraut.

Ich gehe davon aus, dass Sie irgendwo die folgende Verzeichnisstruktur als Go-Pfad haben:

\---[folder name]
    +---bin
    +---pkg
    \---src

• Öffnen Sie ein neues Terminal
• Art sudo nano /etc/environment
• Finde PATH=...und gehe das Ende davon und füge :nach dem letzten Pfad einen Doppelpunkt hinzu, dann füge dein vollständiges go pathz/home/user/gocode

und Sie sind fertig. Dies sollte es durch das System dauerhaft machen.

Dies ist, was es für mich unter Ubuntu 15.10 mit folgenden Funktionen zum Laufen gebracht hatfish shell :

# ~/.config/fish/config.fish

set -g -x PATH /usr/local/bin $PATH
set -g -x GOPATH /usr/share/go

Dann musste ich die Berechtigungen für den goOrdner ändern (er wurde auf root gesetzt)

sudo chown <name>:<name> -R /usr/share/go

go path kann jeder Ort sein, an dem Sie einfach ein Verzeichnis erstellen und eine globale Pfadvariable im Namen von GOPATH für Ihre Umgebung festlegen möchten.

mkdir ~/go
export GOPATH=~/go
go get github.com/go-sql-driver/mysql

Mit Go 1.8 (2. Quartal 2017) müssen Sie keine Datei bearbeiten, wenn Sie den GOPATHfür Sie festgelegten Standardwert akzeptieren.

$HOME/go

Sie können die Kommentare zu Ausgabe 17262 und die dazugehörige Twitter-Abstimmung sehen :

Durch Auswahl eines Standards GOPATHkönnen wir unsere Dokumentation vereinfachen, da wir Dinge wie sagen können

$ go get github.com/foo/bar

wird das github.com/foo/barRepo in überprüfen $HOME/go/src/github.com/foo/bar.

Wir müssen Neulinge nicht davon ablenken, eine env-Variable festlegen zu müssen. Wir müssen lediglich eine kleine Anmerkung in Klammern am Ende der Seite einfügen

$HOME/goist der Standardpfad zu Ihrem Go-Arbeitsbereich.
Wenn Sie diesen Pfad ändern möchten, setzen Sie die GOPATHVariable auf etwas Ihrer Wahl.

Meine Go-Umgebung sah Ihrer ähnlich.

$go env
GOARCH="amd64"
GOBIN=""
GOEXE=""
GOHOSTARCH="amd64"
GOHOSTOS="linux"
GOOS="linux"
GOPATH=""
GORACE=""
GOROOT="/usr/lib/go-1.6"
GOTOOLDIR="/usr/lib/go-1.6/pkg/tool/linux_amd64"
GO15VENDOREXPERIMENT="1"
CC="gcc"
GOGCCFLAGS="-fPIC -m64 -pthread -fmessage-length=0"
CXX="g++"
CGO_ENABLED="1"

Ich habe es gelöst, indem ich GOPATH auf / usr / lib / go gesetzt habe . Versuch es.

export GOPATH=/usr/lib/go
export PATH=$PATH:$GOPATH/bin

GOPATH ist eine Umgebungsvariable für Ihren Arbeitsplatz. GOROOT ist eine Umgebungsvariable für Ihr Installationsverzeichnis. Obwohl GOROOT und GOPATH während der Installationszeit automatisch festgelegt werden (falls es keinen Fehler geben würde), können Sie den folgenden Vorgang ausführen , um ihn manuell anzugeben. Weitere Informationen finden Sie auf der Wiki-Seite von GO .

Es ist besser, GOPATH auf ein Verzeichnis in Ihrem Home-Verzeichnis festzulegen , z. B. $ HOME / go,% USERPROFILE% \ go (Windows).

1. Dies ist ein Lösungs-Mac, der unter macOS Sierra, ver. 10.12 und auch in Gogland-EAP, das von JetBrains als IDE für Go-Programmierung eingeführt wurde.

Auf Ihrem Terminaltyp

vim ~/.profile

Drücken Sie im geöffneten Dokument auf dem Terminal i und fügen Sie den folgenden Pfad hinzu

GOPATH=/path/to/a/directory/inside/home/directory
GOROOT=/path/to/you/go/library
PATH=$PATH:$GOPATH:$GOROOT:$GOROOT/bin

Drücken Sie ESC und geben Sie Folgendes ein : x . Zuletzt sollten Sie Ihr Terminal neu starten ( schließen und öffnen ) oder sich erneut abmelden und anmelden .

2. Informationen zur Windows- und Linux-Konfiguration finden Sie auf der Go-Wiki-Seite von Githab unter Einstellen von GOPATH-Golang .

VORSICHT nicht beide gesetzt GOROOT und GOPATH in das gleiche Verzeichnis, sonst erhalten Sie eine Warnung erhalten.

export GOROOT=/usr/lib/go
export GOPATH=$HOME/go
export PATH=$PATH:$GOROOT/bin

Und vielleicht möchten Sie nach $ go env suchen

(Ubuntu)

Wenn Sie keinen GOPATH festlegen, wird der Standardwert verwendet.

Sie müssen Ihrem PATH $ GOPATH / bin hinzufügen, um eine in $ GOPATH / bin installierte Binärdatei auszuführen, oder Sie müssen $ GOPATH / bin / the-command eingeben. Fügen Sie dies Ihrem ~ / .bash_profile hinzu

export PATH=$GOPATH/bin:$PATH

Aktueller GOPATH-Befehl:

go env GOPATH

Ändern des GOPATH-Befehls:

export GOPATH=$HOME/your-desired-path

Dies war die nervigste Sache, mit der man sich befassen musste. In der Hoffnung, Ihre Zeit zu sparen.

IF go wurde als Root-Benutzer installiert. Dem Root-Benutzer der bash_profile-Textdatei ~ / .bash_profile Ihres Systems muss $ GOROOT dem Verzeichnis go install und $ GOPATH dem Verzeichnis go / src zugewiesen sein.

  ...$# sudo su
  ...$# vi ~/.bash_profile

    ***Story continues in vi editor***

    GOROOT=$GOROOT:/usr/local/go
    GOPATH=$GOPATH:/usr/local/go/src
    ...
    [your regular PATH stuff here]
    ...

Stellen Sie sicher, dass sich der Pfad für die Binärdatei in Ihrem Pfad auf .bash_profile befindet

PATH = $ PATH: $ HOME / bin: / usr / local / bin: / usr / local / go / bin

Dieser Pfad kann so lang sein, wie er sein muss. Um neue Elemente hinzuzufügen, die nur durch Doppelpunkte getrennt sind:

Beenden Sie den vi-Editor und speichern Sie das Bash-Profil (: wq steht für Schreiben und Beenden)

  [esc] 
  [shift] + [:] 
  :wq

Sie müssen sich vom Terminal abmelden und erneut anmelden, damit das Profil erneut gestartet werden kann. Sie können es auch einfach mithilfe des Exports starten.

...$# export GOPATH=/usr/local/go/src

Sie können go env überprüfen:

...$# go env

Yay!

GOBIN=""
GOCHAR="6"
GOEXE=""
GOHOSTARCH="amd64"
GOHOSTOS="linux"
GOOS="linux"
GOPATH="/usr/local/go/src"
GORACE=""
GOROOT="/usr/local/go"

Jetzt können Sie sudo and go Verzeichnisse in go / src herunterladen und erstellen und zu dem gelangen, was Sie versucht haben.

Beispiel

# sudo go get github.com/..

Jetzt wirst du auf ein anderes Problem stoßen. Vielleicht hast du Git nicht installiert. Das ist ein weiteres Abenteuer. :)

Auf meinem Fedora 20-Computer habe ich meinem ~ / .bashrc die folgenden Zeilen hinzugefügt:

export GOROOT=/usr/lib/golang
export GOPATH=$HOME/go
export PATH=$PATH:$GOROOT/bin:$GOPATH/bin

Noch eine andere Lösung: Exportieren Sie jede GO*Umgebungsvariable ausgo env

.bashrc:

eval $(go env | grep '^GO[A-Z0-9_]*=' | while read setenv; do
  echo "export $setenv; "
done 2> /dev/null)

[[ -n $GOPATH ]] || export GOPATH="$HOME/go/bin"
[[ -n $GOROOT ]] || export GOROOT=/usr/bin/go
export PATH="$PATH:$GOPATH/bin:$GOROOT/bin"

Bearbeiten Sie Ihre ~/.bash_profile, um die folgende Zeile hinzuzufügen:

$ export GOPATH=$HOME/work

Speichern Sie Ihren Editor und beenden Sie ihn. Dann beschaffen Sie Ihre~/.bash_profile

$ source ~/.bash_profile

Hinweis: Legen Sie den GOBIN-Pfad fest, um eine Binärdatei zu generieren, wenn go install ausgeführt wird

$ export GOBIN=$HOME/work/bin

Dieses Skript hilft Ihnen, Gopaths zu wechseln. https://github.com/buffonomics/goswitch

Wie in der geschrieben offiziellen Anleitung geschrieben :

Die Umgebungsvariable GOPATH gibt den Speicherort Ihres Arbeitsbereichs an. Der Standardwert ist ein Verzeichnis mit dem Namen go in Ihrem Home-Verzeichnis, also $ HOME / go unter Unix, $ home / go unter Plan 9 und% USERPROFILE% \ go (normalerweise C: \ Users \ YourName \ go) unter Windows. Wenn Sie an einem anderen Ort arbeiten möchten, müssen Sie GOPATH auf den Pfad zu diesem Verzeichnis setzen. (Ein weiteres gängiges Setup ist das Setzen von GOPATH = $ HOME.) Beachten Sie, dass GOPATH nicht derselbe Pfad wie Ihre Go-Installation sein darf.

Wenn Sie beispielsweise in Jetbrains Webstorm (mit dem Go-Plugin ) codieren , möchten Sie möglicherweise festlegenGOPATH , dass /Users/<user>/WebstormProjects.

Stellen Sie es in einfacheren Worten auf den Ort ein, an dem sich Ihre Go-Projekte befinden sollen.

Sie können die "Export" -Lösung genau so verwenden, wie es andere vorgeschlagen haben. Ich möchte Ihnen eine weitere Lösung zur dauerhaften Bequemlichkeit anbieten: Sie können einen beliebigen Pfad als GOPATH verwenden, wenn Sie Go-Befehle ausführen.

Zunächst müssen Sie den Namen ein kleines Tool zum Download gost: https://github.com/byte16/gost/releases . Wenn Sie Ubuntu verwenden, können Sie die Linux-Version herunterladen ( https://github.com/byte16/gost/releases/download/v0.1.0/gost_linux_amd64.tar.gz ).

Dann müssen Sie die folgenden Befehle ausführen, um es zu entpacken:

$ cd /path/to/your/download/directory 
$ tar -xvf gost_linux_amd64.tar.gz

Sie würden eine ausführbare Datei erhalten gost. Sie können es zur /usr/local/binbequemen Verwendung verschieben:

$ sudo mv gost /usr/local/bin

Führen Sie den folgenden Befehl aus, um den Pfad, den Sie als GOPATH verwenden möchten, in den Pfad hinzuzufügen, der verwaltetgost wird. Es ist erforderlich, dem Pfad einen Namen zu geben, den Sie später verwenden würden.

$ gost add foo /home/foobar/bar     # 'foo' is the name and '/home/foobar/bar' is the path

Führen Sie einen beliebigen Go-Befehl im folgenden Format aus:

gost goCommand [-p {pathName}] -- [goFlags...] [goArgs...]

Zum Beispiel wollen Sie laufen go get github.com/go-sql-driver/mysqlmit /home/foobar/barals GOPATH, tun Sie es einfach wie folgt:

$ gost get -p foo -- github.com/go-sql-driver/mysql  # 'foo' is the name you give to the path above.

Es würde Ihnen helfen, den GOPATH festzulegen und den Befehl auszuführen. Aber denken Sie daran , dass Sie den Weg in hinzugefügt haben gost‚s pathspace . Wenn Sie sich in einer beliebigen Ebene von Unterverzeichnissen von befinden /home/foobar/bar, können Sie sogar einfach den folgenden Befehl ausführen, der kurz dasselbe tun würde:

$ gost get -- github.com/go-sql-driver/mysql

gostist ein einfaches Go-Tool, mit dem Sie GOPATHs verwalten und Go-Befehle ausführen können. Weitere Informationen zur Verwendung anderer Go-Befehle finden Sie einfach gost help goCmdName. Wenn Sie beispielsweise mehr darüber erfahren möchten install, geben Sie einfach die folgenden Wörter ein in:

$ gost help install

Weitere Details finden Sie auch in der README-Datei des Projekts: https://github.com/byte16/gost/blob/master/README.md

Sie müssen den PFAD basierend auf dem von Ihnen verwendeten Terminal (bash oder zsh) aktualisieren.

1. Öffnen Sie die Shell-Skriptdatei des Terminals, dh ~/.bashrcoder ~/.zshrcin einem Editor

   vi ~/.zshrc
      (or)
   code ~/.zshrc

2. Aktualisieren Sie den folgenden GOPATH, falls er bereits gefunden wurde, oder fügen Sie die folgende Zeile hinzu.

export GOPATH=$HOME/go:/$HOME/projects/go

Hier können Sie :der GOPATHUmgebungsvariablen einen oder mehrere Pfade hinzufügen, die durch ein Semikolon von verschiedenen Positionen Ihrer GO-Projekte auf dem System getrennt sind/path/1:path/2:path/3 .

In meinem Fall habe ich wie oben gezeigt zwei Pfade hinzugefügt, einen aus dem Stammverzeichnis $HOME/gound einen aus dem Projektverzeichnis:/$HOME/projects/go