Comment définir la variable d'environnement GOPATH sur Ubuntu? Quel fichier dois-je modifier?

J'essaie de faire un go get:

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

et il échoue avec l'erreur suivante:

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

quand je fais un go env, une liste de valeurs Go est affichée comme ci-dessous:

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"

clairement le GOPATH n'est pas réglé, comment et où dois-je le régler?

Je vois de nombreux threads qui mentionnent cette erreur mais aucun qui fournit une réponse à ma question, quel fichier doit être modifié pour fournir une valeur pour ce chemin?

Nouvelle façon:

Découvrez cette réponse.

Old Way:

Ajoutez simplement les lignes suivantes à ~ / .bashrc et cela persistera. Cependant, vous pouvez utiliser d'autres chemins que vous aimez comme GOPATH au lieu de $ HOME / go dans mon exemple.

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

Ubuntu 14.04

export GOPATH=$HOME/go

De plus, vous pouvez ajouter cette chaîne au fichier

$HOME/.bashrc

GOPATH doit être défini sur un répertoire vide nouvellement créé. C'est le go "workspace", où il télécharge des packages, et cetera. J'utilise ~ / .go.

Par exemple:

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

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

Nouvelle façon: modules Go

Depuis Go 1.11, vous n'avez plus besoin d'utiliser GOPATH. Accédez simplement à votre répertoire de projet et faites-le une fois:

go mod init github.com/youruser/yourrepo

• Avec cela, Go crée une racine de module dans ce répertoire.
• Vous pouvez créer autant de modules que vous le souhaitez.
• Pour des instructions étape par étape, consultez également cette réponse .

Old Way: GOPATH

Si vous insistez pour travailler avec GOPATH, tenez compte de ceci:

• Depuis Go 1.8, vous n'avez pas besoin de régler votre GOPATH ou GOROOT.
• GOPATH par défaut se trouve sous votre répertoire utilisateur / home.

De la documentation :

Si aucun GOPATH n'est défini, il est supposé être $ HOME / go sur les systèmes Unix et% USERPROFILE% \ go sur Windows. Si vous souhaitez utiliser un emplacement personnalisé comme espace de travail, vous pouvez définir la variable d'environnement GOPATH.

Si par exemple, c'est un Ubuntu, après avoir installé les packages:

$sudo apt install golang -y

Ajoutez simplement les lignes suivantes à ~ / .bashrc (de votre utilisateur)

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

export GOPATH=/path/desired/here

Il n'est pas nécessaire de modifier un fichier, nous pouvons simplement utiliser la commande ci-dessus pour modifier directement les variables d'environnement Go.

Écrivez ce code dans le terminal.

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

Remarque : Cela sera réinitialisé à chaque nouvelle fenêtre de terminal ou redémarrage du système.

Pour être persistant, collez le code ci-dessous dans votre fichier .zshrcou .bashrcen fonction de votre shell. Ces fichiers dans votre répertoire personnel . Ce sera comme ci-dessous.

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

Vous aurez également besoin de GOPATH plus tard. Alors ajoutez-le à ~/.bashrc.

Si vous avez configuré quelque chose qui nécessite une modification des variables d'environnement, par exemple Java, Go, etc., cela sera très familier.

Je suppose que vous avez la structure de répertoires suivante quelque part comme chemin d'accès:

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

• ouvrir un nouveau terminal
• type sudo nano /etc/environment
• trouver PATH=...et aller à la fin de celui-ci et ajouter un deux-points :après le dernier chemin, puis collez votre entier go pathpar exemple/home/user/gocode

et vous avez terminé, cela devrait le rendre persistant dans le système.

C'est ce qui m'a permis de travailler sur Ubuntu 15.10 en utilisant fish shell:

# ~/.config/fish/config.fish

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

Ensuite, j'ai dû modifier les autorisations sur le godossier (il était défini sur root)

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

go path pourrait être partout où vous voulez, il suffit de créer un répertoire et de définir la variable de chemin d'accès globale au nom de GOPATH dans votre environnement.

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

Avec Go 1.8 (Q2 2017), vous n'aurez pas à modifier de fichier si vous acceptez la GOPATHvaleur par défaut (définie pour vous)

$HOME/go

Vous pouvez voir les commentaires sur le numéro 17262 et le vote twitter associé :

