GOPATH not set in VSCode [duplicate] - go
I'm trying to install doozer like this:
$ goinstall github.com/ha/doozer
I get these errors.
goinstall: os: go/build: package could not be found locally
goinstall: fmt: go/build: package could not be found locally
goinstall: io: go/build: package could not be found locally
goinstall: reflect: go/build: package could not be found locally
goinstall: math: go/build: package could not be found locally
goinstall: rand: go/build: package could not be found locally
goinstall: url: go/build: package could not be found locally
goinstall: net: go/build: package could not be found locally
goinstall: sync: go/build: package could not be found locally
goinstall: runtime: go/build: package could not be found locally
goinstall: strings: go/build: package could not be found locally
goinstall: sort: go/build: package could not be found locally
goinstall: strconv: go/build: package could not be found locally
goinstall: bytes: go/build: package could not be found locally
goinstall: log: go/build: package could not be found locally
goinstall: encoding/binary: go/build: package could not be found locally
GOPATH is discussed in the cmd/go documentation:
The GOPATH environment variable lists places to look for Go code. On
Unix, the value is a colon-separated string. On Windows, the value is
a semicolon-separated string. On Plan 9, the value is a list.
GOPATH must be set to get, build and install packages outside the
standard Go tree.
GOROOT is discussed in the installation instructions:
The Go binary distributions assume they will be installed in
/usr/local/go (or c:\Go under Windows), but it is possible to install
the Go tools to a different location. In this case you must set the
GOROOT environment variable to point to the directory in which it was
installed.
For example, if you installed Go to your home directory you should add
the following commands to $HOME/.profile:
export GOROOT=$HOME/go
export PATH=$PATH:$GOROOT/bin
Note: GOROOT must be set only when installing to a custom location.
(updated version of Chris Bunch's answer.)
Here is a my simple setup:
directory for go related things: ~/programming/go
directory for go compiler/tools: ~/programming/go/go-1.4
directory for go software : ~/programming/go/packages
GOROOT, GOPATH, PATH are set as following:
export GOROOT=/home/user/programming/go/go-1.4
export GOPATH=/home/user/programming/go/packages
export PATH=$PATH:$GOROOT/bin:$GOPATH/bin
So, in short:
GOROOT is for compiler/tools that comes from go installation.
GOPATH is for your own go projects / 3rd party libraries (downloaded with "go get").
First run go env.
If you see that the go isn't installed, you can install it via homebrew or via package and/or other ways.
If you are seeing output then your Go is installed.
It shows you all the envs that are set and are not.
If you see empty for GOROOT:
Run which go (On my computer : /usr/local/go/bin/go)
then export like this export GOROOT=/usr/local/go
If you see empty for GOPATH:
Create any directory anywhere on your computer for go projects in my case: ~/GO_PROJECTS
Then export GOPATH=~/GO_PROJECTS
GOPATH is discussed here:
The GOPATH Environment Variable
GOPATH may be set to a colon-separated list of paths inside which Go
code, package objects, and executables may be found.
Set a GOPATH to use goinstall to build and install your own code and
external libraries outside of the Go tree (and to avoid writing
Makefiles).
And GOROOT is discussed here:
$GOROOT The root of the Go tree, often $HOME/go. This defaults to the
parent of the directory where all.bash is run. If you choose not to
set $GOROOT, you must run gomake instead of make or gmake when
developing Go programs using the conventional makefiles.
I read the go help gopath docs and was still incredibly confused, but found this little nugget from another go doc page:
The GOPATH environment variable specifies the location of your workspace. It is likely the only environment variable you'll need to set when developing Go code.
http://golang.org/doc/code.html#GOPATH
Starting with go 1.8 (Q2 2017), GOPATH will be set for you by default to $HOME/go
See issue 17262 and Rob Pike's comment:
$HOME/go it will be.
There is no single best answer but this is short and sweet, and it can only be a problem to choose that name if $HOME/go already exists, which will only happen for experts who already have go installed and will understand GOPATH.
The GOPATH should not point to the Go installation, but rather to your workspace (see https://golang.org/doc/code.html#GOPATH). Whenever you install some package with go get or go install, it will land within the GOPATH. That is why it warns you, that you most definitely do not want random packages from the internet to be dumped into your official installation.
You generally should not set GOROOT explicitly. The go command identifies the appropriate GOROOT automatically based on its own directory location.
GOPATH defaults to $HOME/go. You only need to set it explicitly if you want to put it somewhere else.
GOPATH contains:
Binaries installed using go install, located at $GOPATH/bin.¹
This location can be overridden using the GOBIN environment variable.
A cache of downloaded module source code and checksums, located at $GOPATH/pkg/mod.
This location can be overridden using the GOMODCACHE environment variable.
If you set both GOBIN and GOMODCACHE, and do not set GO111MODULE=off, then GOPATH itself should have essentially no effect.
In addition, in the legacy GOPATH mode (when GO111MODULE=off is also set), GOPATH contains:
Source code used to build packages, stored in a directory tree rooted at $GOPATH/src.
Non-binaries installed using go install, located at $GOPATH/pkg.
Installing non-binary packages is no longer particularly useful: the go command has a cache of built artifacts, which has been required since Go 1.12 even in GOPATH mode.
The build cache is not located within GOPATH. Its location can be set with the GOCACHE environment variable.
¹ Binaries can also be installed using go get on Go 1.17 and earlier, but go install is preferred as of Go 1.16; see https://golang.org/doc/go1.16.
In modern Go, you don't need to set GOPATH or GOROOT. In fact, unless you're doing something very specialized, it's best to have them unset on your system.
Use Go modules. Having installed Go, pick a directory where you want to work. Then:
$ mkdir example
$ cd example
$ go mod init example.com
Note that the module name example.com is arbitrary; if you keep your work on GitHub, this could be something like github.com/your-username/project-name.
The last command will have created a go.mod file; now you can grab dependencies with go get:
$ go get rsc.io/quote
Now your code using this dependency:
$ touch main.go
Place this in main.go:
package main
import (
"fmt"
"rsc.io/quote"
)
func main() {
fmt.Println(quote.Go())
}
And run with:
$ go run .
W.r.t. original question, you can now get your doozer dependency with:
$ go get github.com/ha/doozer
Now you can use the doozer module in your code. And so on. You can also examine the go.mod file in your directory to see the dependencies listed, along with their versions. Each module is self-contained, with its own versions of dependencies. You can have two modules alongside each other, each with its own go.mod file pointing to different versions of some dependency - this will all work OK because of the isolation between modules.
For additional information, start with the official tutorial here. In several chapters, it walks you through the steps shown above, as well as writing your own reusable modules and packages, and importing them from other modules. Additional interactive tutorials are available at https://play-with-go.dev/
GOPATH and GOROOT configurations are deprecated.
You can use the GO module instead.
For example:
mkdir go_app
cd go_app
go mod init go_app
Regarding GOROOT specifically, Go 1.9 will set it automatically to its installation path.
Even if you have multiple Go installed, calling the 1.9.x one will set GOROOT to /path/to/go/1.9 (before, if not set, it assumed a default path like /usr/local/go or c:\Go).
See CL Go Review 53370:
The go tool will now use the path from which it was invoked to attempt to locate the root of the Go install tree.
This means that if the entire Go installation is moved to a new location, the go tool should continue to work as usual.
This may be overriden by setting GOROOT in the environment, which should only be done in unusual circumstances.
Note that this does not affect the result of the runtime.GOROOT() function, which will continue to report the original installation location; this may be fixed in later releases.
As mentioned above:
The GOPATH environment variable specifies the location of your
workspace.
For Windows, this worked for me (in Ms-dos window):
set GOPATH=D:\my_folder_for_go_code\
This creates a GOPATH variable that Ms-dos recognizes when used as follows:
cd %GOPATH%
Lots of answers but no substance, like robots doing cut and paste on what's on their system. There is no need to set GOROOT as an environment variable. However, there is a beneficial need to set the GOPATH environment variable, and if not set it defaults to ${HOME}/go/ folder.
It is the PATH environment variable that you must pay attention because this variable is the variable that can change your go version. Not GOROOT! Forget GOROOT.
Now, if you switch or change to a new go version, your downloaded packages will use the default $HOME/go folder and it will mixed-up with whatever your previous go version was. This is not good.
Therefore, this is where GOPATH you need to define in order to isolate downloaded packages of the new go version.
In summary, forget GOROOT. Think more on GOPATH.
Run go help environment it has documentation for every environment variable that can be listed by go env command
Here is one solution (single user):
GOROOT=$HOME/.local # your go executable is in $GOROOT/bin
GOPATH=$HOME/.gopath
PATH=$GOROOT/bin:$GOPATH/bin:$PATH
go complains if you change .gopath to .go.
I wish they went with how the rust/cargo guys did and just put everything at one place.
There's a command you can use: go env GOPATH
You don't need to explicitly set GOROOT (Modern versions of Go can figure it out on their own based on the location of the go binary that you run).
Also, got the follow error when trying to work with vgo:
go: modules disabled inside GOPATH/src by GO111MODULE=auto; see 'go help modules'
Removing GOROOT, updating my GOPATH and export GO111MODULE="on" resolved the issue.
GOPATH see in here
GOPATH may be set to a colon-separated list of paths inside which Go code, package objects, and executables may be found.
Set a GOPATH to use goinstall to build and install your own code and external libraries outside of the Go tree (and to avoid writing Makefiles).
As of 2020 and Go version 1.13+, in Windows the best way for updating GOPATH is just typing in command prompt:
setx GOPATH C:\mynewgopath
I had to append
export GOROOT=/usr/local/Cellar/go/1.10.1/libexec
to my ~/.bash_profile on Mac OS X
There is also a case where when we use go it compiles all the go files.
So lets say we had one file main.go and later we changed the current file to main_old.go and then added our new main.go file. Then when we build our app all the go files will get compiled. So the error that's happening might be due to compilation error in some other go files.
Once Go lang is installed, GOROOT is the root directory of the installation.
When I exploded Go Lang binary in Windows C:\ directory, my GOROOT should be C:\go.
If Installed with Windows installer, it may be C:\Program Files\go (or C:\Program Files (x86)\go, for 64-bit packages)
GOROOT = C:\go
while my GOPATH is location of Go lang source code or workspace.
If my Go lang source code is located at C:\Users\\GO_Workspace, your GOPATH would be as below:
GOPATH = C:\Users\<xyz>\GO_Workspace
For all newcomers they could do a simply export GOPATH=$HOME/go if you are using Ubuntu or do go help gopath for more information.
in osx, i installed with brew, here is the setting that works for me
GOPATH="$HOME/my_go_work_space" //make sure you have this folder created
GOROOT="/usr/local/Cellar/go/1.10/libexec"
If you are using the distro go, you should point to where the include files are, for example:
$ rpm -ql golang | grep include
/usr/lib/golang/include
(This is for Fedora 20)
the values should be (MACOS):
GOROOT="/usr/local/go" --> all binaries file core go
GOPATH="/Applications/proyectos/go" --> the route to workspace (custom workspace)
Related
Where does go download my dependencies if I do not specify GOPATH?
new go learner so this might be a trivial question. If I understand the documentation correctly, go had been using GOPATH in the beginning and every dependency and source code need to be in this GOPATH but after 1.1.1 GO switched gear to use Go Modules which is like other languages doing. Now if I do not specify GOPATH at all in my bashrc/bash_profile or anywhere, I can now do go init mymod and write some code and simply run go build and it will download whatever depdendency package I am using without any problem. I have tried setting GOPATH and when GOPATH is set, the packages are downloaded to my GOPATH as expected, but without GOPATH, this still works. But I am not sure where the dependencies are downloaded. Could you please explain to me what is happening here? Where the dependency pacakge are downloaded in this case?
Quoting from Command go: GOPATH environment variable: If the environment variable is unset, GOPATH defaults to a subdirectory named "go" in the user's home directory ($HOME/go on Unix, %USERPROFILE%\go on Windows), unless that directory holds a Go distribution. Run "go env GOPATH" to see the current GOPATH.
Where does go get install packages?
I've been given instructions to run go get <some-remote-git-repo> which seems to succeed, but it's not clear to me where the package was installed to so I can run an executable from it. Per https://golang.org/doc/code.html#remote it seems it will be installed in $GOPATH/bin but $GOPATH isn't defined in my shell (though the go get command seems to work fine). Go is installed via Homebrew.
I found the missing clue by running brew info go, which says: ==> Caveats A valid GOPATH is required to use the `go get` command. If $GOPATH is not specified, $HOME/go will be used by default: https://golang.org/doc/code.html#GOPATH From that I found the executable in question at $HOME/go/bin.
go env you can get the path from GOMODCACHE
I had a similar problem which is why I found your question. However, in my case I did not have an empty GOPATH but one with multiple directories. I worked out the issue and describe it here... If you run go get and you already have the package it says nothing (even with the -v option). This is confusing if it's not in the first directory of your GOPATH. Ie you run go get , there is no error or any message but when you check the first directory of the GOPATH (which is where the doc says it should be) you can't find it. I eventually found it, but since I have a large GOPATH this was rather tedious.
Even if you don't have a $GOPATH variable you can see what it uses by doing go env GOPATH. Try this to see what your path is: echo `go env GOPATH`/bin
Using go build Try this with main.go. In your greeter directory, run the following command: go build In this case, you built your greeter application into an executable file that was added to your current directory. Check this by running the ls command: ls ./greeter
go: cannot find GOROOT directory: c:\go
I unzipped the Go distribution into d:\dev\go, added d:\dev\go\bin to my path, created a file d:\projects\hello\hello.go and set GOPATH to d:\projects\hello. Running go build hello.go tells me: go: cannot find GOROOT directory: c:\go Now several different places strongly urge me not to set GOROOT, setting GOPATH should be everything that is needed. Should I go against this recommendation or is there something I am missing?
From Dave Cheney's You don’t need to set GOROOT, really article: There are only two cases that where you may have to set a $GOROOT environment. These are both described in the installation page on the golang.org website. For completeness I will recap them here You are a Linux, FreeBSD or OS X user using the the zip or tarball binary downloads from the golang.org website. These binaries have a $GOROOT value of /usr/local/go and recommend you unpack them into that location. If you choose not to do this, then you must set $GOROOT to the location you chose. You are a Windows user using the zip binary download from the golang.org website. These binaries have a $GOROOT value of C:\Go. If you place Go somewhere else on your system then you must set $GOROOT to the location you chose. (The rest of the article is a good read if you want to learn the history that has caused confusion over GOROOT, the summary is it's due to outdated instructions mostly from pre-Go1.) So if you use a pre-built Go binary, and you want to put it somewhere other than where it "wants", then you need GOROOT. Otherwise (i.e. if you build Go from source, or if you put the binary distribution in the default location) you don't need or want to set GOROOT (the above article gives some reasons why not). If you're unsure, the easiest way to get it "correct" is to first not set anything other GOPATH. Then run go env and see what it says; if that shows reasonable entries for GOROOT and GOPATH then you're done; only set variables to override that if it's wrong.
I got this error when compiling and when getting the compiler version, I solved the problem by deleting the system variable GOROOT and reassigning it. was c:\Go; became c:\Go =)
I set GOROOT to point to the content of that dir: AUTHORS PATENTS api favicon.ico misc src CONTRIBUTORS README bin include pkg test LICENSE VERSION doc lib robots.txt That's the dir which containts src, bin, doc, lib, etc...
Once Go lang is installed, GOROOT is the root directory of the installation. When I exploded Go Lang binary in Windows C:\ directory, my GOROOT should be C:\go. If Installed with Windows installer, it may be C:\Program Files\go (or C:\Program Files (x86)\go, for 64-bit packages) GOROOT = C:\go
Maybe the cache problem. For me, I reopen the MinGW (I installed go in msys2 by pacman), and it worked.
How to set GOPATH on MAC after installing go1.4.1.darwin-amd64-osx10.8.pkg
I have run go1.4.1.darwin-amd64-osx10.8.pkg to install go on my MAC. It install go in /usr/local/go/bin/go. Can you tell me what should my GOPATH set to? I tried '/usr/local/go' and '/usr/local/go/bin/go'. But both does not seem to be the right path. Thank you.
GOPATH is an environmental variable used to define the location of your workplace directory. It's used by the Go tools for various reasons. For example: go get -u github.com/nsf/gocode will download the source code and place it at $GOPATH/src/github.com/nsfs/gocode Compile that source code and place the binary at $GOPATH/bin Place symbol and package information at $GOPATH/pkg/architecture/github.com/nsfs The path is also used in other tools: go build github.com/nsf/gocode go install github.com/nsfs/gocode github.com/nsfs/gocode in the above commands is resolved automatically to $GOPATH/src/github.com/nsfs/gocode and thus you can run these commands without actually being in your workplace (the point of $GOPATH) The $GOPATH location for your workplace directory can be put anywhere on your machine, but it must minimally have 3 folders (because go get and other tools need these folders). bin pkg src This environmental variable can be set like any other environmental variable. If you're using go from the Terminal.app, you can set it by opening the file: vi ~/.bashrc and then setting it export GOPATH=~/goworkplace ~/goworkplace is a location to the workplace directory with those 3 folders. It can be anywhere on your system, such as, ~/Development/goworkplace, ~/Desktop/goworkplace, as long as it has those 3 folders For information, take a look at this: https://golang.org/doc/code.html
Try this First you can check the golang is install or not. Run go env After that you can show the list of go env variables.. then you check where you can install the go after that set $GOPATH like:- export GOPATH=/var/projects/go and also set $GOBIN like:- export =$GOPATH/bin
What should be the values of GOPATH and GOROOT?
I'm trying to install doozer like this: $ goinstall github.com/ha/doozer I get these errors. goinstall: os: go/build: package could not be found locally goinstall: fmt: go/build: package could not be found locally goinstall: io: go/build: package could not be found locally goinstall: reflect: go/build: package could not be found locally goinstall: math: go/build: package could not be found locally goinstall: rand: go/build: package could not be found locally goinstall: url: go/build: package could not be found locally goinstall: net: go/build: package could not be found locally goinstall: sync: go/build: package could not be found locally goinstall: runtime: go/build: package could not be found locally goinstall: strings: go/build: package could not be found locally goinstall: sort: go/build: package could not be found locally goinstall: strconv: go/build: package could not be found locally goinstall: bytes: go/build: package could not be found locally goinstall: log: go/build: package could not be found locally goinstall: encoding/binary: go/build: package could not be found locally
GOPATH is discussed in the cmd/go documentation: The GOPATH environment variable lists places to look for Go code. On Unix, the value is a colon-separated string. On Windows, the value is a semicolon-separated string. On Plan 9, the value is a list. GOPATH must be set to get, build and install packages outside the standard Go tree. GOROOT is discussed in the installation instructions: The Go binary distributions assume they will be installed in /usr/local/go (or c:\Go under Windows), but it is possible to install the Go tools to a different location. In this case you must set the GOROOT environment variable to point to the directory in which it was installed. For example, if you installed Go to your home directory you should add the following commands to $HOME/.profile: export GOROOT=$HOME/go export PATH=$PATH:$GOROOT/bin Note: GOROOT must be set only when installing to a custom location. (updated version of Chris Bunch's answer.)
Here is a my simple setup: directory for go related things: ~/programming/go directory for go compiler/tools: ~/programming/go/go-1.4 directory for go software : ~/programming/go/packages GOROOT, GOPATH, PATH are set as following: export GOROOT=/home/user/programming/go/go-1.4 export GOPATH=/home/user/programming/go/packages export PATH=$PATH:$GOROOT/bin:$GOPATH/bin So, in short: GOROOT is for compiler/tools that comes from go installation. GOPATH is for your own go projects / 3rd party libraries (downloaded with "go get").
First run go env. If you see that the go isn't installed, you can install it via homebrew or via package and/or other ways. If you are seeing output then your Go is installed. It shows you all the envs that are set and are not. If you see empty for GOROOT: Run which go (On my computer : /usr/local/go/bin/go) then export like this export GOROOT=/usr/local/go If you see empty for GOPATH: Create any directory anywhere on your computer for go projects in my case: ~/GO_PROJECTS Then export GOPATH=~/GO_PROJECTS
GOPATH is discussed here: The GOPATH Environment Variable GOPATH may be set to a colon-separated list of paths inside which Go code, package objects, and executables may be found. Set a GOPATH to use goinstall to build and install your own code and external libraries outside of the Go tree (and to avoid writing Makefiles). And GOROOT is discussed here: $GOROOT The root of the Go tree, often $HOME/go. This defaults to the parent of the directory where all.bash is run. If you choose not to set $GOROOT, you must run gomake instead of make or gmake when developing Go programs using the conventional makefiles.
I read the go help gopath docs and was still incredibly confused, but found this little nugget from another go doc page: The GOPATH environment variable specifies the location of your workspace. It is likely the only environment variable you'll need to set when developing Go code. http://golang.org/doc/code.html#GOPATH
Starting with go 1.8 (Q2 2017), GOPATH will be set for you by default to $HOME/go See issue 17262 and Rob Pike's comment: $HOME/go it will be. There is no single best answer but this is short and sweet, and it can only be a problem to choose that name if $HOME/go already exists, which will only happen for experts who already have go installed and will understand GOPATH.
The GOPATH should not point to the Go installation, but rather to your workspace (see https://golang.org/doc/code.html#GOPATH). Whenever you install some package with go get or go install, it will land within the GOPATH. That is why it warns you, that you most definitely do not want random packages from the internet to be dumped into your official installation.
You generally should not set GOROOT explicitly. The go command identifies the appropriate GOROOT automatically based on its own directory location. GOPATH defaults to $HOME/go. You only need to set it explicitly if you want to put it somewhere else. GOPATH contains: Binaries installed using go install, located at $GOPATH/bin.¹ This location can be overridden using the GOBIN environment variable. A cache of downloaded module source code and checksums, located at $GOPATH/pkg/mod. This location can be overridden using the GOMODCACHE environment variable. If you set both GOBIN and GOMODCACHE, and do not set GO111MODULE=off, then GOPATH itself should have essentially no effect. In addition, in the legacy GOPATH mode (when GO111MODULE=off is also set), GOPATH contains: Source code used to build packages, stored in a directory tree rooted at $GOPATH/src. Non-binaries installed using go install, located at $GOPATH/pkg. Installing non-binary packages is no longer particularly useful: the go command has a cache of built artifacts, which has been required since Go 1.12 even in GOPATH mode. The build cache is not located within GOPATH. Its location can be set with the GOCACHE environment variable. ¹ Binaries can also be installed using go get on Go 1.17 and earlier, but go install is preferred as of Go 1.16; see https://golang.org/doc/go1.16.
Regarding GOROOT specifically, Go 1.9 will set it automatically to its installation path. Even if you have multiple Go installed, calling the 1.9.x one will set GOROOT to /path/to/go/1.9 (before, if not set, it assumed a default path like /usr/local/go or c:\Go). See CL Go Review 53370: The go tool will now use the path from which it was invoked to attempt to locate the root of the Go install tree. This means that if the entire Go installation is moved to a new location, the go tool should continue to work as usual. This may be overriden by setting GOROOT in the environment, which should only be done in unusual circumstances. Note that this does not affect the result of the runtime.GOROOT() function, which will continue to report the original installation location; this may be fixed in later releases.
In modern Go, you don't need to set GOPATH or GOROOT. In fact, unless you're doing something very specialized, it's best to have them unset on your system.
Use Go modules. Having installed Go, pick a directory where you want to work. Then:
$ mkdir example
$ cd example
$ go mod init example.com
Note that the module name example.com is arbitrary; if you keep your work on GitHub, this could be something like github.com/your-username/project-name.
The last command will have created a go.mod file; now you can grab dependencies with go get:
$ go get rsc.io/quote
Now your code using this dependency:
$ touch main.go
Place this in main.go:
package main
import (
"fmt"
"rsc.io/quote"
)
func main() {
fmt.Println(quote.Go())
}
And run with:
$ go run .
W.r.t. original question, you can now get your doozer dependency with:
$ go get github.com/ha/doozer
Now you can use the doozer module in your code. And so on. You can also examine the go.mod file in your directory to see the dependencies listed, along with their versions. Each module is self-contained, with its own versions of dependencies. You can have two modules alongside each other, each with its own go.mod file pointing to different versions of some dependency - this will all work OK because of the isolation between modules.
For additional information, start with the official tutorial here. In several chapters, it walks you through the steps shown above, as well as writing your own reusable modules and packages, and importing them from other modules. Additional interactive tutorials are available at https://play-with-go.dev/
GOPATH and GOROOT configurations are deprecated. You can use the GO module instead. For example: mkdir go_app cd go_app go mod init go_app
As mentioned above: The GOPATH environment variable specifies the location of your workspace. For Windows, this worked for me (in Ms-dos window): set GOPATH=D:\my_folder_for_go_code\ This creates a GOPATH variable that Ms-dos recognizes when used as follows: cd %GOPATH%
Lots of answers but no substance, like robots doing cut and paste on what's on their system. There is no need to set GOROOT as an environment variable. However, there is a beneficial need to set the GOPATH environment variable, and if not set it defaults to ${HOME}/go/ folder.
It is the PATH environment variable that you must pay attention because this variable is the variable that can change your go version. Not GOROOT! Forget GOROOT.
Now, if you switch or change to a new go version, your downloaded packages will use the default $HOME/go folder and it will mixed-up with whatever your previous go version was. This is not good.
Therefore, this is where GOPATH you need to define in order to isolate downloaded packages of the new go version.
In summary, forget GOROOT. Think more on GOPATH.
Run go help environment it has documentation for every environment variable that can be listed by go env command
Here is one solution (single user): GOROOT=$HOME/.local # your go executable is in $GOROOT/bin GOPATH=$HOME/.gopath PATH=$GOROOT/bin:$GOPATH/bin:$PATH go complains if you change .gopath to .go. I wish they went with how the rust/cargo guys did and just put everything at one place.
There's a command you can use: go env GOPATH
You don't need to explicitly set GOROOT (Modern versions of Go can figure it out on their own based on the location of the go binary that you run). Also, got the follow error when trying to work with vgo: go: modules disabled inside GOPATH/src by GO111MODULE=auto; see 'go help modules' Removing GOROOT, updating my GOPATH and export GO111MODULE="on" resolved the issue. GOPATH see in here GOPATH may be set to a colon-separated list of paths inside which Go code, package objects, and executables may be found. Set a GOPATH to use goinstall to build and install your own code and external libraries outside of the Go tree (and to avoid writing Makefiles).
As of 2020 and Go version 1.13+, in Windows the best way for updating GOPATH is just typing in command prompt: setx GOPATH C:\mynewgopath
I had to append export GOROOT=/usr/local/Cellar/go/1.10.1/libexec to my ~/.bash_profile on Mac OS X
There is also a case where when we use go it compiles all the go files. So lets say we had one file main.go and later we changed the current file to main_old.go and then added our new main.go file. Then when we build our app all the go files will get compiled. So the error that's happening might be due to compilation error in some other go files.
Once Go lang is installed, GOROOT is the root directory of the installation. When I exploded Go Lang binary in Windows C:\ directory, my GOROOT should be C:\go. If Installed with Windows installer, it may be C:\Program Files\go (or C:\Program Files (x86)\go, for 64-bit packages) GOROOT = C:\go while my GOPATH is location of Go lang source code or workspace. If my Go lang source code is located at C:\Users\\GO_Workspace, your GOPATH would be as below: GOPATH = C:\Users\<xyz>\GO_Workspace
For all newcomers they could do a simply export GOPATH=$HOME/go if you are using Ubuntu or do go help gopath for more information.
in osx, i installed with brew, here is the setting that works for me GOPATH="$HOME/my_go_work_space" //make sure you have this folder created GOROOT="/usr/local/Cellar/go/1.10/libexec"
If you are using the distro go, you should point to where the include files are, for example: $ rpm -ql golang | grep include /usr/lib/golang/include (This is for Fedora 20)
the values should be (MACOS): GOROOT="/usr/local/go" --> all binaries file core go GOPATH="/Applications/proyectos/go" --> the route to workspace (custom workspace)