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

new working files added

Browse Source
This commit is contained in:
Maryam Behzadi
2018-05-30 15:39:28 +04:30
parent df3cf71ad3
commit f5a0e4dcf5
6 changed files with 0 additions and 96 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
fa/not translated/01.0.md
View File

@@ -1,20 +0,0 @@
# 1 Go Environment Configuration
Welcome to the world of Go, let's start exploring!
Go is a fast-compiled, garbage-collected, concurrent systems programming language. It has the following advantages:
- Compiles a large project within a few seconds.
- Provides a software development model that is easy to reason about, avoiding most of the problems associated with C-style header files.
- Is a static language that does not have levels in its type system, so users do not need to spend much time dealing with relations between types. It is more like a lightweight object-oriented language.
- Performs garbage collection. It provides basic support for concurrency and communication.
- Designed for multi-core computers.
Go is a compiled language. It combines the development efficiency of interpreted or dynamic languages with the security of static languages. It is going to be the language of choice for modern, multi-core computers with networking. For these purposes, there are some problems that need to inherently be resolved at the level of the language of choice, such as a richly expressive lightweight type system, a native concurrency model, and strictly regulated garbage collection. For quite some time, no packages or tools have emerged that have aimed to solve all of these problems in a pragmatic fashion; thus was born the motivation for the Go language.
In this chapter, I will show you how to install and configure your own Go development environment.
## Links
- [Directory](preface.md)
- Next section: [Installation](01.1.md)

148
fa/not translated/01.1.md
View File