En choisissant une valeur par défaut GOPATH, nous pouvons rendre notre documentation plus facile car nous pouvons dire des choses comme

$ go get github.com/foo/bar

vérifiera le github.com/foo/bardépôt en $HOME/go/src/github.com/foo/bar.

Nous n'avons pas besoin de distraire les nouveaux arrivants avec la nécessité de définir une variable env, il suffit de mettre une petite note entre parenthèses au bas de la page

$HOME/goest le chemin par défaut vers votre espace de travail go.
Si vous souhaitez modifier ce chemin, définissez la GOPATHvariable sur quelque chose de votre choix.

Mon environnement de go ressemblait au vôtre.

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

Je l'ai résolu en définissant GOPATH sur / usr / lib / go . Essaye le.

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

GOPATH est une variable d'environnement de votre emplacement d'espace de travail. GOROOT est une variable d'environnement de votre répertoire d'installation. Bien que GOROOT et GOPATH soient automatiquement définis (s'il n'y aurait pas de bogue) pendant le temps d'installation, pour le spécifier manuellement, vous pouvez suivre le processus ci-dessous. De plus, pour plus d'informations, vous pouvez vous référer à la page wiki de GO .

Il est préférable de définir GOPATH dans un répertoire de votre répertoire personnel, par exemple, $ HOME / go,% USERPROFILE% \ go (Windows).

1. Il s'agit d'une solution mac, qui est testée sur macOS Sierra, ver. 10.12, ainsi que dans Gogland-EAP, qui a été introduit comme programmation IDE for Go par JetBrains.

Sur votre type de terminal

vim ~/.profile

dans le document ouvert sur le terminal, appuyez sur i et ajoutez le chemin suivant

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

appuyez sur ESC et tapez : x . Enfin, vous devez redémarrer ( fermer et ouvrir ) votre terminal ou vous déconnecter et vous reconnecter.

2. Pour la configuration Windows et Linux, veuillez vous référer à la page Go Go sur Githab sur la configuration de GOPATH-Golang .

ATTENTION Ne définissez pas GOROOT et GOPATH dans le même répertoire, sinon vous obtiendrez un avertissement.

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

Et vous voudrez peut-être vérifier par $ go env

(Ubuntu)

Si vous ne définissez pas de GOPATH, la valeur par défaut sera utilisée.

Vous devez ajouter $ GOPATH / bin à votre PATH pour exécuter tout binaire installé dans $ GOPATH / bin, ou vous devez taper $ GOPATH / bin / the-command. Ajoutez ceci à votre ~ / .bash_profile

export PATH=$GOPATH/bin:$PATH

Commande GOPATH actuelle:

go env GOPATH

Modification de la commande GOPATH:

export GOPATH=$HOME/your-desired-path

Cela a été la chose la plus ennuyeuse à gérer. Dans l'espoir de gagner du temps.

IF go a été installé en tant qu'utilisateur root. L'utilisateur root du fichier texte bash_profile de votre système ~ / .bash_profile doit avoir $ GOROOT assigné au répertoire go install et $ GOPATH doit être assigné au répertoire 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]
    ...

assurez-vous que le chemin d'accès au binaire se trouve dans votre chemin sur .bash_profile

CHEMIN = $ CHEMIN: $ ACCUEIL / bin: / usr / local / bin: / usr / local / go / bin

Ce CHEMIN peut être aussi long qu'une chaîne qu'il doit être .. pour ajouter de nouveaux éléments séparés juste par deux points:

quitter l'éditeur vi et enregistrer le profil bash (: wq signifie écrire et quitter)

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

Vous devez vous déconnecter du terminal et vous reconnecter pour que le profil se lance à nouveau .. ou vous pouvez simplement le démarrer en utilisant l'exportation.

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

Vous pouvez vérifier go env:

...$# go env

Yay!

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

Maintenant, vous pouvez sudo et go pourront télécharger et créer des répertoires dans go / src et vous pourrez vous rendre à ce que vous essayez de faire.

exemple

# sudo go get github.com/..

Maintenant, vous rencontrerez un autre problème .. vous pourriez ne pas avoir installé git .. c'est une autre aventure .. :)

Sur ma machine Fedora 20, j'ai ajouté les lignes suivantes à mon ~ / .bashrc:

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

Encore une autre solution: exporter chaque GO*variable d'environnement dego 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"

