157 lines
6.5 KiB
Markdown
157 lines
6.5 KiB
Markdown
# 1.2 $GOPATH and workspace
|
|
|
|
## $GOPATH
|
|
|
|
Go takes a unique approach to manage the code files with the introduction of a `$GOPATH` directory which contains all the go code on the machine. Note that this is different from the `$GOROOT` environment variable which states where go is installed on the machine. We have to define the `$GOPATH` variable before using the language, in *nix systems there is a file called `.profile` we need to append the below export statement to the file. The concept behind gopath is a novel one, where we can link to any go code at any instant of time without ambiguity.
|
|
|
|
Starting from go 1.8, the GOPATH environment variable now has a default value if it not set: it defaults to `$HOME/go` on Unix and `%USERPROFILE%/go` on Windows.
|
|
|
|
On Unix-like systems, the variable should be used like this:
|
|
|
|
export GOPATH=${HOME}/mygo
|
|
|
|
In Windows, you need to create a new environment variable called GOPATH, then set its value to `c:\mygo`( ***This value depends on where your workspace is located*** )
|
|
|
|
It's OK to have more than one path (workspace) in `$GOPATH`, but remember that you have to use `:`(`;` in Windows) to separate them. At this point, `go get` will save the content to your first path in `$GOPATH`. It is highly recommended to not have multiples versions, the worst case is to create a folder by the name of your project right inside `$GOPATH`, it breaks everything that the creators were wishing to change in programming with the creation of go language because when you create a folder inside `$GOPATH` you will reference your packages as directly as <packagename>, and this breaks all the applications which will import your package because the `go get` won't find your package. Please follow conventions, there is a reason conventions are created.
|
|
|
|
In `$GOPATH`, you must have three folders as follows:
|
|
|
|
- `src` for source files whose suffix is .go, .c, .g, .s.
|
|
- `pkg` for compiled files whose suffix is .a.
|
|
- `bin` for executable files
|
|
|
|
In this book, I use `mygo` as my only path in `$GOPATH`.
|
|
|
|
## Package directory
|
|
|
|
Create package source files and folders like `$GOPATH/src/mymath/sqrt.go` (`mymath` is the package name) ( ***Author uses `mymath` as his package name, and the same name for the folder that contains the package source files***)
|
|
|
|
Every time you create a package, you should create a new folder in the `src` directory, with the notable exception of main, for which `main` folder creation is optional. Folder names are usually the same as the package that you are going to use. You can have multi-level directories if you want to. For example, if you create the directory `$GOPATH/src/github.com/astaxie/beedb`, then the package path would be `github.com/astaxie/beedb`. The package name will be the last directory in your path, which is `beedb` in this case.
|
|
|
|
Execute following commands. ( ***Now author goes back to talk examples*** )
|
|
|
|
cd $GOPATH/src
|
|
mkdir mymath
|
|
|
|
Create a new file called `sqrt.go`, type the following content to your file.
|
|
```Go
|
|
// Source code of $GOPATH/src/mymath/sqrt.go
|
|
package mymath
|
|
|
|
func Sqrt(x float64) float64 {
|
|
z := 0.0
|
|
for i := 0; i < 1000; i++ {
|
|
z -= (z*z - x) / (2 * x)
|
|
}
|
|
return z
|
|
}
|
|
```
|
|
Now my package directory has been created and its code has been written. I recommend that you use the same name for your packages as their corresponding directories, and that the directories contain all of the package source files.
|
|
|
|
## Compile packages
|
|
|
|
We've already created our package above, but how do we compile it for practical purposes? There are two ways to do this.
|
|
|
|
1. Switch your work path to the directory of your package, then execute the `go install` command.
|
|
2. Execute the above command except with a file name, like `go install mymath`.
|
|
|
|
After compiling, we can open the following folder.
|
|
|
|
cd $GOPATH/pkg/${GOOS}_${GOARCH}
|
|
// you can see the file was generated
|
|
mymath.a
|
|
|
|
The file whose suffix is `.a` is the binary file of our package. How do we use it?
|
|
|
|
Obviously, we need to create a new application to use it.
|
|
|
|
Create a new application package called `mathapp`.
|
|
|
|
cd $GOPATH/src
|
|
mkdir mathapp
|
|
cd mathapp
|
|
vim main.go
|
|
|
|
Write the following content to main.go.
|
|
|
|
```Go
|
|
|
|
//$GOPATH/src/mathapp/main.go source code.
|
|
package main
|
|
|
|
import (
|
|
"mymath"
|
|
"fmt"
|
|
)
|
|
|
|
func main() {
|
|
fmt.Printf("Hello, world. Sqrt(2) = %v\n", mymath.Sqrt(2))
|
|
}
|
|
```
|
|
|
|
To compile this application, you need to switch to the application directory, which in this case is `$GOPATH/src/mathapp`, then execute the `go install` command. Now you should see an executable file called `mathapp` was generated in the directory `$GOPATH/bin/`. To run this program, use the `./mathapp` command. You should see the following content in your terminal.
|
|
|
|
Hello world. Sqrt(2) = 1.414213562373095
|
|
|
|
## Install remote packages
|
|
|
|
Go has a tool for installing remote packages, which is a command called `go get`. It supports most open source communities, including GitHub, Google Code, BitBucket, and Launchpad.
|
|
|
|
go get github.com/astaxie/beedb
|
|
|
|
You can use `go get -u …` to update your remote packages and it will automatically install all the dependent packages as well.
|
|
|
|
This tool will use different version control tools for different open source platforms. For example, `git` for GitHub and `hg` for Google Code. Therefore, you have to install these version control tools before you use `go get`.
|
|
|
|
After executing the above commands, the directory structure should look like following.
|
|
|
|
$GOPATH
|
|
src
|
|
|-github.com
|
|
|-astaxie
|
|
|-beedb
|
|
pkg
|
|
|--${GOOS}_${GOARCH}
|
|
|-github.com
|
|
|-astaxie
|
|
|-beedb.a
|
|
|
|
Actually, `go get` clones source code to the `$GOPATH/src` of the local file system, then executes `go install`.
|
|
|
|
You can use remote packages in the same way that we use local packages.
|
|
```Go
|
|
import "github.com/astaxie/beedb"
|
|
```
|
|
## Directory complete structure
|
|
|
|
If you've followed all of the above steps, your directory structure should now look like the following.
|
|
|
|
bin/
|
|
mathapp
|
|
pkg/
|
|
${GOOS}_${GOARCH}, such as darwin_amd64, linux_amd64
|
|
mymath.a
|
|
github.com/
|
|
astaxie/
|
|
beedb.a
|
|
src/
|
|
mathapp
|
|
main.go
|
|
mymath/
|
|
sqrt.go
|
|
github.com/
|
|
astaxie/
|
|
beedb/
|
|
beedb.go
|
|
util.go
|
|
|
|
Now you are able to see the directory structure clearly: `bin` contains executable files, `pkg` contains compiled files and `src` contains package source files.
|
|
|
|
(The format of environment variables in Windows is `%GOPATH%`, however this book mainly follows the Unix-style, so Windows users need to replace these yourself.)
|
|
|
|
## Links
|
|
|
|
- [Directory](preface.md)
|
|
- Previous section: [Installation](01.1.md)
|
|
- Next section: [Go commands](01.3.md)
|