轉眼加入螞蟻已經三個多月，這期間主要維護一 Go 寫的服務器。雖然用的時間不算長，但還是積累了一些心得體會，這里總結歸納一下，供想嘗試 Go 的同學參考。
本文會依次介紹 Go 的設計理念、開發環境、語言特性。本文在談及語言特性的時也會討論一些 Go 的不足之處，旨在給讀者提供一個全面的視角。
簡介
一般來說，編程語言都會有一個 slogan 來表示它們的特點。比如提到 Clojure，一般會想到這么幾個詞匯：lisp on JVM、immutable、persistent；Java 的話我能想到的是企業級開發、中規中矩。對於 Go ，官網介紹到：
Go is an open source programming language that makes it easy to build simple, reliable, and efficient software.
提取幾個關鍵詞：open（開放）、simple（簡潔）、reliable（可靠）、efficient（高效）。這也可以說是它的設計目標。除了上面這些口號外，初學者還需要知道 Go 是一門命令式的靜態語言（是指在編譯時檢查變量類型是否匹配），與 Java 屬於同一類別。
| Imperative | Functional | |
|---|---|---|
| Dynamic | Python/Ruby/Javascript | Lisp/Scheme/Clojure |
| Static | Java/C++/Rust/Go | OCaml/Scala/Haskell |
由於 Hello World 太簡潔，不具備展示 Go 的特點，所以下面展示一段訪問 httpbin，打印 response 的完整代碼。
package main
import (
"fmt"
"io/ioutil"
"net/http"
)
func main() {
// http://httpbin.org/#/Anything/get_anything
r, err := http.Get("http://httpbin.org/anything?hello=world")
if err != nil {
panic(err)
}
defer r.Body.Close()
body, err := ioutil.ReadAll(r.Body)
if err != nil {
panic(err)
}
fmt.Printf("body = %s\n", string(body))
}
上面的代碼片段包括了 Go 的主要組成：包的聲明與引用、函數定義、錯誤處理、流程控制、defer。
開發環境
通過上面的代碼片段，可以看出 Go 語言 simple（簡潔）的特點，所以找一個最熟悉的文本編輯器，一般通過配置插件，都可以達到快速開發的目的。很久之前我就已經把所有文本編輯放到 Emacs 上，這里介紹下我的配置。
除了 go-mode 這個 major mode，為了配置像 源碼跳轉、API 自動補全、查看函數文檔等現代 IDE 必備功能，需要安裝以下命令
go get -u github.com/rogpeppe/godef
go get -u github.com/stamblerre/gocode # for go-eldoc/company-go
go get -u golang.org/x/tools/cmd/goimports
go get -u github.com/kisielk/errcheck
go get -u github.com/lukehoban/go-outline # for go-imenu
然后再按照 setup-go.el 里的配置，就擁有了一個功能完備的開發環境。
不像 Java 語言需要運行時，Go 支持直接將整個項目 build 成一個二進制文件，方便部署，而支持交叉編譯，不過在開發時，直接 go run XXX.go 更為便利，截止到 Go 1.12，還不支持 REPL，官方有提供在線版的 Playground 供分享、調試代碼。
我個人的習慣是建一個 go-app 項目，每個要測試的邏輯放到一個 test 里面去，這樣就可以使用 go test -v -run XXX 來運行。之所以不選用 go run，是因為一個目錄下只允許有一個 main 的 package，多個 IDE 會提示錯誤。
數據類型
一般編程語言，數據類型分為基本的與復雜的兩類。
基本的一般比較簡單，表示一個值，Go 里面就有 string, bool, int8, int32(rune), int64, float32, float64, byte(uint8) 等基本類型
復雜類型一般表示多個值或具有某些高級用法，Go 里面有：
- pointer Go 里只支持取地址
&與間接訪問*操作符，不支持對指針進行算術操作 - struct 類似於 C 語言里面的 struct，Java 里面的對象
- function 函數在 Go 里是一等成員
- array 大小固定的數組
- slice 動態的數組
- map 哈希表
- chan 用於在多個 goroutine 內通信
- interface 類似於 Java 里面的接口，但是與 Java 里的用法不一樣
下面將重點介紹 Go 里特有或用途最廣的數據類型。
struct/interface
Go 里面的 struct 類似於 Java 里面的 Object，但是並沒有繼承，僅僅是對數據的一層包裝（抽象）。相對於其他復雜類型，struct 是值類型，也就是說作為函數參數或返回值時，會拷貝一份值，值類型分配在 stack 上，與之相對的引用類型，分配在 heap 上。
初學者一般會有這樣的誤區，認為傳值比傳引用要慢，實則不然，具體涉及到 Go 如何管理內存，這里暫不詳述，感興趣到可以閱讀：
BenchmarkByPointer-8 20000000 86.7 ns/op
BenchmarkByValue-8 50000000 31.9 ns/op
所以一般推薦直接使用值類型的 struct，如果確認這是瓶頸了，可以再嘗試改為引用類型（&struct）
如果說 struct 是對狀態的封裝，那么 interface 就是對行為的封裝，相當於對外的契約（contract）。而且 Go 里面有這么一條最佳實踐
Accept interfaces, return concrete structs. （函數的參數盡量為 interface，返回值為 struct）
這樣的好處也很明顯，作為類庫的設計者，對其要求的參數盡量寬松，方便使用，返回具體值方便后續的操作處理。一個極端的情況，可以用 interface{} 表示任意類型的參數，因為這個接口里面沒有任何行為，所以所有類型都是符合的。又由於 Go 里面不支持范型，所以interface{}是唯一的解決手段。
相比較 Java 這類面向對象的語言，接口需要顯式（explicit）繼承（使用 implements 關鍵字），而在 Go 里面是隱式的（implicit），新手往往需要一段時間來體會這一做法的巧妙，這里舉一例子來說明：
Go 的 IO 操作涉及到兩個基礎類型：Writer/Reader ，其定義如下：
type Reader interface {
Read(p []byte) (n int, err error)
}
type Writer interface {
Write(p []byte) (n int, err error)
}
自定義類型如果實現了這兩個方法，那么就實現了這兩個接口，下面的 Example 就是這么一個例子：
type Example struct {
}
func (e *Example) Write(p byte[]) (n int, err error) {
}
func (e *Example) Read(p byte[]) (n int, err error) {
}
由於隱式繼承過於靈活，在 Go 里面可能會看到如下代碼：
var _ blob.Fetcher = (*CachingFetcher)(nil)
這是通過將 nil 強轉為 *CachingFetcher，然后在賦值時，指定 blob.Fetcher 類型，保證 *CachingFetcher 實現了 blob.Fetcher 接口。
作為接口的設計者，如果想實現者顯式繼承一個接口，可以在接口中額外加一個方法。比如：
type Fooer interface {
Foo()
ImplementsFooer()
}
這樣，實現者必須實現 ImplementsFooer 方法才能說是繼承了 Fooer 接口。所以說隱式繼承有利有弊，需要開發者自己去把握。
map/slice
Map/Slice 是 Go 里面最常用的兩類數據結構，屬於引用類型。在語言 runtime 層面實現，僅有的兩個支持范型的結構。
Slice 是長度不固定的數組，類似於 Java 里面的 List。
// map 通過 make 進行初始化
// 如果提前知道 m 大小，建議通過 make 的第二個參數指定，避免后期的數據移動、復制
m := make(map[string]string, 10)
// 賦值
m["zhangsan"] = "teacher"
// 讀取指定值，如不存在，返回其類型的默認值
v := m["zhangsan"]
// 判斷指定 key 知否在 map 內
v, ok := m["zhangsan"]
// slice 通過 make 進行初始化
s := make([]int)
// 增加元素
s = append(s, 1)
// 也可以通過 make 第二個參數指定大小
s := make([]int, 10)
for i:=0;i<10;i++ {
s[i] = i
}
// 也可以使用三個參數的 make 初始化 slice
// 第二個參數為初始化大小，第三個為最大容量
// 需要通過 append 增加元素
s := make([]int, 0 ,10)
s = append(s, 1)
chan/goroutine
作為一門新語言，Goroutine 是 Go 借鑒 CSP 模型提供的並發解決方案，相比傳統 OS 級別的線程，它有以下特點：
- 輕量，完全在用戶態調度（不涉及OS狀態直接的轉化）
- 資源占用少，啟動快
- 目前，Goroutine 調度器不保證公平（fairness），搶占（pre-emption）也支持的非常有限，一個空的
for{}可能會一直不被調度出去。
一般可以使用 chan/select 來進行 Goroutine 之間的調度。chan 類似於 Java 里面的 BlockingQueue，且能保證 Goroutine-safe，也就是說多個 Goroutine 並發進行讀寫是安全的。
chan 里面的元素默認為1個，也可以在創建時指定緩沖區大小，讀寫支持堵塞、非堵塞兩種模式，關閉一個 chan 后，再寫數據時會 panic。
// chan 與 slice/map 一樣，使用 make 初始化
ch := make(chan int, 2)
// blocking read
v := <-ch
// nonblocking read, 需要注意 default 分支不能省略，否則會堵塞住
select {
case v:=<-ch:
default:
}
// blocking write
ch <- v
// nonblocking write
select {
case ch<-v:
default:
}
chan 作為 Go 內一重要數據類型，看似簡單，實則暗藏玄妙，用時需要多加留意，這里不再展開敘述，后面打算專門寫一篇文章去介紹，感興趣的可以閱讀下面的文章：
- Curious Channels
- Prosumer 基於 buffered chan 實現的生產者消費者，核心點在於關閉 chan 只意味着生產者不能再發送數據，消費者無法獲知 chan 是否已經關閉，需要用其他方式去通信。
語言特性
Go 相比 Java 來說，語言特性真的是少太多。推薦 Learn X in Y minutes 這個網站，快速瀏覽一遍即可掌握 Go 的語法。Go 的簡潔程度覺得和 JavaScript 差不多，但卻是一門靜態語言，具有強類型，這兩點又讓它區別於一般的腳本語言。
代碼風格
Go 遵循約定大於配置（convention over configuratio）的設計理念，比如在構建一個項目時，直接 go build 一個命令就搞定了，不需要什么 Makefile、pom.xml 等配置文件。下面介紹幾個常用的約定：
- 一個包內函數、變量的可見性是通過首字母大小寫確定的。大寫表示可見。
- 一般
{放在行末，否則 Go 編輯器會自動插入一個逗號，導致編譯錯誤 - 一個文件夾內，只能定義一個包
- 變量、函數命名盡量簡短，標准庫里面經常可以看到一個字母的變量
由於以上種種約定，在看別人代碼時很舒服，有種 Python 的感覺。另外建議在編輯器中配置 goimports 來自動化格式代碼。
錯誤處理
Go 內沒有 try catch 機制，而且已經明確拒絕了這個 Proposal，而是通過返回值的方式來處理。
f, err := os.Open(filename)
if err != nil {
return …, err // zero values for other results, if any
}
Go 的函數一般通過返回多值的方式來傳遞 error（且一般是第二個位置），實際項目中一般使用 pkg/errors 去處理、包裝 err。
依賴管理
Go 的依賴管理，相比其他語言較弱。
在 Go 1.11 正式引入的 modules 之前，項目必須放在 $GOPATH/src/xxx.com/username/project 內，這樣 Go 才能去正確解析項目依賴，而且 Go 社區沒有統一的包托管平台，不像 Java 中 maven 一樣有中央倉庫的概念，而是直接引用 Git 的庫地址，所以在 Go 里，一般會使用 github.com/username/package 的方式來表示。
go get 是下載依賴但命令，但一個個去 get 庫不僅僅繁碎，而且無法固化依賴版本信息，所以 dep 應運而生，添加新依賴后，直接運行 dep ensure 就可以全部下下來，而且會把當前依賴的 commit id 記錄到 Gopkg.lock 里面，這就能解決版本不固定的問題。
但 modules 才是正路，且在 1.13 版本會默認開啟，所以這里只介紹它的用法。
# 首先導出環境變量
export GO111MODULE=on
# 在一個空文件夾執行 init，創建一個名為 hello 的項目
go mod init hello
# 這時會在當前文件夾內創建 go.mod ，內容為
module hello
go 1.12
# 之后就可以編寫 Go 文件，添加依賴后，執行 go run/
# 依賴會自動下載，並記錄在 go.mod 內，版本信息記錄在 go.sum
更多用法可以參考官方示例，這里只是想說明目前 Go 內的工具鏈大部分已經支持，但是 godoc 還不支持。
GC
Go 也是具有垃圾回收的語言，但相比於 JVM，Go GC 可能顯得及其簡單，從 Go 1.10 開始，Go GC 采用 Concurrent Mark & Sweep (CMS) 算法，且不具有分代、compact 特性。讀者如果對相關名詞不熟悉，可以閱讀：
而且 Go 里面調整 GC 的參數只有一個 GOGC，表示下面的比率
新分配對象 / 上次 GC 后剩余對象
默認 100，表示新分配對象達到之前剩余對象大小時，進行 GC。GOGC=off 可以關閉 GC，SetGCPercent 可以動態修改這個比率。
在啟動一個 Go 程序時，可以設置 GODEBUG=gctrace=1 來打印 GC 日志，日志具體含義可參考 pkg/runtime，這里不再贅述。對調試感興趣的可以閱讀：
總結
Go 最初由 Google 在 2007 為解決軟件復雜度、提升開發效率的一試驗品，到如今不過十二年，但無疑已經家喻戶曉，成為雲時代的首選。其面向接口的特有編程方式，也非常靈活，兼具動態語言的簡潔與靜態語言的高效，推薦大家嘗試一下。Go Go Go!
