01.2.md

#1.2 $GOPATH and workspace ##$GOPATH Go commands all rely on one important environment variable which is called $GOPATH. Notice that this is not the $GOROOT where Go is installed. This variable points to the workspace of Go in your computer. (I use this path in 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 is OK to have more than one path(workspace) in $GOPATH, but remember that you have to use :(; in Windows) to break up them. 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, folders' name usually as same as the package's that you are going to use. You can have multi-level directory if you want to. For example, you create directories $GOPATH/src/github.com/astaxie/beedb, then the package path is 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 is created and code work is done. I recommend you to keep same name for your package and the folder contains package source files.

##Compile packages We've already created our package above, but how to compile it for practical? There are two ways to do it.

1. Switch your work path to the directory of your package, then execute command go install.
2. Execute above command with file name like go install mymath.

After compiled, 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 packages, and now how can 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 is $GOPATH/src/mathapp in this case, then execute command go install. Now you should see an executable file called mathapp was generated in the directory $GOPATH/bin/. To run this program, use command ./mathapp, you should see following content in your terminal.

Hello world. Sqrt(2) = 1.414213562373095

##Install remote packages Go has a tool for installing remote packages, which is the command called go get. It supports most of 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, hg for Google Code. Therefore you have to install these version control tools before you use go get.

After executed 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 $GOPATH/src of local file system, then executes go install.

Use remote packages is the same way as we use local packages.

import "github.com/astaxie/beedb"

##Directory complete structure If you follow all steps, your directory structure should look like the following now.

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, src contains package source files.

(The format of environment variables in Windows is %GOPATH%, this book mainly uses Unix-style, so Windows users need to replace by yourself.)

##Links

• Directory
• Previous section: Installation
• Next section: Go commands