ver variable restaurar permanentes modificar java_home gopath entorno crear configurar go

restaurar - ¿Cómo configuro la variable de entorno GOPATH en Ubuntu? ¿Qué archivo debo editar?



variable path windows 10 (21)

Estoy tratando de hacer un go get

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

y falla con el siguiente error:

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

cuando hago un go env de go, se muestra una lista de valores de Go como se muestra a continuación:

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"

claramente el GOPATH no está configurado, ¿cómo y dónde lo configuro?

Veo muchos subprocesos que mencionan este error, pero ninguno que responda a mi pregunta. ¿Qué archivo debe editarse para proporcionar un valor para esta ruta?

Como está escrito en las instrucciones oficiales :

La variable de entorno GOPATH especifica la ubicación de su espacio de trabajo. De manera predeterminada, un directorio llamado va dentro de su directorio de inicio, por lo que $ HOME / ir en Unix, $ casa / ir en Plan 9 y% USERPROFILE% / go (generalmente C: / Users / YourName / go) en Windows. Si desea trabajar en una ubicación diferente, deberá establecer GOPATH en la ruta a ese directorio. (Otra configuración común es establecer GOPATH = $ HOME.) Tenga en cuenta que GOPATH no debe ser la misma ruta que su instalación de Go.

Por ejemplo, si está codificando en Jetbrains Webstorm (con el complemento Go ), es posible que desee establecer GOPATH como /Users/<user>/WebstormProjects .

En palabras más simples, configúralo donde quieras que residan tus proyectos Go.

Con Go 1.8 (Q2 2017), no tendrá que editar ningún archivo si acepta el valor GOPATH predeterminado (establecido para usted)

$HOME/go

Puede ver los comentarios sobre el número 17262 y el voto en Twitter asociado :

Al elegir un GOPATH predeterminado, podemos facilitar nuestra documentación porque podemos decir cosas como

$ go get github.com/foo/bar

verificará el repositorio de github.com/foo/bar en $HOME/go/src/github.com/foo/bar .

No necesitamos distraer a los recién llegados con la necesidad de establecer una variable de entorno, todo lo que debemos hacer es poner una pequeña nota entre paréntesis en la parte inferior de la página.

$HOME/go es la ruta predeterminada a tu área de trabajo de go.
Si desea cambiar esta ruta, configure la variable GOPATH como GOPATH .

Edite su ~/.bash_profile para agregar la siguiente línea:

$ export GOPATH=$HOME/work

Guarde y salga de su editor. Entonces, fuente tu ~/.bash_profile

$ source ~/.bash_profile

Nota: establezca la ruta GOBIN para generar un archivo binario cuando se ejecute go install

$ export GOBIN=$HOME/work/bin

En mi máquina Fedora 20 agregué las siguientes líneas a mi ~ / .bashrc:

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

Esta ha sido la cosa más molesta de tratar. Con la esperanza de ahorrar su tiempo.

IF go fue instalado como usuario root. El usuario raíz del archivo de texto bash_profile de su sistema ~ / .bash_profile debe tener $ GOROOT asignado al directorio de instalación go y $ GOPATH debe asignarse al directorio 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] ...

asegúrese de que la ruta para ir binario esté en su ruta en .bash_profile

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

Este PATH puede ser tan largo como debe ser la cadena ... para agregar nuevos elementos separados por dos puntos:

salir del editor vi y guardar el perfil bash (: wq significa escribir y salir)

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

Tiene que cerrar sesión en el terminal y volver a iniciar sesión para que el perfil vuelva a iniciarse ... o simplemente puede iniciarlo utilizando Exportar.

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

Puedes verificar go env

...$# go env

¡Hurra!

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

Ahora puede usar sudo and go, podrá descargar y crear directorios dentro de go / src y podrá llegar a lo que estaba tratando de hacer.

ejemplo

# sudo go get github.com/..

Ahora se encontrará con otro problema ... puede que no tenga instalado git ... esa es otra aventura ... :)

Esto es lo que lo hizo funcionar para mí en Ubuntu 15.10 usando el fish shell :

# ~/.config/fish/config.fish set -g -x PATH /usr/local/bin $PATH set -g -x GOPATH /usr/share/go

Luego tuve que cambiar los permisos en la carpeta go (fue configurado como root)

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

Mi ambiente de go se veía similar al tuyo.

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

Lo resolví configurando GOPATH en / usr / lib / go . Pruébalo.

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

Necesitarás GOPATH más tarde, también. Así que ~/.bashrc a ~/.bashrc .

Otra solución más: exportar cada variable de entorno GO* desde go 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"

Puedes usar la solución "exportar" como lo han sugerido otros chicos. Me gustaría ofrecerle otra solución para su conveniencia permanente: puede usar cualquier ruta como GOPATH cuando ejecute los comandos Go.

En primer lugar, debe descargar una pequeña herramienta llamada gost : https://github.com/byte16/gost/releases . Si usa ubuntu, puede descargar la versión de linux ( https://github.com/byte16/gost/releases/download/v0.1.0/gost_linux_amd64.tar.gz ).

Luego necesitas ejecutar los siguientes comandos para descomprimirlo:

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

Usted obtendría un gost ejecutable. Puede moverlo a /usr/local/bin para un uso conveniente:

$ sudo mv gost /usr/local/bin