@@ -1,148 +0,0 @@
# 1.1 Installation
## Three ways to install Go
There are many ways to configure the Go development environment on your computer, and you can choose whichever one you like. The three most common ways are as follows.
- Official installation packages.
- The Go team provides convenient installation packages in Windows, Linux, Mac and other operating systems. This is probably the easiest way to get started. You can get the installers from the [Golang Download Page](https://golang.org/dl/).
- Install it yourself from source code.
- Popular with developers who are familiar with Unix-like systems.
- Using third-party tools.
- There are many third-party tools and package managers for installing Go, like apt-get in Ubuntu and homebrew for Mac.
In case you want to install more than one version of Go on a computer, you should take a look at a tool called [GVM](https://github.com/moovweb/gvm). It is the best tool I've seen so far for accomplishing this task, otherwise you'd have to deal with it yourself.
## Install from source code
To compile Go 1.5 and upwards, you only need the previous version of Go, as Go has achieved bootstrapping. You only need Go to compile Go.
To compile Go 1.4 downwards, you will need a C compiler as some parts of Go are still written in Plan 9 C and AT&T assembler.
On a Mac, if you have installed Xcode, you already have the compiler.
On Unix-like systems, you need to install gcc or a similar compiler. For example, using the package manager apt-get (included with Ubuntu), one can install the required compilers as follows:
```sh
sudo apt-get install gcc libc6-dev
```
On Windows, you need to install MinGW in order to install gcc. Don't forget to configure your environment variables after the installation has completed.( ***Everything that looks like this means it's commented by a translator: If you are using 64-bit Windows, you should install the 64-bit version of MinGW*** )
At this point, execute the following commands to clone the Go source code and compile it.( ***It will clone the source code to your current directory. Switch your work path before you continue. This may take some time.*** )
git clone https://go.googlesource.com/go
cd go/src
./all.bash
A successful installation will end with the message "ALL TESTS PASSED."
On Windows, you can achieve the same by running `all.bat`.
If you are using Windows, the installation package will set your environment variables automatically. In Unix-like systems, you need to set these variables manually as follows. ( ***If your Go version is greater than 1.0, you don't have to set $GOBIN, and it will automatically be related to your $GOROOT/bin, which we will talk about in the next section***)
export GOROOT=$HOME/go
export GOBIN=$GOROOT/bin
export PATH=$PATH:$GOROOT/bin
If you see the following information on your screen, you're all set.
![](images/1.1.mac.png?raw=true)
Figure 1.1 Information after installing from source code
Once you see the usage information of Go, it means you have successfully installed Go on your computer. If it says "no such command", check that your $PATH environment variable contains the installation path of Go.
## Using the standard installation packages
Go has one-click installation packages for every supported operating system. These packages will install Go in `/usr/local/go` (`c:\Go` in Windows) by default. Of course this can be modified, but you also need to change all the environment variables manually as I've shown above.
### How to check if your operating system is 32-bit or 64-bit?
Our next step depends on your operating system type, so we have to check it before we download the standard installation packages.
If you are using Windows, press `Win+R` and then run the command tool. Type the `systeminfo` command and it will show you some useful system information. Find the line that says "system type" -if you see "x64-based PC" that means your operating system is 64-bit, 32-bit otherwise.
I strongly recommend downloading the 64-bit package if you are a Mac user, as Go no longer supports pure 32-bit processors on Mac OSX.
Linux users can type `uname -a` in the terminal to see system information.
A 64-bit operating system will show the following:
<some description> x86_64 x86_64 x86_64 GNU/Linux
// some machines such as Ubuntu 10.04 will show as following
x86_64 GNU/Linux
32-bit operating systems instead show:
<some description> i686 i686 i386 GNU/Linux
### Mac
Go to the [download page](https://golang.org/dl/), choose `go1.4.2.darwin-386.pkg` (The later version has no 32-bit download.)for 32-bit systems and `go1.8.3.darwin-amd64.pkg` for 64-bit systems. Going all the way to the end by clicking "next", `~/go/bin` will be added to your system's $PATH after you finish the installation. Now open the terminal and type `go`. You should see the same output shown in figure 1.1.
### Linux
Go to the [download page](https://golang.org/dl/), choose `go1.8.3.linux-386.tar.gz` for 32-bit systems and `go1.8.3.linux-amd64.tar.gz` for 64-bit systems. Suppose you want to install Go in the `$GO_INSTALL_DIR` path. Uncompress the `tar.gz` to your chosen path using the command `tar zxvf go1.8.3.linux-amd64.tar.gz -C $GO_INSTALL_DIR`. Then set your $PATH with the following: `export PATH=$PATH:$GO_INSTALL_DIR/go/bin`. Now just open the terminal and type `go`. You should now see the same output displayed in figure 1.1.
### Windows
Go to the [download page](https://golang.org/dl/), choose `go1.8.3.windows-386.msi` for 32-bit systems and `go1.8.3.windows-amd64.msi` for 64-bit systems. Going all the way to the end by clicking "next", `c:/go/bin` will be added to `path`. Now just open a command line window and type `go`. You should now see the same output displayed in figure 1.1.
## Use third-party tools
### GVM
GVM is a Go multi-version control tool developed by a third-party, like rvm for ruby. It's quite easy to use. Install gvm by typing the following commands in your terminal:
bash < <(curl -s -S -L https://raw.github.com/moovweb/gvm/master/binscripts/gvm-installer)
Then we install Go using the following commands:
gvm install go1.8.3
gvm use go1.8.3
After the process has finished, you're all set.
### apt-get
Ubuntu is the most popular desktop release version of Linux. It uses `apt-get` to manage packages. We can install Go using the following commands.
sudo add-apt-repository ppa:gophers/go
sudo apt-get update
sudo apt-get install golang-go
### wget
```sh
wget https://storage.googleapis.com/golang/go1.8.3.linux-amd64.tar.gz
sudo tar -xzf go1.8.3.linux-amd64.tar.gz -C /usr/local
# Go environment
export GOROOT=/usr/local/go
export GOBIN=$GOROOT/bin
export PATH=$PATH:$GOBIN
export GOPATH=$HOME/gopath
```
Starting from go 1.8, The GOPATH environment variable now has a default value if it is unset. It defaults to `$HOME/go` on Unix and `%USERPROFILE%/go` on Windows.
### Homebrew
Homebrew is a software management tool commonly used in Mac to manage packages. Just type the following commands to install Go.
1. Install Homebrew
```sh
/usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"
```
2. Install Go
```sh
brew update && brew upgrade
brew install go
```
## Links
- [Directory](preface.md)
- Previous section: [Go environment configuration](01.0.md)
- Next section: [$GOPATH and workspace](01.2.md)

156
fa/not translated/01.2.md
View File

@@ -1,156 +0,0 @@
# 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 in 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 is unset. It defaults to `$HOME/go` on Unix and `%USERPROFILE%/go` on Windows.
In 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 break them up. 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 it's 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)

106
fa/not translated/01.3.md
View File

@@ -1,106 +0,0 @@
# 1.3 Go commands
## Go commands
The Go language comes with a complete set of command operation tools. You can execute the `go` command on the terminal to see them:
![](images/1.3.go.png?raw=true)
Figure 1.3 Go command displays detailed information
These are all useful for us. Let's see how to use some of them.
## go build
This command is for compiling tests. It will compile packages and dependencies if it's necessary.
- If the package is not the `main` package such as `mymath` in section 1.2, nothing will be generated after you execute `go build`. If you need the package file `.a` in `$GOPATH/pkg`, use `go install` instead.
- If the package is the `main` package, it will generate an executable file in the same folder. If you want the file to be generated in `$GOPATH/bin`, use `go install` or `go build -o ${PATH_HERE}/a.exe.`
- If there are many files in the folder, but you just want to compile one of them, you should append the file name after `go build`. For example, `go build a.go`. `go build` will compile all the files in the folder.
- You can also assign the name of the file that will be generated. For instance, in the `mathapp` project (in section 1.2), using `go build -o astaxie.exe` will generate `astaxie.exe` instead of `mathapp.exe`. The default name is your folder name (non-main package) or the first source file name (main package).
(According to [The Go Programming Language Specification](https://golang.org/ref/spec), package names should be the name after the word `package` in the first line of your source files. It doesn't have to be the same as the folder name, and the executable file name will be your folder name by default.)
- `go build` ignores files whose names start with `_` or `.`.
- If you want to have different source files for every operating system, you can name files with the system name as a suffix. Suppose there are some source files for loading arrays. They could be named as follows:
array_linux.go | array_darwin.go | array_windows.go | array_freebsd.go
`go build` chooses the one that's associated with your operating system. For example, it only compiles array_linux.go in Linux systems, and ignores all the others.
## go clean
This command is for cleaning files that are generated by compilers, including the following files:
_obj/ // old directory of object, left by Makefiles
_test/ // old directory of test, left by Makefiles
_testmain.go // old directory of gotest, left by Makefiles
test.out // old directory of test, left by Makefiles
build.out // old directory of test, left by Makefiles
*.[568ao] // object files, left by Makefiles
DIR(.exe) // generated by go build
DIR.test(.exe) // generated by go test -c
MAINFILE(.exe) // generated by go build MAINFILE.go
I usually use this command to clean up my files before I upload my project to Github. These are useful for local tests, but useless for version control.
## go fmt and gofmt
The people who are working with C/C++ should know that people are always arguing about which code style is better: K&R-style or ANSI-style. However in Go, there is only one code style which is enforced. For example, left braces must only be inserted at the end of lines, and they cannot be on their own lines, otherwise you will get compile errors! Fortunately, you don't have to remember these rules. `go fmt` does this job for you. Just execute the command `go fmt <File name>.go` in terminal. I don't use this command very much because IDEs usually execute this command automatically when you save source files. I will talk more about IDEs in the next section.
`go fmt` is just an alias, which runs the command 'gofmt -l -w' on the packages named by the import paths.
We usually use `gofmt -w` instead of `go fmt`. The latter will not rewrite your source files after formatting code. `gofmt -w src` formats the whole project.
## go get
This command is for getting remote packages. So far, it supports BitBucket, Github, Google Code and Launchpad. There are actually two things that happen after we execute this command. The first thing is that Go downloads the source code, then executes `go install`. Before you use this command, make sure you have installed all of the related tools.
BitBucket (Mercurial Git)
Github (git)
Google Code (Git, Mercurial, Subversion)
Launchpad (Bazaar)
In order to use this command, you have to install these tools correctly. Don't forget to update the `$PATH` variable. By the way, it also supports customized domain names. Use `go help importpath` for more details about this.
## go install
This command compiles all packages and generates files, then moves them to `$GOPATH/pkg` or `$GOPATH/bin`.
## go test
This command loads all files whose name include `*_test.go` and generates test files, then prints information that looks like the following.
ok archive/tar 0.011s
FAIL archive/zip 0.022s
ok compress/gzip 0.033s
...
It tests all your test files by default. Use command `go help testflag` for more details.
## godoc
Many people say that we don't need any third-party documentation for programming in Go (actually I've made a [CHM](https://github.com/astaxie/godoc) already). Go has a powerful tool to manage documentation natively.
So how do we look up package information in documentation? For instance, if you want to get more details about the `builtin` package, use the `godoc builtin` command. Similarly, use the `godoc net/http` command to look up the `http` package documentation. If you want to see more details about specific functions, use the `godoc fmt Printf` and `godoc -src fmt Printf` commands to view the source code.
Execute the `godoc -http=:8080` command, then open `127.0.0.1:8080` in your browser. You should see a localized golang.org. It can not only show the standard packages' information, but also packages in your `$GOPATH/pkg`. It's great for people who are suffering from the Great Firewall of China.
## Other commands
Go provides more commands than those we've just talked about.
go fix // upgrade code from an old version before go1 to a new version after go1
go version // get information about your version of Go
go env // view environment variables about Go
go list // list all installed packages
go run // compile temporary files and run the application
There are also more details about the commands that I've talked about. You can use `go help <command>` to look them up.
## Links
- [Directory](preface.md)
- Previous section: [$GOPATH and workspace](01.2.md)
- Next section: [Go development tools](01.4.md)

483
fa/not translated/01.4.md
View File

@@ -1,483 +0,0 @@
# Go development tools
In this section, I'm going to show you a few IDEs that can help you become a more efficient programmer, with capabilities such as intelligent code completion and auto-formatting. They are all cross-platform, so the steps I will be showing you should not be very different, even if you are not using the same operating system.
## LiteIDE
LiteIDE is an open source, lightweight IDE for developing Go projects only, developed by visualfc.
![](images/1.4.liteide.png?raw=true)
Figure 1.4 Main panel of LiteIDE
LiteIDE features.
- Cross-platform
- Windows
- Linux
- Mac OS
- Cross-compile
- Manage multiple compile environments
- Supports cross-compilation of Go
- Project management standard
- Documentation view based on $GOPATH
- Compilation system based on $GOPATH
- API documentation index based on $GOPATH
- Go source code editor
- Code outlining
- Full support of gocode
- Go documentation view and API index
- View code expression using `F1`
- Function declaration jump using `F2`
- Gdb support
- Auto-format with `gofmt`
- Others
- Multi-language
- Plugin system
- Text editor themes
- Syntax support based on Kate
- intelligent completion based on full-text
- Customized shortcuts
- Markdown support
- Real-time preview
- Customized CSS
- Export HTML and PDF
- Convert and merge to HTML and PDF
### LiteIDE installation
- Install LiteIDE
- [Download page](https://sourceforge.net/projects/liteide/files/)
- [Source code](https://github.com/visualfc/liteide)
You need to install Go first, then download the version appropriate for your operating system. Decompress the package to directly use it.
- Install gocode
You have to install gocode in order to use intelligent completion
go get -u github.com/nsf/gocode
- Compilation environment
Switch configuration in LiteIDE to suit your operating system.
In Windows and using the 64-bit version of Go, you should choose win64 as the configuration environment in the tool bar. Then, choose `Options`, find `LiteEnv` in the left list and open file `win64.env` in the right list.
GOROOT=c:\go
GOBIN=
GOARCH=amd64
GOOS=windows
CGO_ENABLED=1
PATH=%GOBIN%;%GOROOT%\bin;%PATH%
。。。
Replace `GOROOT=c:\go` to your Go installation path, save it. If you have MinGW64, add `c:\MinGW64\bin` to your path environment variable for `cgo` support.
In Linux and using the 64-bit version of Go, you should choose linux64 as the configuration environment in the tool bar. Then, choose `Options`, find `LiteEnv` in the left list and open the `linux64.env` file in the right list.
GOROOT=$HOME/go
GOBIN=
GOARCH=amd64
GOOS=linux
CGO_ENABLED=1
PATH=$GOBIN:$GOROOT/bin:$PATH
。。。
Replace `GOROOT=$HOME/go` to your Go installation path, save it.
- $GOPATH
$GOPATH is the path that contains a list of projects. Open the command tool (or press ``Ctrl+` ``in LiteIDE), then type `go help gopath` for more details.
It's very easy to view and change $GOPATH in LiteIDE. Follow `View - Setup GOPATH` to view and change these values.
## Sublime Text
Here I'm going to introduce you the Sublime Text 3 (Sublime for short) + GoSublime + gocode. Let me explain why.
- Intelligent completion
![](images/1.4.sublime1.png?raw=true)
Figure 1.5 Sublime intelligent completion
- Auto-format source files
- Project management
![](images/1.4.sublime2.png?raw=true)
Figure 1.6 Sublime project management
- Syntax highlight
- Free trial forever with no functional limitations. You may be prompted once in a while to remind you to purchase a license, but you can simply ignore it if you wish. Of course, if you do find that it enhances your productivity and you really enjoy using it, please purchase a copy of it and support its continued development!
First, download the version of [Sublime](http://www.sublimetext.com/) suitable for your operating system.
1. Press ``Ctrl+` ``, open the command tool and input the following commands.
Applicable to Sublime Text 3：
```Go
import urllib.request,os;pf='Package Control.sublime-package';ipp=sublime.installed_packages_path();urllib.request.install_opener(urllib.request.build_opener(urllib.request.ProxyHandler()));open(os.path.join(ipp,pf),'wb').write(urllib.request.urlopen('http://sublime.wbond.net/'+pf.replace(' ','%20')).read())
```
Applicable to Sublime Text 2：
```Go
import urllib2,os;pf='Package Control.sublime-package';ipp=sublime.installed_packages_path();os.makedirs(ipp)ifnotos.path.exists(ipp)elseNone;urllib2.install_opener(urllib2.build_opener(urllib2.ProxyHandler()));open(os.path.join(ipp,pf),'wb').write(urllib2.urlopen('http://sublime.wbond.net/'+pf.replace(' ','%20')).read());print('Please restart Sublime Text to finish installation')
```
Restart Sublime Text when the installation has finished. You should then find a `Package Control` option in the "Preferences" menu.
![](images/1.4.sublime3.png?raw=true)
Figure 1.7 Sublime Package Control
2. To install GoSublime, SidebarEnhancements and Go Build, press `Ctrl+Shift+p` to open Package Control, then type `pcip` (short for "Package Control: Install Package").
![](images/1.4.sublime4.png?raw=true)
Figure 1.8 Sublime Install Packages
Now type in "GoSublime", press OK to install the package, and repeat the same steps for installing SidebarEnhancements and Go Build. Once again, restart the editor when it completes the installation.
3. To verify that the installation is successful, open Sublime, then open the `main.go` file to see if it has the proper syntax highlighting. Type `import` to see if code completion prompts appear. After typing `import "fmt"`, type `fmt.` anywhere after the `import` declaration to see whether or not intelligent code completion for functions was successfully enabled.
If everything is fine, you're all set.
If not, check your $PATH again. Open a terminal, type `gocode`. If it does not run, your $PATH was not configured correctly.
## Vim
Vim is a popular text editor for programmers, which evolved from its slimmer predecessor, Vi. It has functions for intelligent completion, compilation and jumping to errors.
vim-go is vim above an open-source go language using the most extensive development environment plug-ins
The plugin address：[github.com/fatih/vim-go](https://github.com/fatih/vim-go)
Vim plugin management are the mainstream [Pathogen](https://github.com/tpope/vim-pathogen) and [Vundle](https://github.com/VundleVim/Vundle.vim)
，But the aspects thereof are different.
Pathogen is to solve each plug-in after the installation of files scattered to multiple directories and poor management of the existence. Vundle is to solve the automatic search and download plug-ins exist.
These two plug-ins can be used simultaneously.
1.Install Vundle
```sh
mkdir ~/.vim/bundle
git clone https://github.com/gmarik/Vundle.vim.git ~/.vim/bundle/Vundle.vim
```
Edit .vimrc，Vundle the relevant configuration will be placed in the beginning([Refer to the Vundle documentation for details](https://github.com/VundleVim/Vundle.vim))
```sh
set nocompatible " be iMproved, required
filetype off " required
" set the runtime path to include Vundle and initialize
set rtp+=~/.vim/bundle/Vundle.vim
call vundle#begin()
" let Vundle manage Vundle, required
Plugin 'gmarik/Vundle.vim'
" All of your Plugins must be added before the following line
call vundle#end() " required
filetype plugin indent on " required
```
2.Install Vim-go
Edit ~/.vimrc，Add a line between vundle #begin and vundle #end：
```sh
Plugin 'fatih/vim-go'
```
Executed within Vim: PluginInstall
3.Install YCM(Your Complete Me) to AutoComplete
Add a line to ~ / .vimrc:
```sh
Plugin 'Valloric/YouCompleteMe'
```
Executed within Vim: PluginInstall
![](images/1.4.vim.png?raw=true)
Figure 1.8 Vim intelligent completion for Go
1. Syntax highlighting for Go
cp -r $GOROOT/misc/vim/* ~/.vim/
2. Enabling syntax highlighting
filetype plugin indent on
syntax on
3. Install [gocode](https://github.com/nsf/gocode/)
go get -u github.com/nsf/gocode
gocode will be installed in `$GOBIN` as default
4. Configure [gocode](https://github.com/nsf/gocode/)
~ cd $GOPATH/src/github.com/nsf/gocode/vim
~ ./update.sh
~ gocode set propose-builtins true
propose-builtins true
~ gocode set lib-path "/home/border/gocode/pkg/linux_amd64"
lib-path "/home/border/gocode/pkg/linux_amd64"
~ gocode set
propose-builtins true
lib-path "/home/border/gocode/pkg/linux_amd64"
Explanation of gocode configuration:
propose-builtins: specifies whether or not to open intelligent completion; false by default.
lib-path: gocode only searches for packages in `$GOPATH/pkg/$GOOS_$GOARCH` and `$GOROOT/pkg/$GOOS_$GOARCH`. This setting can be used to add additional paths.
5. Congratulations! Try `:e main.go` to experience the world of Go!
## Emacs
Emacs is the so-called Weapon of God. She is not only an editor, but also a powerful IDE.
![](images/1.4.emacs.png?raw=true)
Figure 1.10 Emacs main panel of Go editor
1. Syntax highlighting
cp $GOROOT/misc/emacs/* ~/.emacs.d/
2. Install [gocode](https://github.com/nsf/gocode/)
go get -u github.com/nsf/gocode
gocode will be installed in `$GOBIN` as default
3. Configure [gocode](https://github.com/nsf/gocode/)
~ cd $GOPATH/src/github.com/nsf/gocode/vim
~ ./update.bash
~ gocode set propose-builtins true
propose-builtins true
~ gocode set lib-path "/home/border/gocode/pkg/linux_amd64"
lib-path "/home/border/gocode/pkg/linux_amd64"
~ gocode set
propose-builtins true
lib-path "/home/border/gocode/pkg/linux_amd64"
4. Install [Auto Completion](http://www.emacswiki.org/emacs/AutoComplete)
Download and uncompress
~ make install DIR=$HOME/.emacs.d/auto-complete
Configure ~/.emacs file
;;auto-complete
(require 'auto-complete-config)
(add-to-list 'ac-dictionary-directories "~/.emacs.d/auto-complete/ac-dict")
(ac-config-default)
(local-set-key (kbd "M-/") 'semantic-complete-analyze-inline)
(local-set-key "." 'semantic-complete-self-insert)
(local-set-key ">" 'semantic-complete-self-insert)
Follow this [link](http://www.emacswiki.org/emacs/AutoComplete) for more details.
5. Configure .emacs
;; golang mode
(require 'go-mode-load)
(require 'go-autocomplete)
;; speedbar
;; (speedbar 1)
(speedbar-add-supported-extension ".go")
(add-hook
'go-mode-hook
'(lambda ()
;; gocode
(auto-complete-mode 1)
(setq ac-sources '(ac-source-go))
;; Imenu & Speedbar
(setq imenu-generic-expression
'(("type" "^type *\\([^ \t\n\r\f]*\\)" 1)
("func" "^func *\\(.*\\) {" 1)))
(imenu-add-to-menubar "Index")
;; Outline mode
(make-local-variable 'outline-regexp)
(setq outline-regexp "//\\.\\|//[^\r\n\f][^\r\n\f]\\|pack\\|func\\|impo\\|cons\\|var.\\|type\\|\t\t*....")
(outline-minor-mode 1)
(local-set-key "\M-a" 'outline-previous-visible-heading)
(local-set-key "\M-e" 'outline-next-visible-heading)
;; Menu bar
(require 'easymenu)
(defconst go-hooked-menu
'("Go tools"
["Go run buffer" go t]
["Go reformat buffer" go-fmt-buffer t]
["Go check buffer" go-fix-buffer t]))
(easy-menu-define
go-added-menu
(current-local-map)
"Go tools"
go-hooked-menu)
;; Other
(setq show-trailing-whitespace t)
))
;; helper function
(defun go ()
"run current buffer"
(interactive)
(compile (concat "go run " (buffer-file-name))))
;; helper function
(defun go-fmt-buffer ()
"run gofmt on current buffer"
(interactive)
(if buffer-read-only
(progn
(ding)
(message "Buffer is read only"))
(let ((p (line-number-at-pos))
(filename (buffer-file-name))
(old-max-mini-window-height max-mini-window-height))
(show-all)
(if (get-buffer "*Go Reformat Errors*")
(progn
(delete-windows-on "*Go Reformat Errors*")
(kill-buffer "*Go Reformat Errors*")))
(setq max-mini-window-height 1)
(if (= 0 (shell-command-on-region (point-min) (point-max) "gofmt" "*Go Reformat Output*" nil "*Go Reformat Errors*" t))
(progn
(erase-buffer)
(insert-buffer-substring "*Go Reformat Output*")
(goto-char (point-min))
(forward-line (1- p)))
(with-current-buffer "*Go Reformat Errors*"
(progn
(goto-char (point-min))
(while (re-search-forward "<standard input>" nil t)
(replace-match filename))
(goto-char (point-min))
(compilation-mode))))
(setq max-mini-window-height old-max-mini-window-height)
(delete-windows-on "*Go Reformat Output*")
(kill-buffer "*Go Reformat Output*"))))
;; helper function
(defun go-fix-buffer ()
"run gofix on current buffer"
(interactive)
(show-all)
(shell-command-on-region (point-min) (point-max) "go tool fix -diff"))
6. Congratulations, you're done! Speedbar is closed by default -remove the comment symbols in the line `;;(speedbar 1)` to enable this feature, or you can use it through `M-x speedbar`.
## Eclipse
Eclipse is also a great development tool. I'll show you how to use it to write Go programs.
![](images/1.4.eclipse1.png?raw=true)
Figure 1.1 Eclipse main panel for editing Go
1. Download and install [Eclipse](http://www.eclipse.org/)
2. Download [goclipse](https://code.google.com/p/goclipse/)
[http://code.google.com/p/goclipse/wiki/InstallationInstructions](http://code.google.com/p/goclipse/wiki/InstallationInstructions)
3. Download gocode
gocode in Github.
https://github.com/nsf/gocode
You need to install git in Windows, usually we use [msysgit](https://code.google.com/p/msysgit/)
Install gocode in the command tool
go get -u github.com/nsf/gocode
You can install from source code if you like.
4. Download and install [MinGW](http://sourceforge.net/projects/mingw/files/MinGW/)
5. Configure plugins.
Windows->Preferences->Go
(1).Configure Go compiler
![](images/1.4.eclipse2.png?raw=true)
Figure 1.12 Go Setting in Eclipse
(2).Configure gocode(optional), set gocode path to where the gocode.exe is.
![](images/1.4.eclipse3.png?raw=true)
Figure 1.13 gocode Setting
(3).Configure gdb(optional), set gdb path to where the gdb.exe is.
![](images/1.4.eclipse4.png?raw=true)
Figure 1.14 gdb Setting
6. Check the installation
Create a new Go project and hello.go file as following.
![](images/1.4.eclipse5.png?raw=true)
Figure 1.15 Create a new project and file
Test installation as follows.(you need to type command in console in Eclipse)
![](images/1.4.eclipse6.png?raw=true)
Figure 1.16 Test Go program in Eclipse
## IntelliJ IDEA
People who have worked with Java should be familiar with this IDE. It supports Go syntax highlighting and intelligent code completion, implemented by a plugin.
1. Download IDEA, there is no difference between the Ultimate and Community editions
![](images/1.4.idea1.png?raw=true)
2. Install the Go plugin. Choose `File - Setting - Plugins`, then click `Browser repo`.
![](images/1.4.idea3.png?raw=true)
3. Search `golang`, double click `download and install` and wait for the download to complete.
![](images/1.4.idea4.png?raw=true)
Click `Apply`, then restart.
4. Now you can create a Go project.
![](images/1.4.idea5.png?raw=true)
Input the position of your Go sdk in the next step -basically it's your $GOROOT.
( ***See a [blog post](http://wuwen.org/tips-about-using-intellij-idea-and-go/) for setup and use IntelliJ IDEA with Go step by step *** )
## Visual Studio VSCode
This is an awesome text editor released as open source cross platform my Microsoft which takes the development experience to a whole new level, https://code.visualstudio.com/. It has everything a modern text editor is expected to have and despite being based on the same backend that atom.io is based, it is very fast.
It works with Windows, Mac, Linux. It has go package built, it provides code linting.
## Atom
Atom is an awesome text editor released as open source cross platform, built on Electron , and based on everything we love about our favorite editors. We designed it to be deeply customizable, but still approachable using the default configuration.
Download: https://atom.io/
## Gogland
Gogland is the codename for a new commercial IDE by JetBrains aimed at providing an ergonomic environment for Go development.
The official version is not yet released。
Download:https://www.jetbrains.com/go/
## Links
- [Directory](preface.md)
- Previous section: [Go commands](01.3.md)
- Next section: [Summary](01.5.md)