Come posso impostare la variabile d'ambiente GOPATH su Ubuntu? Quale file devo modificare?

Sto cercando di fare un go get:

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

e non riesce con il seguente errore:

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

quando faccio un go env, un elenco di valori Go viene mostrato come di seguito:

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"

chiaramente il GOPATH non è impostato, come e dove devo impostarlo?

Vedo molti thread che menzionano questo errore ma nessuno che fornisce una risposta alla mia domanda, quale file deve essere modificato per fornire un valore per questo percorso?

Nuovo modo:

Dai un'occhiata a questa risposta.

Vecchio modo:

Aggiungi le seguenti righe a ~ / .bashrc e questo persisterà. Tuttavia, puoi usare altri percorsi che ti piacciono come GOPATH invece di $ HOME / vai nel mio esempio.

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

Ubuntu 14.04

export GOPATH=$HOME/go

Inoltre è possibile aggiungere questa stringa al file

$HOME/.bashrc

GOPATH dovrebbe essere impostato su una directory vuota appena creata. Questo è lo "spazio di lavoro", dove scarica i pacchetti, eccetera. Uso ~ / .go.

Per esempio:

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

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

New Way: Go Modules

Da Go 1.11, non devi più usare GOPATH. Basta andare alla directory del progetto e farlo una volta:

go mod init github.com/youruser/yourrepo

• Con questo, Go crea un modulo root in quella directory.
• Puoi creare quanti moduli vuoi.
• Per istruzioni dettagliate, vedere anche questa risposta .

Old Way: GOPATH

Se insisti a lavorare con GOPATH, fai attenzione a questo:

• Da Go 1.8, non è necessario impostare GOPATH o GOROOT.
• GOPATH per impostazione predefinita si trova nella directory utente / home.

Dalla documentazione :

Se non è impostato GOPATH, si presume che sia $ HOME / go su sistemi Unix e% USERPROFILE% \ go su Windows. Se si desidera utilizzare una posizione personalizzata come area di lavoro, è possibile impostare la variabile di ambiente GOPATH.

Se per esempio, è un Ubuntu, dopo aver installato i pacchetti:

$sudo apt install golang -y

Aggiungi le seguenti righe a ~ / .bashrc (del tuo utente)

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

export GOPATH=/path/desired/here

Non è necessario modificare alcun file, possiamo semplicemente usare il comando sopra per modificare direttamente le variabili di ambiente Go.

Scrivi questo codice nel Terminale.

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

Nota : questo verrà ripristinato ad ogni nuova finestra Terminale o riavvio del sistema.

Per essere persistente, incolla il codice qui sotto nel tuo .zshrco .bashrcfile in base alla tua shell. Quei file nella tua home directory . Sarà come sotto.

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

Avrai bisogno di GOPATH anche in seguito. Quindi aggiungilo a ~/.bashrc.

Se hai impostato qualcosa che richiede la modifica delle variabili di ambiente, ad esempio Java, Go ecc., Questo sarà molto familiare.

Presumo che tu abbia la seguente struttura di directory da qualche parte come percorso Go:

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

• aprire un nuovo terminale
• genere sudo nano /etc/environment
• trovare PATH=...e andare alla fine di esso e aggiungere due punti :dopo l'ultimo percorso quindi incollare nel vostro pieno go pathpe/home/user/gocode

e il gioco è fatto, questo dovrebbe renderlo persistente attraverso il sistema.

Questo è ciò che ha funzionato per me su Ubuntu 15.10 usando fish shell:

# ~/.config/fish/config.fish

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

Quindi ho dovuto modificare i permessi sulla gocartella (era impostato su root)

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

go path potrebbe essere ovunque tu voglia semplicemente creare una directory e impostare la variabile path globale nel nome di GOPATH nel tuo ambiente.

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

Con Go 1.8 (Q2 2017), non dovrai modificare alcun file se accetti il GOPATHvalore predefinito (impostato per te)

$HOME/go

Puoi vedere i commenti sulla questione 17262 e il voto twitter associato :

