build-web-application-with-golang/de/01.2.md

#1.2 $GOPATH and workspace

## $GOPATH

Go commands all rely on one important environment variable called $GOPATH. Notice that this is not the $GOROOT variable where Go is installed. This variable points to the workspace of Go on your computer (I use this path on my computer; if you don't have the same directory structure, please replace by yourself).

In Unix-like systems, the variable should be used like this:
	
	export GOPATH=/home/apple/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 break them up. At this point, `go get` will save the content to your first path in $GOPATH.

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 same name for the folder where contains package source files***)

Every time you create a package, you should create a new folder in the `src` directory. 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 following content to your file.

	// 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
	
code 

	//$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.

	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)