Go 環境配置完全指南：安裝、GOPATH、常用命令與開發工具（Build Web Application with Golang 第一章）
Go 環境配置完全指南：安裝、GOPATH、常用命令與開發工具（Build Web Application with Golang 第一章）
本指南對應開源電子書《Build Web Application with Golang》（正體中文版）第一章「Go 環境配置」，系統講解 Go 語言的三種安裝方式（原始碼、標準套件、第三方工具）、GOPATH 與工作空間的規劃、go 工具鏈的核心命令（build/clean/fmt/get/install/test 等），以及 LiteIDE、Sublime Text、VSCode、Atom、GoLand、Vim、Emacs、Eclipse、IntelliJ IDEA 等主流開發工具的配置方法。讀完後你將能獨立完成從零搭建 Go 開發環境、組織專案目錄、編譯安裝應用，並按自己的習慣選配一款趁手的編輯器，為後續章節的 Web 應用開發打下基礎。
目錄
1.1 安裝 Go
Go 的三種安裝方式
Go 有多種安裝方式，你可以選擇自己喜歡的。這裡我們介紹三種最常見的安裝方式：
- Go 原始碼安裝：這是一種標準的軟體安裝方式。對於經常使用 Unix 類別系統的使用者，尤其對於開發者來說，從原始碼安裝可以自己訂製。
- Go 標準套件安裝：Go 提供了方便的安裝套件，支援 Windows、Linux、Mac 等系統。這種方式適合快速安裝，可根據自己的系統位數下載好相應的安裝套件，一路 next 就可以輕鬆安裝了。推薦這種方式。
- 第三方工具安裝：目前有很多方便的第三方軟體套件工具，例如 Ubuntu 的 apt-get 和 wget、Mac 的 homebrew 等。這種安裝方式適合那些熟悉相應系統的使用者。
最後，如果你想在同一個系統中安裝多個版本的 Go，你可以參考第三方工具 GVM，這是目前在這方面做得最好的工具，除非你知道怎麼處理。
Go 原始碼安裝
Go 1.5 徹底移除 C 程式碼，Runtime、Compiler、Linker 均由 Go 編寫，實現自舉（bootstrapping）。只需要安裝了上一個版本，即可從原始碼安裝。
在 Go 1.5 之前，Go 的原始碼中，有些部分是用 Plan 9 C 和 AT&T 彙編寫的，因此假如你要想從原始碼安裝，就必須安裝 C 的編譯工具：
- 在 Mac 系統中，只要你安裝了 Xcode，就已經包含了相應的編譯工具。
- 在類 Unix 系統中，需要安裝 gcc 等工具。例如 Ubuntu 系統可透過在終端中執行
sudo apt-get install gcc libc6-dev來安裝編譯工具。 - 在 Windows 系統中，你需要安裝 MinGW，然後透過 MinGW 安裝 gcc，並設定相應的環境變數。
你可以直接去官網下載原始碼，找相應的 goVERSION.src.tar.gz 的檔案下載，下載之後解壓縮到 $HOME 目錄，執行如下程式碼：
cd go/src
./all.bash
執行 all.bash 後出現 "ALL TESTS PASSED" 字樣時才算安裝成功。
上面是 Unix 風格的命令，Windows 下的安裝方式類似，只不過是執行 all.bat，呼叫的編譯器是 MinGW 的 gcc。
如果是 Mac 或者 Unix 使用者需要設定幾個環境變數，如果想重啟之後也能生效的話把下面的命令寫到 .bashrc 或者 .zshrc 裡面：
export GOPATH=$HOME/gopath
export PATH=$PATH:$HOME/go/bin:$GOPATH/bin
如果你是寫入檔案的，記得執行 bash .bashrc 或者 bash .zshrc 使得設定立馬生效。如果是 Windows 系統，就需要設定環境變數，在 path 裡面增加相應的 go 所在的目錄，設定 gopath 變數。
當你設定完畢之後在命令列裡面輸入 go，看到如下圖片即說明你已經安裝成功：
圖 1.1 原始碼安裝之後執行 Go 命令的圖
如果出現 Go 的 Usage 資訊，那麼說明 Go 已經安裝成功了；如果出現該命令不存在，那麼可以檢查一下自己的 PATH 環境變數中是否包含了 Go 的安裝目錄。
從 go 1.8 開始，GOPATH 環境變數現在有一個預設值，如果它沒有被設定。它在 Unix 上預設為 $HOME/go，在 Windows 上預設為 %USERPROFILE%/go。
Go 標準套件安裝
Go 提供了每個平臺一鍵安裝的選項，這些套件預設會安裝到如下目錄：/usr/local/go（Windows 系統：c:\Go），當然你可以改變它們的安裝位置，但是改變之後你必須在你的環境變數中設定如下資訊：
export GOROOT=$HOME/go
export GOPATH=$HOME/gopath
export PATH=$PATH:$GOROOT/bin:$GOPATH/bin
上面這些命令對於 Mac 和 Unix 使用者來說最好是寫入 .bashrc 或者 .zshrc 檔案，對於 Windows 使用者來說當然是寫入環境變數。
如何判斷自己的作業系統是 32 位還是 64 位？
我們接下來的 Go 安裝需要判斷作業系統的位數，所以這小節我們先確定自己的系統型別：
- Windows 系統：按 Win+R 執行 cmd，輸入
systeminfo後按 Enter，稍等片刻，會出現一些系統資訊。在「系統型別」一行中，若顯示 "x64-based PC"，即為 64 位系統；若顯示 "X86-based PC"，則為 32 位系統。 - Mac 系統：建議直接使用 64 位的，因為 Go 所支援的 Mac OS X 版本已經不支援純 32 位處理器了。
- Linux 系統：可透過在 Terminal 中執行命令
arch（即uname -m）來檢視系統資訊：
64 位系統顯示：
x86_64
32 位系統顯示：
i386
Mac 安裝
訪問 Golang 下載地址，32 位系統下載 go1.4.2.darwin-386-osx10.8.pkg（更新的版本已無 32 位下載），64 位系統下載 go1.8.3.darwin-amd64.pkg，雙擊下載檔案，一路預設安裝點選下一步，這個時候 go 已經安裝到你的系統中，預設已經在 PATH 中增加了相應的 ~/go/bin，這個時候開啟終端，輸入 go。
看到類似上面原始碼安裝成功的圖片說明已經安裝成功。如果出現 go 的 Usage 資訊，那麼說明 go 已經安裝成功了；如果出現該命令不存在，那麼可以檢查一下自己的 PATH 環境變中是否包含了 go 的安裝目錄。
Linux 安裝
訪問 Golang 下載地址，32 位系統下載 go1.8.3.linux-386.tar.gz，64 位系統下載 go1.8.3.linux-amd64.tar.gz。
假定你想要安裝 Go 的目錄為 $GO_INSTALL_DIR，後面替換為相應的目錄路徑。
解壓縮 tar.gz 到安裝目錄下：
tar zxvf go1.8.3.linux-amd64.tar.gz -C $GO_INSTALL_DIR
設定 PATH：
export PATH=$PATH:$GO_INSTALL_DIR/go/bin
然後執行 go：
圖 1.2 Linux 系統下安裝成功之後執行 go 顯示的資訊
如果出現 go 的 Usage 資訊，那麼說明 go 已經安裝成功了；如果出現該命令不存在，那麼可以檢查一下自己的 PATH 環境變中是否包含了 go 的安裝目錄。
Windows 安裝
訪問 Golang 下載頁，32 位請選擇名稱中包含 windows-386 的 msi 安裝套件，64 位請選擇名稱中包含 windows-amd64 的。下載好後執行，不要修改預設安裝目錄 C:\Go\，若安裝到其他位置會導致不能執行自己所編寫的 Go 程式碼。安裝完成後預設會在環境變數 Path 後新增 Go 安裝目錄下的 bin 目錄 C:\Go\bin\，並新增環境變數 GOROOT，值為 Go 安裝根目錄 C:\Go\。
驗證是否安裝成功：在執行中輸入 cmd 開啟命令列工具，在提示符下輸入 go，檢查是否能看到 Usage 資訊。輸入 cd %GOROOT%，看是否能進入 Go 安裝目錄。若都成功，說明安裝成功。
不能的話請檢查上述環境變數 Path 和 GOROOT 的值。若不存在請解除安裝後重新安裝，存在請重啟計算機後重試以上步驟。
第三方工具安裝
GVM
gvm 是第三方開發的 Go 多版本管理工具，類似 ruby 裡面的 rvm 工具。使用起來相當的方便，安裝 gvm 使用如下命令：
bash < <(curl -s -S -L https://raw.githubusercontent.com/moovweb/gvm/master/binscripts/gvm-installer)
安裝完成後我們就可以安裝 go 了：
gvm install go1.8.3
gvm use go1.8.3
也可以使用下面的命令，省去每次呼叫 gvm use 的麻煩：
gvm use go1.8.3 --default
執行完上面的命令之後 GOPATH、GOROOT 等環境變數會自動設定好，這樣就可以直接使用了。
apt-get
Ubuntu 是目前使用最多的 Linux 桌面系統，使用 apt-get 命令來管理軟體套件，我們可以透過下面的命令來安裝 Go，為了以後方便，應該把 git、mercurial 也安裝上：
sudo apt-get install python-software-properties
sudo add-apt-repository ppa:gophers/go
sudo apt-get update
sudo apt-get install golang-stable git-core mercurial
wget
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
配置環境變數：
export GOROOT=/usr/local/go
export GOBIN=$GOROOT/bin
export PATH=$PATH:$GOBIN
export GOPATH=$HOME/gopath (可選設定)
或者使用：
sudo vim /etc/profile
並新增下面的內容：
export GOROOT=/usr/local/go
export GOBIN=$GOROOT/bin
export PATH=$PATH:$GOBIN
export GOPATH=$HOME/gopath (可選設定)
重新載入 profile 檔案：
source /etc/profile
homebrew
homebrew 是 Mac 系統下面目前使用最多的管理軟體的工具，目前已支援 Go，可以透過命令直接安裝 Go，為了以後方便，應該把 git、mercurial 也安裝上：
- 安裝 homebrew：
/usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"
- 安裝 go：
brew update && brew upgrade
brew install go
brew install git
brew install mercurial //可選安裝
1.2 GOPATH 與工作空間
前面我們在安裝 Go 的時候看到需要設定 GOPATH 變數，Go 從 1.1 版本到 1.7 必須設定這個變數，而且不能和 Go 的安裝目錄一樣，這個目錄用來存放 Go 原始碼、Go 的可執行檔案，以及相應的編譯之後的套件檔案。所以這個目錄下面有三個子目錄：src、bin、pkg。
從 go 1.8 開始，GOPATH 環境變數現在有一個預設值，如果它沒有被設定。它在 Unix 上預設為 $HOME/go，在 Windows 上預設為 %USERPROFILE%/go。
GOPATH 設定
go 命令依賴一個重要的環境變數：$GOPATH。Windows 系統中環境變數的形式為 %GOPATH%，本書主要使用 Unix 形式，Windows 使用者請自行替換。
在類 Unix 環境下大概這樣設定：
export GOPATH=/home/apple/mygo
為了方便，應該建立以上資料夾，並且把上一行加入到 .bashrc 或者 .zshrc 或者自己的 sh 的配置檔案中。
Windows 設定如下，建立一個環境變數名稱叫做 GOPATH：
GOPATH=c:\mygo
GOPATH 允許多個目錄，當有多個目錄時，請注意分隔符：多個目錄的時候 Windows 是分號，Linux 系統是冒號。當有多個 GOPATH 時，預設會將 go get 的內容放在第一個目錄下。
以上 $GOPATH 目錄約定有三個子目錄：
src：存放原始碼（比如：.go .c .h .s 等）pkg：編譯後生成的檔案（比如：.a）bin：編譯後生成的可執行檔案（為了方便，可以把此目錄加入到$PATH變數中，如果有多個 gopath，那麼使用${GOPATH//://bin:}/bin新增所有的 bin 目錄）
以後我所有的例子都是以 mygo 作為我的 gopath 目錄。
程式碼目錄結構規劃
GOPATH 下的 src 目錄就是接下來開發程式的主要目錄，所有的原始碼都是放在這個目錄下面，那麼一般我們的做法就是一個目錄一個專案，例如：$GOPATH/src/mymath 表示 mymath 這個套件或者可執行應用，這個根據 package 是 main 還是其他來決定，main 的話就是可執行應用，其他的話就是套件，這個會在後續詳細介紹 package。
所以當建立應用或者一個程式碼套件時都是在 src 目錄下建立一個資料夾，資料夾名稱一般是程式碼套件名稱，當然也允許多階層目錄，例如在 src 下面建立了目錄 $GOPATH/src/github.com/astaxie/beedb，那麼這個套件路徑就是 "github.com/astaxie/beedb"，套件名稱是最後一個目錄 beedb。
下面我就以 mymath 為例來講述如何編寫套件，執行如下程式碼：
cd $GOPATH/src
mkdir mymath
建立檔案 sqrt.go，內容如下（該檔案與本書倉庫中的 zh-tw/src/1.2/sqrt.go 完全一致）：
// $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
}
這樣我的套件目錄和程式碼已經建立完畢。注意：一般建議 package 的名稱和目錄名保持一致。
編譯應用
上面我們已經建立了自己的套件，如何進行編譯安裝呢？有兩種方式可以進行安裝：
- 只要進入對應的套件目錄，然後執行
go install，就可以安裝了。 - 在任意的目錄執行如下程式碼
go install mymath。
安裝完之後，我們可以進入如下目錄：
cd $GOPATH/pkg/${GOOS}_${GOARCH}
//可以看到如下檔案
mymath.a
這個 .a 檔案是套件，那麼我們如何進行呼叫呢？接下來我們建立一個應用程式來呼叫這個套件。
建立套件 mathapp：
cd $GOPATH/src
mkdir mathapp
cd mathapp
vim main.go
$GOPATH/src/mathapp/main.go 原始碼（該檔案與本書倉庫中的 zh-tw/src/1.2/main.go 完全一致）：
package main
import (
"mymath"
"fmt"
)
func main() {
fmt.Printf("Hello, world. Sqrt(2) = %v\n", mymath.Sqrt(2))
}
可以看到這個的 package 是 main，import 裡面呼叫的套件是 mymath，這個就是相對於 $GOPATH/src 的路徑，如果是多階層目錄，就在 import 裡面引入多階層目錄，如果你有多個 GOPATH，也是一樣，Go 會自動在多個 $GOPATH/src 中尋找。
如何編譯程式呢？進入該應用目錄，然後執行 go build，那麼在該目錄下面會產生一個 mathapp 的可執行檔案：
./mathapp
輸出如下內容：
Hello, world. Sqrt(2) = 1.414213562373095
如何安裝該應用，進入該目錄執行 go install，那麼在 $GOPATH/bin/ 下增加了一個可執行檔案 mathapp。還記得前面我們把 $GOPATH/bin 加到我們的 PATH 裡面了，這樣可以在命令列輸入如下命令就可以執行：
mathapp
也是輸出如下內容：
Hello, world. Sqrt(2) = 1.414213562373095
這裡我們展示如何編譯和安裝一個可執行的應用，以及如何設計我們的目錄結構。
取得遠端套件
go 語言有一個取得遠端套件的工具就是 go get，目前 go get 支援多數開源社群（例如：GitHub、googlecode、bitbucket、Launchpad）：
go get github.com/astaxie/beedb
go get -u參數可以自動更新套件，而且當 go get 的時候會自動取得該套件依賴的其他第三方套件。
透過這個命令可以取得相應的原始碼，對應的開源平臺採用不同的原始碼控制工具，例如 GitHub 採用 git、googlecode 採用 hg，所以要想取得這些原始碼，必須先安裝相應的原始碼控制工具。
透過上面取得的程式碼在我們本地的原始碼相應的程式碼結構如下：
$GOPATH
src
|--github.com
|-astaxie
|-beedb
pkg
|--相應平臺
|-github.com
|--astaxie
|beedb.a
go get 本質上可以理解為首先第一步是透過原始碼工具 clone 程式碼到 src 下面，然後執行 go install。
在程式碼中如何使用遠端套件，很簡單的就是和使用本地套件一樣，只要在開頭 import 相應的路徑就可以：
import "github.com/astaxie/beedb"
程式的整體結構
透過上面建立的我本地的 mygo 的目錄結構如下所示：
bin/
mathapp
pkg/
平臺名/ 如：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
從上面的結構我們可以很清晰的看到，bin 目錄下面存的是編譯之後可執行的檔案，pkg 下面存放的是套件，src 下面儲存的是應用原始碼。
1.3 Go 命令
Go 語言自帶有一套完整的命令列工具，你可以透過在命令列中執行 go 來檢視它們：
圖 1.3 Go 命令顯示詳細的資訊
這些命令對於我們平時編寫的程式碼非常有用，接下來就讓我們了解一些常用的命令。
go build
這個命令主要用於編譯程式碼。在套件的編譯過程中，若有必要，會同時編譯與之相關聯的套件。
- 如果是普通套件，就像我們在 1.2 節中編寫的
mymath套件那樣，當你執行go build之後，它不會產生任何檔案。如果你需要在$GOPATH/pkg下產生相應的檔案，那就得執行go install。 - 如果是
main套件，當你執行go build之後，它就會在當前目錄下產生一個可執行檔案。如果你需要在$GOPATH/bin下產生相應的檔案，需要執行go install，或者使用go build -o 路徑/a.exe。 - 如果某個專案資料夾下有多個檔案，而你只想編譯某個檔案，就可在
go build之後加上檔名，例如go build a.go；go build命令預設會編譯當前目錄下的所有 go 檔案。 - 你也可以指定編譯輸出的檔名。例如 1.2 節中的
mathapp應用，我們可以指定go build -o astaxie.exe，預設情況是你的 package 名（非 main 套件），或者是第一個原始檔的檔名（main 套件）。實際上，package 名指程式碼中 "package" 後使用的名稱，此名稱可以與資料夾名不同。預設產生的可執行檔名是資料夾名。 - go build 會忽略目錄下以 "_" 或 "." 開頭的 go 檔案。
- 如果你的原始碼針對不同的作業系統需要不同的處理，那麼你可以根據不同的作業系統字尾來命名檔案。例如有一個讀取陣列的程式，它對於不同的作業系統可能有如下幾個原始檔：
array_linux.go
array_darwin.go
array_windows.go
array_freebsd.go
go build 的時候會選擇性地編譯以系統名結尾的檔案（Linux、Darwin、Windows、Freebsd）。例如 Linux 系統下面編譯只會選擇 array_linux.go 檔案，其它系統名結尾檔案全部忽略。
參數的介紹：
| 參數 | 說明 |
|---|---|
-o |
指定輸出的檔名，可以帶上路徑，例如 go build -o a/b/c |
-i |
安裝相應的套件，編譯 + go install |
-a |
更新全部已經是最新的套件，但是對標準套件不適用 |
-n |
把需要執行的編譯命令顯示出來，但是不執行，這樣就可以很容易的知道底層是如何執行的 |
-p n |
指定可以並行可執行的編譯數目，預設是 CPU 數目 |
-race |
開啟編譯的時候自動檢測資料競爭的情況，目前只支援 64 位的機器 |
-v |
顯示出來我們正在編譯的套件名 |
-work |
顯示出來編譯時候的臨時資料夾名稱，並且如果已經存在的話就不要刪除 |
-x |
顯示出來執行的命令，其實就是和 -n 的結果類似，只是這個會執行 |
-ccflags 'arg list' |
傳遞參數給 5c, 6c, 8c 呼叫 |
-compiler name |
指定相應的編譯器，gccgo 還是 gc |
-gccgoflags 'arg list' |
傳遞參數給 gccgo 編譯連線呼叫 |
-gcflags 'arg list' |
傳遞參數給 5g, 6g, 8g 呼叫 |
-installsuffix suffix |
為了和預設的安裝套件區別開來，採用這個字首來重新安裝那些依賴的套件，-race 的時候預設已經是 -installsuffix race，大家可以透過 -n 命令來驗證 |
-ldflags 'flag list' |
傳遞參數給 5l, 6l, 8l 呼叫 |
-tags 'tag list' |
設定在編譯的時候可以適配的那些 tag，詳細的 tag 限制參考 Build Constraints |
go clean
這個命令是用來移除當前原始碼套件和關聯原始碼套件裡面編譯產生的檔案。這些檔案包括：
_obj/ 舊的 object 目錄，由 Makefiles 遺留
_test/ 舊的 test 目錄，由 Makefiles 遺留
_testmain.go 舊的 gotest 檔案，由 Makefiles 遺留
test.out 舊的 test 記錄，由 Makefiles 遺留
build.out 舊的 test 記錄，由 Makefiles 遺留
*.[568ao] object 檔案，由 Makefiles 遺留
DIR(.exe) 由 go build 產生
DIR.test(.exe) 由 go test -c 產生
MAINFILE(.exe) 由 go build MAINFILE.go 產生
*.so 由 SWIG 產生
我一般都是利用這個命令清除編譯檔案，然後 GitHub 提交原始碼，在本機測試的時候這些編譯檔案都是和系統相關的，但是對於原始碼管理來說沒必要。
$ go clean -i -n
cd /Users/astaxie/develop/gopath/src/mathapp
rm -f mathapp mathapp.exe mathapp.test mathapp.test.exe app app.exe
rm -f /Users/astaxie/develop/gopath/bin/mathapp
參數介紹：
| 參數 | 說明 |
|---|---|
-i |
清除關聯的安裝的套件和可執行檔案，也就是透過 go install 安裝的檔案 |
-n |
把需要執行的清除命令顯示出來，但是不執行，這樣就可以很容易的知道底層是如何執行的 |
-r |
迴圈的清除在 import 中引入的套件 |
-x |
顯示出來執行的詳細命令，其實就是 -n 列印的執行版本 |
go fmt
有過 C/C++ 經驗的讀者會知道，一些人經常為程式碼採取 K&R 風格還是 ANSI 風格而爭論不休。在 go 中，程式碼則有標準的風格。由於之前已經有的一些習慣或其它的原因我們常將程式碼寫成 ANSI 風格或者其它更合適自己的格式，這將為人們在閱讀別人的程式碼時新增不必要的負擔，所以 go 強制了程式碼格式（比如左大括號必須放在行尾），不按照此格式的程式碼將不能編譯透過。
為了減少浪費在排版上的時間，go 工具集中提供了一個 go fmt 命令，它可以幫你格式化你寫好的程式碼檔案，使你寫程式碼的時候不需要關心格式，你只需要在寫完之後執行 go fmt <檔名>.go，你的程式碼就被修改成了標準格式。
使用 go fmt 命令，其實是呼叫了 gofmt，而且需要參數 -w，否則格式化結果不會寫入檔案。gofmt -w -l src，可以格式化整個專案。所以 go fmt 是 gofmt 的上層一個封裝命令，如果想要更多的自訂格式化，可以參考 gofmt。
gofmt 的參數介紹：
| 參數 | 說明 |
|---|---|
-l |
顯示那些需要格式化的檔案 |
-w |
把改寫後的內容直接寫入到檔案中，而不是作為結果列印到標準輸出 |
-r |
新增形如 "a[b:len(a)] -> a[b:]" 的重寫規則，方便我們做批量替換 |
-s |
簡化檔案中的程式碼 |
-d |
顯示格式化前後的 diff 而不是寫入檔案，預設是 false |
-e |
列印所有的語法錯誤到標準輸出。如果不使用此標記，則只會列印不同行的前 10 個錯誤 |
-cpuprofile |
支援除錯模式，寫入相應的 cpufile 到指定的檔案 |
go get
這個命令是用來動態取得遠端程式碼套件的，目前支援的有 BitBucket、GitHub、Google Code 和 Launchpad。這個命令在內部實際上分成了兩步操作：第一步是下載原始碼套件，第二步是執行 go install。下載原始碼套件的 go 工具會自動根據不同的域名呼叫不同的原始碼工具，對應關係如下：
BitBucket (Mercurial Git)
GitHub (Git)
Google Code Project Hosting (Git, Mercurial, Subversion)
Launchpad (Bazaar)
所以為了 go get 能正常工作，你必須確保安裝了合適的原始碼管理工具，並同時把這些命令加入你的 PATH 中。其實 go get 支援自訂域名的功能，具體參見 go help remote。
參數介紹：
| 參數 | 說明 |
|---|---|
-d |
只下載不安裝 |
-f |
只有在你包含了 -u 參數的時候才有效，不讓 -u 去驗證 import 中的每一個都已經取得了，這對於本地 fork 的套件特別有用 |
-fix |
在取得原始碼之後先執行 fix，然後再去做其他的事情 |
-t |
同時也下載需要為執行測試所需要的套件 |
-u |
強制使用網路去更新套件和它的相依套件 |
-v |
顯示執行的命令 |
go install
這個命令在內部實際上分成了兩步操作：第一步是產生結果檔案（可執行檔案或者 .a 套件），第二步會把編譯好的結果移到 $GOPATH/pkg 或者 $GOPATH/bin。
參數支援 go build 的編譯參數。大家只要記住一個參數 -v 就好了，這個隨時隨地的可以檢視底層的執行資訊。
go test
執行這個命令，會自動讀取原始碼目錄下面名為 *_test.go 的檔案，產生並執行測試用的可執行檔案。輸出的資訊類似：
ok archive/tar 0.011s
FAIL archive/zip 0.022s
ok compress/gzip 0.033s
...
預設的情況下，不需要任何的參數，它會自動把你原始碼套件下面所有 test 檔案測試完畢，當然你也可以帶上參數，詳情請參考 go help testflag。
這裡我介紹幾個常用的參數：
| 參數 | 說明 |
|---|---|
-bench regexp |
執行相應的 benchmarks，例如 -bench=. |
-cover |
開啟測試覆蓋率 |
-run regexp |
只執行 regexp 匹配的函式，例如 -run=Array 那麼就執行包含有 Array 開頭的函式 |
-v |
顯示測試的詳細命令 |
go tool
go tool 下面聚集了很多命令，這裡我們只介紹兩個：fix 和 vet。
go tool fix .用來修復以前老版本的程式碼到新版本，例如 go1 之前老版本的程式碼轉化到 go1，例如 API 的變化。go tool vet directory|files用來分析當前目錄的程式碼是否都是正確的程式碼，例如是不是呼叫 fmt.Printf 裡面的參數不正確，例如函式裡面提前 return 了然後出現了無用程式碼之類的。
go generate
這個命令是從 Go1.4 開始才設計的，用於在編譯前自動化產生某類別程式碼。go generate 和 go build 是完全不一樣的命令，透過分析原始碼中特殊的註釋，然後執行相應的命令。這些命令都是很明確的，沒有任何的依賴在裡面。而且大家在用這個之前心裡面一定要有一個觀念：這個 go generate 是給你用的，不是給使用你這個套件的人用的，主要是方便你自動產生一些程式碼。
這裡我們來舉一個簡單的例子，例如我們經常會使用 yacc 來產生程式碼，那麼我們常用這樣的命令：
go tool yacc -o gopher.go -p parser gopher.y
-o 指定了輸出的檔名，-p 指定了 package 的名稱，這是一個單獨的命令，如果我們想讓 go generate 來觸發這個命令，那麼就可以在當前目錄的任意一個 xxx.go 檔案裡面的任意位置增加一行如下的註釋：
//go:generate go tool yacc -o gopher.go -p parser gopher.y
這裡我們注意了，//go:generate 是沒有任何空格的，這其實就是一個固定的格式，在掃描原始碼檔案的時候就是根據這個來判斷的。
所以我們可以透過如下的命令來產生、編譯、測試。如果 gopher.y 檔案有修改，那麼就重新執行 go generate 重新產生檔案就好：
$ go generate
$ go build
$ go test
godoc
在 Go1.2 版本之前還支援 go doc 命令，但是之後全部移到了 godoc 這個命令下，需要這樣安裝 go get golang.org/x/tools/cmd/godoc。
很多人說 go 不需要任何的第三方文件，例如 chm 手冊之類的，因為它內部就有一個很強大的文件工具。
如何檢視相應 package 的文件呢？
- 例如 builtin 套件，那麼執行
godoc builtin - 如果是 http 套件，那麼執行
godoc net/http - 檢視某一個套件裡面的函式，那麼執行
godoc fmt Printf - 也可以檢視相應的程式碼，執行
godoc -src fmt Printf
透過命令在命令列執行 godoc -http=:埠號，比如 godoc -http=:8080。然後在瀏覽器中開啟 127.0.0.1:8080，你將會看到一個 golang.org 的本地 copy 版本，透過它你可以查詢 pkg 文件等其它內容。如果你設定了 GOPATH，在 pkg 分類下，不但會列出標準套件的文件，還會列出你本地 GOPATH 中所有專案的相關文件。
其它命令
go 還提供了其它很多的工具，例如下面的這些工具：
go version 檢視 go 當前的版本
go env 檢視當前 go 的環境變數
go list 列出當前全部安裝的 package
go run 編譯並執行 Go 程式
以上這些工具還有很多參數沒有一一介紹，使用者可以使用 go help 命令 取得更詳細的幫助資訊。
1.4 Go 開發工具
本節我將介紹幾個開發工具，它們都具有自動化提示、自動化 fmt 功能。因為它們都是跨平臺的，所以安裝步驟之類的都是通用的。
LiteIDE
LiteIDE 是一款專門為 Go 語言開發的跨平臺輕量級整合開發環境（IDE），由 visualfc 編寫。
圖 1.4 LiteIDE 主介面
LiteIDE 主要特點：
- 支援主流作業系統：Windows、Linux、MacOS X
- Go 編譯環境管理和切換：管理和切換多個 Go 編譯環境、支援 Go 語言交叉編譯
- 與 Go 標準一致的專案管理方式：基於 GOPATH 的套件瀏覽器、基於 GOPATH 的編譯系統、基於 GOPATH 的 Api 文件檢索
- Go 語言的編輯支援：
- 類別瀏覽器和大綱顯示
- Gocode（程式碼自動完成工具）的完美支援
- Go 語言文件檢視和 Api 快速檢索
- 程式碼表達式資訊顯示
F1 - 原始碼定義跳轉支援
F2 - Gdb 斷點和除錯支援
- gofmt 自動格式化支援
- 其他特徵：
- 支援多國語言介面顯示
- 完全外掛體系結構
- 支援編輯器配色方案
- 基於 Kate 的語法顯示支援
- 基於全文的單詞自動完成
- 支援鍵盤快捷鍵繫結方案
- Markdown 文件編輯支援：即時預覽和同步顯示、自訂 CSS 顯示、可匯出 HTML 和 PDF 文件、批量轉換/合併為 HTML/PDF 文件
LiteIDE 安裝配置：
首先安裝好 Go 語言環境，然後根據作業系統下載 LiteIDE 對應的壓縮檔案直接解壓即可使用。
編譯環境設定：根據自身系統要求切換和配置 LiteIDE 當前使用的環境變數。
以 Windows 作業系統、64 位 Go 語言為例，工具欄的環境配置中選擇 win64，點「編輯環境」，進入 LiteIDE 編輯 win64.env 檔案：
GOROOT=c:\go
GOBIN=
GOARCH=amd64
GOOS=windows
CGO_ENABLED=1
PATH=%GOBIN%;%GOROOT%\bin;%PATH%
。。。
將其中的 GOROOT=c:\go 修改為當前 Go 安裝路徑，存檔即可。如果有 MinGW64，可以將 c:\MinGW64\bin 加入 PATH 中以便 go 呼叫 gcc 支援 CGO 編譯。
以 Linux 作業系統、64 位 Go 語言為例，工具欄的環境配置中選擇 linux64，點「編輯環境」，進入 LiteIDE 編輯 linux64.env 檔案：
GOROOT=$HOME/go
GOBIN=
GOARCH=amd64
GOOS=linux
CGO_ENABLED=1
PATH=$GOBIN:$GOROOT/bin:$PATH
。。。
將其中的 GOROOT=$HOME/go 修改為當前 Go 安裝路徑，存檔即可。
GOPATH 設定：Go 語言的工具鏈使用 GOPATH 設定，是 Go 語言開發的專案路徑列表，在命令列中輸入（在 LiteIDE 中也可以 Ctrl+, 直接輸入）go help gopath 快速檢視 GOPATH 文件。在 LiteIDE 中可以方便的檢視和設定 GOPATH，透過「選單－檢視－GOPATH」設定，可以檢視系統中已存在的 GOPATH 列表，同時可根據需要新增專案目錄到自訂 GOPATH 列表中。
Sublime Text
這裡將介紹 Sublime Text 3（以下簡稱 Sublime）+ GoSublime + gocode 的組合，那麼為什麼選擇這個組合呢？
- 自動化提示程式碼
- 儲存的時候自動格式化程式碼，讓您編寫的程式碼更加美觀，符合 Go 的標準。
- 支援專案管理
- 支援語法高亮
- Sublime Text 3 可免費使用，只是儲存次數達到一定數量之後就會提示是否購買，點選取消繼續用，和正式註冊版本沒有任何區別。
圖 1.5 sublime 自動化提示介面
圖 1.6 sublime 專案管理介面
接下來就開始講如何安裝。根據自己相應的系統下載相應的版本，然後開啟 Sublime。
- 開啟之後安裝 Package Control：Ctrl+` 開啟命令列，執行如下程式碼（適用於 Sublime Text 3）：
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())
適用於 Sublime Text 2：
import urllib2,os;pf='Package Control.sublime-package';ipp=sublime.installed_packages_path();os.makedirs(ipp)ifnot os.path.exists(ipp)else None;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')
這個時候重啟一下 Sublime，可以發現在選單欄多了一個 Package Control 的節目，說明 Package Control 已經安裝成功了。
圖 1.7 sublime 套件管理
- 安裝完之後就可以安裝 Sublime 的外掛了。需安裝 GoSublime、SidebarEnhancements 和 Go Build，安裝外掛之後記得重啟 Sublime 生效，Ctrl+Shift+p 開啟 Package Control 輸入
pcip（即 "Package Control: Install Package" 的縮寫）。這個時候看左下角顯示正在讀取套件資料，完成之後出現如下介面，輸入 GoSublime，按確定就開始安裝了。同理應用於 SidebarEnhancements 和 Go Build。
圖 1.8 sublime 安裝外掛介面
- 安裝 gocode：
go get -u github.com/nsf/gocode
gocode 將會安裝在預設 $GOBIN。
另外建議安裝 gotests（產生測試程式碼）：先在 sublime 安裝 gotests 外掛，再執行：
go get -u -v github.com/cweill/gotests/...
-
驗證是否安裝成功：你可以開啟 Sublime，開啟 main.go，看看語法是不是高亮了，輸入
import是不是自動化提示了，import "fmt"之後，輸入fmt.是不是自動化提示有函數了。如果已經出現這個提示，那說明你已經安裝完成了，並且完成了自動提示。如果沒有出現這樣的提示，一般就是你的$PATH沒有配置正確。你可以開啟終端，輸入 gocode，是不是能夠正確執行，如果不行就說明$PATH沒有配置正確。（針對 XP）有時候在終端能執行成功，但 sublime 無提示或者編譯解碼錯誤，請安裝 sublime text3 和 convert utf8 外掛試一試。 -
MacOS 下已經設定了 GOPATH、$GOBIN，還是沒有自動提示怎麼辦？請在 sublime 中使用 command + 9，然後輸入 env 檢查 GOPATH、$GOBIN 等變數，如果沒有請採用下面的方法：首先建立下面的連線，然後從 Terminal 中直接啟動 sublime：
ln -s /Applications/Sublime\ Text\ 2.app/Contents/SharedSupport/bin/subl /usr/local/bin/sublime
Visual Studio Code
VSCode 是微軟基於 Electron 和 web 技術建構的開源編輯器，是一款很強大的編輯器。
- 安裝 Visual Studio Code 最新版。
- 安裝 Go 外掛：點選右邊的 Extensions 圖示，搜尋 Go 外掛，在外掛列表中選擇 Go，進行安裝，安裝之後，系統會提示重啟 Visual Studio Code。建議把自動儲存功能開啟，開啟方法為：選擇選單 File，點選 Auto save。
VSCode 程式碼設定可用於 Go 擴充套件。這些都可以在使用者的喜好來設定或工作區設定（.vscode/settings.json）。開啟首選項-使用者設定 settings.json：
{
"go.buildOnSave": true,
"go.lintOnSave": true,
"go.vetOnSave": true,
"go.buildFlags": [],
"go.lintFlags": [],
"go.vetFlags": [],
"go.coverOnSave": false,
"go.useCodeSnippetsOnFunctionSuggest": false,
"go.formatOnSave": true,
//goimports
"go.formatTool": "goreturns",
"go.goroot": "", //你的 Goroot
"go.gopath": "", //你的 Gopath
}
接著安裝相依套件支援（網路不穩定，請直接到 GitHub Golang 下載再移動到相關目錄）：
go get -u -v github.com/nsf/gocode
go get -u -v github.com/rogpeppe/godef
go get -u -v github.com/zmb3/gogetdoc
go get -u -v github.com/golang/lint/golint
go get -u -v github.com/lukehoban/go-outline
go get -u -v sourcegraph.com/sqs/goreturns
go get -u -v golang.org/x/tools/cmd/gorename
go get -u -v github.com/tpng/gopkgs
go get -u -v github.com/newhook/go-symbols
go get -u -v golang.org/x/tools/cmd/guru
go get -u -v github.com/cweill/gotests/...
VSCode 還有一項很強大的功能就是斷點除錯，結合 delve 可以很好的進行 Go 程式碼除錯：
go get -v -u github.com/peterh/liner github.com/derekparker/delve/cmd/dlv
brew install go-delve/delve/delve (mac 可選)
如果有問題再來一遍：
go get -v -u github.com/peterh/liner github.com/derekparker/delve/cmd/dlv
注意：修改 "dlv-cert" 證書，選擇「顯示簡介」->「信任」->「程式碼簽名」修改為：始終信任。
開啟首選項-工作區設定，配置 launch.json：
{
"version": "0.2.0",
"configurations": [
{
"name": "main.go",
"type": "go",
"request": "launch",
"mode": "debug",
"remotePath": "",
"port": 2345,
"host": "127.0.0.1",
"program": "${workspaceRoot}", //工作空間路徑
"env": {},
"args": [],
"showLog": true
}
]
}
Atom
Atom 是 GitHub 基於 Electron 和 web 技術建構的開源編輯器，是一款很漂亮強大的編輯器，缺點是速度比較慢。
首先要先安裝 Atom，然後安裝 go-plus 外掛。go-plus 是 Atom 上面的一款開源的 go 語言開發環境的外掛，它需要依賴下面的 go 語言工具：
1. autocomplete-go ：gocode 的程式碼自動提示
2. gofmt ：使用 gofmt, goimports, goreturns
3. builder-go ：go install 和 go test，驗證程式碼，給出建議
4. gometalinter-linter ：golint, vet, gotype 的檢查
5. navigator-godef ：godef
6. tester-go ：go test
7. gorename ：rename
在 Atom 中的 Preference 中可以找到 install 選單，輸入 go-plus，然後點選安裝（install），就會開始安裝 go-plus。go-plus 外掛會自動安裝對應的依賴外掛，如果沒有安裝對應的 go 的類別函式庫會自動執行 go get 安裝。
GoLand
GoLand 是 JetBrains 公司推出的 Go 語言整合開發環境，是 IDEA Go 外掛的強化版。GoLand 同樣基於 IntelliJ 平臺開發，支援 JetBrains 的外掛體系。
Vim
Vim 是從 vi 發展出來的一個文字編輯器，程式碼自動完成、編譯及錯誤跳轉等方便程式設計的功能特別豐富，在程式設計師中被廣泛使用。vim-go 是 vim 上面的一款開源的 go 語言使用最為廣泛開發環境的外掛。
vim 的外掛管理主要有 Pathogen 與 Vundle，但是其作用的方面不同。pathogen 是為了解決每一個外掛安裝後文件分散到多個目錄不好管理而存在的；vundle 是為了解決自動搜尋及下載外掛而存在的。這兩個外掛可同時使用。
- 安裝 Vundle：
mkdir ~/.vim/bundle
git clone https://github.com/gmarik/Vundle.vim.git ~/.vim/bundle/Vundle.vim
修改 .vimrc，將 Vundle 的相關配置置在最開始處：
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
- 安裝 Vim-go：修改 ~/.vimrc，在 vundle#begin 和 vundle#end 間增加一行：
Plugin 'fatih/vim-go'
在 Vim 內執行 :PluginInstall。
- 安裝 YCM（YouCompleteMe）進行自動完成：在 ~/.vimrc 中新增一行：
Plugin 'Valloric/YouCompleteMe'
在 Vim 內執行 :PluginInstall。
圖 1.9 VIM 編輯器自動化提示 Go 介面
接著我們繼續配置 vim：
- 配置 vim 高亮顯示：
cp -r $GOROOT/misc/vim/* ~/.vim/
- 在 ~/.vimrc 檔案中增加語法高亮顯示：
filetype plugin indent on
syntax on
- 安裝 Gocode：
go get -u github.com/nsf/gocode
gocode 預設安裝到 $GOPATH/bin 下面。
- 配置 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"
gocode set 裡面的兩個參數的含意說明：
propose-builtins：是否自動提示 Go 的內建函式、型別和常數，預設為 false，不提示。
lib-path：預設情況下，gocode 只會搜尋$GOPATH/pkg/$GOOS_$GOARCH和$GOROOT/pkg/$GOOS_$GOARCH目錄下的套件，當然這個設定就是可以設定我們額外的 lib 能訪問的路徑。
- 恭喜你，安裝完成，你現在可以使用
:e main.go體驗一下開發 Go 的樂趣。
Emacs
Emacs 傳說中的神器，她不僅僅是一個編輯器，它是一個整合環境，或可稱它為整合開發環境，這些功能如讓使用者置身於全功能的作業系統中。
圖 1.10 Emacs 編輯 Go 主介面
- 配置 Emacs 高亮顯示：
cp $GOROOT/misc/emacs/* ~/.emacs.d/
- 安裝 Gocode：
go get -u github.com/nsf/gocode
gocode 預設安裝到 $GOBIN 裡面下面。
- 配置 Gocode：
cd $GOPATH/src/github.com/nsf/gocode/emacs
cp go-autocomplete.el ~/.emacs.d/
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"
- 需要安裝 Auto Completion：下載 AutoComplete 並解壓：
make install DIR=$HOME/.emacs.d/auto-complete
配置 ~/.emacs 檔案：
;;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)
- 配置 .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"))
- 恭喜你，你現在可以體驗在神器中開發 Go 的樂趣。預設 speedbar 是關閉的，如果開啟需要把
;; (speedbar 1)前面的註釋去掉，或者也可以透過M-x speedbar手動開啟。
Eclipse
Eclipse 也是非常常用的開發利器，以下介紹如何使用 Eclipse 來編寫 Go 程式。
圖 1.11 Eclipse 編輯 Go 的主介面
- 首先下載並安裝好 Eclipse。
- 下載 goclipse 外掛。
- 下載 gocode，用於 go 的程式碼自動完成提示。在 windows 下要安裝 git，通常用 msysgit。再在 cmd 下安裝：
go get -u github.com/nsf/gocode
也可以下載程式碼，直接用 go build 來編譯，會產生 gocode.exe。
- 下載 MinGW 並按要求裝好。
- 配置外掛：Windows->Reference->Go。
(1). 配置 Go 的編譯器：
圖 1.12 設定 Go 的一些基礎資訊
(2). 配置 Gocode（可選，程式碼自動完成），設定 Gocode 路徑為之前產生的 gocode.exe 檔案：
圖 1.13 設定 gocode 資訊
(3). 配置 GDB（可選，做除錯用），設定 GDB 路徑為 MinGW 安裝目錄下的 gdb.exe 檔案：
圖 1.14 設定 GDB 資訊
- 測試是否成功：建立一個 go 工程，再建立一個 hello.go。如下圖：
圖 1.15 建立專案編輯檔案
除錯如下（要在 console 中用輸入命令來除錯）：
圖 1.16 除錯 Go 程式
IntelliJ IDEA
熟悉 Java 的讀者應該對於 idea 不陌生，idea 是透過一個外掛來支援 go 語言的高亮語法、程式碼提示和重構實現。
- 先下載 idea，idea 支援多平臺：win、mac、linux，如果有錢就買個正式版，如果不行就使用社群免費版，對於只是開發 Go 語言來說免費版足夠用了。
- 安裝 Go 外掛，點選選單 File 中的 Setting，找到 Plugins，點選 Browser repo 按鈕。
- 這時候會看見很多外掛，搜尋找到 Golang，雙擊，download and install。等到 golang 那一行後面出現 Downloaded 標誌後，點 OK。
然後點 Apply。這時候 IDE 會要求你重啟。
- 重啟完畢後，建立新專案會發現已經可以建立 golang 專案了：
下一步，會要求你輸入 go sdk 的位置，一般都安裝在 C:\Go，linux 和 mac 根據自己的安裝目錄設定，選中目錄確定，就可以了。
1.5 小結
這一章中我們主要介紹了如何安裝 Go，Go 可以透過三種方式安裝：原始碼安裝、標準套件安裝、第三方工具安裝，安裝之後我們需要配置我們的開發環境，然後介紹了如何配置本地的 $GOPATH，透過設定 $GOPATH 之後讀者就可以建立專案，接著介紹了如何來進行專案編譯、應用安裝等問題，這些需要用到很多 Go 命令，所以接著就介紹了一些 Go 的常用命令工具，包括編譯、安裝、格式化、測試等命令，最後介紹了 Go 的開發工具，目前有很多 Go 的開發工具：LiteIDE、Sublime、VSCode、Atom、GoLand、VIM、Emacs、Eclipse、Idea 等工具，讀者可以根據自己熟悉的工具進行配置，希望能夠透過方便的工具快速的開發 Go 應用。
在本倉庫中，本章的範例程式碼收錄於 zh-tw/src/1.2/（sqrt.go 與 main.go），其中 Sqrt 函式採用牛頓迭代法實現平方根計算並由 main.go 呼叫驗證，可作為搭建 GOPATH 後的第一個練習。下一章「Go 語言基礎」請參見 zh-tw/02.0.md。