Scegliendo un valore predefinito GOPATH, possiamo semplificare la nostra documentazione perché possiamo dire cose come

$ go get github.com/foo/bar

verificherà il github.com/foo/barrepository in $HOME/go/src/github.com/foo/bar.

Non abbiamo bisogno di distrarre i nuovi arrivati ​​con la necessità di impostare un ambiente, tutto ciò che dobbiamo fare è mettere una piccola nota tra parentesi in fondo alla pagina

$HOME/goè il percorso predefinito per l'area di lavoro di go.
Se si desidera modificare questo percorso, impostare la GOPATHvariabile su qualcosa di propria scelta.

Il mio ambiente go sembrava simile al tuo.

$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"

L'ho risolto impostando GOPATH su / usr / lib / go . Provalo.

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

GOPATH è una variabile d'ambiente in base alla posizione dello spazio di lavoro. GOROOT è una variabile d'ambiente nella directory di installazione. Sebbene GOROOT e GOPATH siano impostati automaticamente (se non ci sarebbe un bug) durante il tempo di installazione, per specificarlo manualmente è possibile seguire il processo seguente. Inoltre, per ulteriori informazioni è possibile fare riferimento alla pagina wiki di GO .

È meglio impostare GOPATH su una directory all'interno della home directory, ad esempio $ HOME / go,% USERPROFILE% \ go (Windows).

1. Questa è una soluzione mac, che è testata su macOS Sierra, ver. 10.12, e anche in Gogland-EAP, che è stato introdotto come IDE per la programmazione Go da JetBrains.

Sul tuo tipo di terminale

vim ~/.profile

nel documento aperto sul Terminale premere i e aggiungere il seguente percorso

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

premere ESC e digitare : x . Infine, è necessario riavviare ( chiudere e aprire ) il terminale o Disconnettersi e accedere nuovamente.

2. Per la configurazione di Windows e Linux, consultare la pagina Go wiki su Githab su Impostazione GOPATH-Golang .

ATTENZIONE Non impostare GOROOT e GOPATH sulla stessa directory, altrimenti verrà visualizzato un avviso.

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

E potresti voler controllare per $ go env

(Ubuntu)

Se non si imposta un GOPATH, verrà utilizzato il valore predefinito.

Devi aggiungere $ GOPATH / bin al tuo PERCORSO per eseguire qualsiasi binario installato in $ GOPATH / bin, oppure devi digitare $ GOPATH / bin / the-command. Aggiungi questo al tuo ~ / .bash_profile

export PATH=$GOPATH/bin:$PATH

Comando GOPATH corrente:

go env GOPATH

Modifica del comando GOPATH:

export GOPATH=$HOME/your-desired-path

Questa è stata la cosa più fastidiosa da affrontare. Nella speranza di risparmiare tempo.

IF go è stato installato come utente root. L'utente root del file di testo bash_profile del sistema ~ / .bash_profile deve avere $ GOROOT assegnato alla directory go install e $ GOPATH deve essere assegnato alla directory go / src.

  ...$# 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]
    ...

assicurati che il percorso per diventare binario sia nel tuo percorso su .bash_profile

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

Questo PERCORSO può essere lungo quanto una stringa deve essere..per aggiungere nuovi elementi separati da due punti:

uscire dall'editor vi e salvare il profilo bash (: wq sta per scrivere ed uscire)

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

Devi disconnetterti dal terminale e riconnetterti per riavviare il profilo .. oppure puoi semplicemente avviarlo usando export.

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

Puoi verificare go env:

...$# go env

Sìì!

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

Ora puoi fare sudo e andare, potrai scaricare e creare directory all'interno di go / src e puoi scendere a quello che stavi cercando di fare.

esempio

# sudo go get github.com/..

Ora incontrerai un altro problema ... potresti non aver installato git ... questa è un'altra avventura .. :)

Sulla mia macchina Fedora 20 ho aggiunto le seguenti righe al mio ~ / .bashrc:

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

Ancora un'altra soluzione: esportare ogni GO*variabile d'ambiente dago 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"