Modifiez votre ~/.bash_profilepour ajouter la ligne suivante:

$ export GOPATH=$HOME/work

Enregistrez et quittez votre éditeur. Ensuite, sourcez votre~/.bash_profile

$ source ~/.bash_profile

Remarque: définissez le chemin GOBIN pour générer un fichier binaire lors de l'installation de go

$ export GOBIN=$HOME/work/bin

Ce script vous aidera à changer de Gopathes. https://github.com/buffonomics/goswitch

Comme écrit dans les instructions officielles :

La variable d'environnement GOPATH spécifie l'emplacement de votre espace de travail. Il utilise par défaut un répertoire nommé go dans votre répertoire personnel, donc $ HOME / go sur Unix, $ home / go sur Plan 9 et% USERPROFILE% \ go (généralement C: \ Users \ YourName \ go) sous Windows. Si vous souhaitez travailler dans un autre emplacement, vous devrez définir GOPATH sur le chemin de ce répertoire. (Une autre configuration courante consiste à définir GOPATH = $ HOME.) Notez que GOPATH ne doit pas être le même chemin que votre installation Go.

Ainsi, par exemple, si vous codez dans Jetbrains Webstorm (à l'aide du plug-in Go ), vous souhaiterez peut-être définir GOPATHcomme /Users/<user>/WebstormProjects.

En termes plus simples, définissez-le à l'endroit où vous souhaitez que vos projets Go résident.

Vous pouvez utiliser la solution "d'exportation" comme ce que les autres gars ont suggéré. Je voudrais vous fournir une autre solution pour une commodité permanente: vous pouvez utiliser n'importe quel chemin comme GOPATH lors de l'exécution des commandes Go.

Tout d'abord, vous devez télécharger un petit outil nommé gost: https://github.com/byte16/gost/releases . Si vous utilisez ubuntu, vous pouvez télécharger la version linux ( https://github.com/byte16/gost/releases/download/v0.1.0/gost_linux_amd64.tar.gz ).

Ensuite, vous devez exécuter les commandes ci-dessous pour le décompresser:

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

Vous obtiendriez un exécutable gost. Vous pouvez le déplacer /usr/local/binpour une utilisation pratique:

$ sudo mv gost /usr/local/bin

Exécutez la commande ci-dessous pour ajouter le chemin que vous souhaitez utiliser en tant que GOPATH dans le gestionnaire d'espace de chemin gost . Il est nécessaire de donner au chemin un nom que vous utiliserez plus tard.

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

Exécutez n'importe quelle commande Go que vous souhaitez au format:

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

Par exemple, vous souhaitez exécuter go get github.com/go-sql-driver/mysqlavec /home/foobar/barle GOPATH, faites-le comme ci-dessous:

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

Cela vous aiderait à définir le GOPATH et à exécuter la commande. Mais rappelez-vous que vous avez ajouté le chemin dans gostl' espace de chemin de . Si vous êtes sous n'importe quel niveau de sous-répertoires de /home/foobar/bar, vous pouvez même simplement exécuter la commande ci-dessous qui ferait la même chose pour faire court:

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

gostest un outil simple de Go qui peut vous aider à gérer les GOPATH et à exécuter les commandes Go. Pour plus de détails sur la façon de l'utiliser pour exécuter d'autres commandes Go, vous pouvez simplement l'exécuter gost help goCmdName. Par exemple, vous voulez en savoir plus install, tapez simplement les mots ci-dessous dans:

$ gost help install

Vous pouvez également trouver plus de détails dans le README du projet: https://github.com/byte16/gost/blob/master/README.md

Vous devez mettre à jour le PATH en fonction du terminal (bash ou zsh) que vous utilisez.

1. Ouvrez le fichier de script shell du terminal ie ~/.bashrcou ~/.zshrcdans un éditeur

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

2. Mettez à jour le GOPATH ci-dessous s'il est déjà trouvé ou ajoutez la ligne ci-dessous.

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

Ici, vous pouvez ajouter un ou plusieurs chemins séparés par un point-virgule à :partir de différents emplacements de vos projets GO sur le système à la GOPATHvariable d'environnement, /path/1:path/2:path/3etc.

Dans mon cas, j'ai ajouté 2 chemins, comme indiqué ci-dessus, l'un depuis la racine $HOME/goet l'autre depuis le répertoire des projets:/$HOME/projects/go