Ejecute el siguiente comando para agregar la ruta que desea usar como GOPATH en el espacio de gost mantiene gost . Es necesario que asigne a la ruta un nombre que usaría más adelante.

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

Ejecute cualquier comando Go que desee en el formato:

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

Por ejemplo, desea ejecutar go get github.com/go-sql-driver/mysql con /home/foobar/bar como GOPATH, solo hágalo de la siguiente manera:

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

Le ayudaría a configurar el GOPATH y ejecutar el comando. Pero recuerda que has agregado la ruta en el gost ruta de gost . Si se encuentra en cualquier nivel de subdirectorios de /home/foobar/bar , incluso puede ejecutar el siguiente comando que haría lo mismo para abreviar:

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

gost es una herramienta simple de Go que puede ayudarlo a administrar GOPATHs y ejecutar los comandos Go. Para obtener más detalles sobre cómo usarlo para ejecutar otros comandos Go, solo puede ejecutar gost help goCmdName . Por ejemplo, si desea saber más sobre la install , simplemente escriba las palabras a continuación en:

$ gost help install

También puede encontrar más detalles en el archivo README del proyecto: https://github.com/byte16/gost/blob/master/README.md

Si ha configurado algo que necesita modificar las variables de entorno, por ejemplo, Java, Go, etc., esto será muy familiar.

Asumiré que tiene la siguiente estructura de directorios en algún lugar como su ruta Ir:

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

  • abrir una nueva terminal
  • escriba sudo nano /etc/environment
  • encuentre PATH=... y vaya al final y agregue dos puntos : después de la última ruta, pegue la go path completa go path por ejemplo, /home/user/gocode

y listo, esto debería hacerlo persistente a través del sistema.

Si por ejemplo, es un Ubuntu, después de instalar los paquetes:

$sudo apt install golang -y

Simplemente agregue las siguientes líneas a ~ / .bashrc (de su usuario)

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

Simplemente agregue las siguientes líneas a ~ / .bashrc y esto persistirá. Sin embargo, puede usar otras rutas que le gusten como GOPATH en lugar de $ HOME / go en mi muestra.

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

Solución más corta y actual .

Escriba este código en la Terminal.

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

Nota : Esto se restablecerá en cada nueva ventana de Terminal o reinicio del sistema.

Para ser persistente, pegue el siguiente código en su archivo .zshrc o .bashrc acuerdo con su shell. Esos archivos en su Directorio de Inicio . Será como abajo.

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

Ubuntu 14.04

export GOPATH=$HOME/go

Adicionalmente puedes agregar esta cadena al archivo.

$HOME/.bashrc

go path puede estar en cualquier lugar que desee, solo cree un directorio y establezca la variable global path en el nombre de GOPATH para su entorno.

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

GOPATH es una variable de entorno para su ubicación de espacio de trabajo. GOROOT es una variable de entorno para su directorio de instalación. Aunque GOROOT y GOPATH se configuran automáticamente (si no hubiera un error) durante el tiempo de instalación, para especificarlo manualmente puede seguir el siguiente proceso. Además, para más información puedes consultar la página wiki de GO .

Es mejor configurar GOPATH en un directorio dentro de su directorio de inicio, por ejemplo, $ HOME / go,% USERPROFILE% / go (Windows).

  1. Esta es una solución mac, que se prueba en macOS Sierra, ver. 10.12, y también en Gogland-EAP, que ha sido introducido como un IDE para la programación Go por JetBrains.

En tu tipo de terminal

vim ~/.profile

en el documento abierto en la Terminal, presione i y agregue la siguiente ruta

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

presiona ESC y escribe : x . Por último, debe reiniciar ( cerrar y abrir ) su terminal o Cerrar sesión e iniciar sesión nuevamente.

  1. Para la configuración de Windows y Linux, consulte la página Go wiki en Githab sobre Configuración de GOPATH-Golang .

PRECAUCIÓN No configure tanto GOROOT como GOPATH en el mismo directorio, de lo contrario recibirá una advertencia.

Ir a los módulos

Desde Go 1.11: ahora hay soporte para Go Modules ( anteriormente conocido como vgo ), por lo que ya no tiene que usar GOPATH. Sin embargo, esta sigue siendo una característica experimental.

Por ejemplo, puede ir a cualquier directorio en su sistema (fuera de $ GOPATH), puede inicializar un nuevo módulo de Go allí y puede trabajar allí. No se necesita GOPATH.

Solo necesita hacer esto una vez ( mientras está en un directorio ):

go mod init

Después de esto, ese directorio se asumirá como un módulo raíz. Puedes crear tantos módulos como quieras. GOPATH pronto será historia .

Si insistes en trabajar con GOPATH, entonces escucha esto:

Desde Go 1.8: no necesitas configurar tu GOPATH o GOROOT. GOPATH está por defecto en su directorio de usuario / inicio.

Si no se establece GOPATH, se supone que es $ HOME / go en sistemas Unix y% USERPROFILE% / go en Windows. Si desea utilizar una ubicación personalizada como su área de trabajo, puede configurar la variable de entorno GOPATH.

Más información echa un vistazo a esto .

export GOPATH=/path/desired/here

No es necesario editar ningún archivo, solo podemos usar el comando anterior para editar directamente las variables de entorno Go.