Modifica il tuo ~/.bash_profileper aggiungere la seguente riga:

$ export GOPATH=$HOME/work

Salva ed esci dal tuo editor. Quindi, fonte il tuo~/.bash_profile

$ source ~/.bash_profile

Nota: impostare il percorso GOBIN per generare un file binario quando si avvia go install

$ export GOBIN=$HOME/work/bin

Questo script ti aiuterà a cambiare Gopath. https://github.com/buffonomics/goswitch

Come scritto nelle istruzioni ufficiali :

La variabile di ambiente GOPATH specifica la posizione dell'area di lavoro. L'impostazione predefinita è una directory denominata go all'interno della home directory, quindi $ HOME / vai su Unix, $ home / vai al piano 9 e% USERPROFILE% \ go (di solito C: \ Users \ Nomeutente \ go) su Windows. Se desideri lavorare in una posizione diversa, dovrai impostare GOPATH sul percorso di quella directory. (Un'altra impostazione comune è impostare GOPATH = $ HOME.) Nota che GOPATH non deve essere lo stesso percorso dell'installazione di Go.

Quindi, ad esempio, se stai programmando in Jetbrains Webstorm (usando il plugin Go ), potresti voler impostare GOPATHcome /Users/<user>/WebstormProjects.

In parole più semplici, impostalo su dove vuoi che risiedano i tuoi progetti Go.

Puoi usare la soluzione "export" proprio come hanno suggerito altri ragazzi. Vorrei offrirti un'altra soluzione per comodità permanente: puoi usare qualsiasi percorso come GOPATH quando esegui i comandi Go.

Innanzitutto, devi scaricare un piccolo strumento chiamato gost: https://github.com/byte16/gost/releases . Se usi Ubuntu, puoi scaricare la versione di Linux ( https://github.com/byte16/gost/releases/download/v0.1.0/gost_linux_amd64.tar.gz ).

Quindi è necessario eseguire i comandi seguenti per decomprimerlo:

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

Otterresti un eseguibile gost. Puoi spostarlo in /usr/local/binper un comodo utilizzo:

$ sudo mv gost /usr/local/bin

Eseguire il comando seguente per aggiungere il percorso che si desidera utilizzare come GOPATH gost mantiene lo spazio dei percorsi . È necessario assegnare al percorso un nome da utilizzare in seguito.

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

Esegui qualsiasi comando Go desiderato nel formato:

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

Ad esempio, si desidera eseguire go get github.com/go-sql-driver/mysqlcon /home/foobar/baril GOPATH, basta fare come qui sotto:

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

Ti aiuterebbe a impostare GOPATH ed eseguire il comando. Ma ricorda che hai aggiunto il percorso nello spaziogost dei percorsi . Se ti trovi in ​​qualsiasi livello delle sottodirectory di /home/foobar/bar, puoi anche semplicemente eseguire il comando di seguito che farebbe la stessa cosa in breve:

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

gostè un semplice strumento di Go che può aiutarti a gestire GOPATH ed eseguire comandi Go. Per maggiori dettagli su come usarlo per eseguire altri comandi Go, puoi semplicemente eseguirlo gost help goCmdName. Ad esempio, per saperne di più install, basta digitare le parole in basso in:

$ gost help install

Puoi anche trovare maggiori dettagli nel README del progetto: https://github.com/byte16/gost/blob/master/README.md

Devi aggiornare il PERCORSO in base al terminale (bash o zsh) che usi.

1. Aprire il file di script della shell del terminale, ovvero ~/.bashrco ~/.zshrcin un editor

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

2. Aggiorna il GOPATH di seguito se già trovato o aggiungi la riga di seguito.

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

Qui puoi aggiungere uno o più percorsi separati da un punto e virgola :da diverse posizioni dei tuoi progetti GO sul sistema alla GOPATHvariabile d'ambiente, ad es /path/1:path/2:path/3.

Nel mio caso, ho aggiunto 2 percorsi, come mostrato sopra, uno dalla radice $HOME/goe l'altro dalla directory dei progetti:/$HOME/projects/go