lostecho/build-web-application-with-golang
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Test2

Browse Source
This commit is contained in:
Slava Zgordan
2015-07-19 05:13:41 +02:00
parent 421f6ec83f
commit 03d91c59ca
99 changed files with 0 additions and 12903 deletions
Download Patch File Download Diff File Expand all files Collapse all files

151
ru/01.2.md
View File

@@ -1,151 +0,0 @@
#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)