關于Go語言，你可能會討厭的五件事
關于 Go 語言，你有什么要吐槽的？
近年來，Go 從新出現(xiàn)的編程語言中脫穎而出。不過要把 Go 稱為“新晉者”似乎并不合適，因為谷歌早在 2009 年就推出了 Go，并于 2012 年發(fā)布了***個最終版（Go 1.0）。到現(xiàn)在為止，Go 已經發(fā)展到了 1.10 版本，這個版本令人印象深刻，而且還在不斷添加新的特性。
為什么它被稱為 eGOtistic（自大狂）……
大家都知道，Go 在實現(xiàn)或語法方面喜歡“我行我素”。在英語中，這種情況被描述為“自以為是”。很多來自其他編程語言的概念在 Go 中并不存在，或者即使存在，它們的行為也變得“面目全非”。后一種情況可能會導致意想不到的錯誤，甚至讓開發(fā)人員感到疑惑。
嚴格的 Go 語法通常會讓開發(fā)人員感到疲倦。Go 編譯器不允許出現(xiàn)未使用的導入和變量，并竭盡所能將它們攔截下來，甚至讓花括號另起一行都不行。Go 強制使用相對固定且?guī)缀踅y(tǒng)一的編程風格。只要 Go 編譯器不喜歡某些東西，到***都變成了編譯錯誤。
Go 提供了非常嚴格的類型安全。因為太過嚴格，我們甚至可以通過它來實現(xiàn)一些特殊效果和編程錯誤，其中一些我們稍后會在文中討論。不過，我們很少有必要在 Go 中顯式地聲明類型，因為類型通常可以從賦值中獲得，也就是類型推斷。
我不是要提供問答！
一年多以前，我開始在工作中大量使用 Go。Go 算不上是我最喜歡的編程語言，但我承認，Go 在提升開發(fā)效率方面起到了一定作用。事實上，我已經使用 Go 完成了幾個小項目，主要是一些嵌入式應用。Go Toolchain 的跨平臺編譯功能（編譯后可用于其他操作系統(tǒng)或 CPU 平臺）非常棒，已經***于它的競爭對手。
現(xiàn)在讓我們來看看 Go 的一些比較特別的特性。入門 Go 其實很容易，可能只需要一個周末來了解它的基礎知識。但當你開始用 Go 做一些更復雜的事情時，各種奇奇怪怪的事件開始浮出水面。
有時候，這些特性非常奇怪，谷歌為此提供了問題解答，用于解釋類似“為什么 X 的行為是這樣或者那樣的”這類問題。Go 在很多方面都表現(xiàn)得與其他語言不太一樣，感覺好像程序員在某個時候一定會被某些陷阱絆倒一樣。gopher Slack 頻道已經證實了這種情況的存在，其中就有這樣的描述：“現(xiàn)在你真的應該好好了解一下 Go 了，因為每個開發(fā)人員在他們的 Go 職業(yè)生涯中都會問到這個問題”。通常情況下，我們的直覺與 Go 的特性并不相符。例如，在谷歌的 C 語言變種中，公開類型、函數(shù)、常量等都以大寫字母作為開頭來表示它們是公開的，而標識符開頭的小寫字母表示它們是私有的。
盡管如此，有關 Go 的很多決策都是在郵件列表或提案文件中經過了長時間的討論，因此還是得到了肯定。然而，討論所使用的用例都非常特殊，以至于很多開發(fā)人員仍然不清楚這與他們要解決的問題究竟有什么關系。
我個人最喜歡的部分是 Go 沒有提供可重入鎖，即同一線程或 Goroutine（Coroutine 或 Green Thread 的變體）可遞歸獲取的鎖。如果不通過 hack 的方式就無法自行實現(xiàn)這樣的功能，因為線程在 Go 中不可用，而 Goroutine 也并沒有提供可用于遞歸識別相同 Coroutine 的標識符。
在這篇文章中，我想介紹 Go 的五個特性及其語法，這些特性都很隱晦。
1. 瘋狂的影子
讓我們從最簡單的事情開始：每個優(yōu)秀的開發(fā)人員都聽說過 Shadowing，它通常會發(fā)生在變量的上下文中。下面是只包含兩個作用域的簡單示例：
- foo("foo")
- func foo(var1 string) {
- for {
- var1 := "bar"
- fmt.Println(var1)
- break
- }
我們通過:=賦值符號創(chuàng)建了一個變量，并通過所賦的值（類型引用）來推斷變量的類型。在這里，它是一個字符串。因此，我們在內部作用域（for 循環(huán)）中創(chuàng)建了一個與函數(shù)參數(shù)名稱相同的變量。我們覆蓋（shadow）了輸入參數(shù)，并輸出“bar”。
到現(xiàn)在為止還挺好。但是，在 Go 中，需要為其他包的屬性指定包名（即結構體、方法、函數(shù)等），這個可以在提供 Println 函數(shù)的 fmt 包中看到。
所以我們對之前的例子稍微做一下重構：
- foo("foo")
- func foo(var1 string) {
- for {
- fmt := "bar"
- fmt.Println(var1)
- break
- }
- }
這一次，我們遇到了編譯錯誤，我們試圖在一個字符串上調用 Println 函數(shù)。但這種情況并不總是這么明顯。當代碼突然停止編譯時，即使只有幾行代碼也會給我們帶來“驚喜”。
如果結構體發(fā)生重疊，就會很麻煩。讓我們舉一個奇怪的例子：
- type task struct {
- }
- func main() {
- task := &task{}
- }
我們創(chuàng)建了一個叫作 task 的結構體和它的一個實例。我們有意使用小寫 task 作為結構體的名稱，因為如前所述，Go 使用***個字母來確定可見性，所以 task 在這里是私有的。
到目前為止，它看起來很不錯，Go 編譯了我們創(chuàng)建的 task。但是，當我們嘗試添加另一行代碼時，情況突然發(fā)生了變化。
- type task struct {
- }
- func main() {
- task := &task{}
- task = &task{}
- }
現(xiàn)在無法通過編譯，并顯示 task 不是一個類型。此時，Go 分不清類型和變量之間的區(qū)別。也許有人會說，在 JavaScript 中，變量 task 可以是對類型的引用，但這在 Go 中是不可能的，因為類型不可以作為值賦給變量。
現(xiàn)在的問題是：這算不算是悲劇？一般來說不算，但它卻經常在我沒有意識到的情況下發(fā)生。后面可能還會有一些代碼嘗試訪問相同名稱的結構體或包，而每次都需要花幾分鐘時間才能找到問題所在。
說到類型問題，讓我們看看另外一個例子。
2. 類型還是無類型，這是個問題！
我們已經知道如何創(chuàng)建結構體和函數(shù)。有時候，我們會偶爾“重命名”一下類型，比如：type handle int ，這將創(chuàng)建一個叫作 handle 的類型，它的行為類似 int。通常，這個特性被稱為類型別名。你可能也想到過這個特性，但不是在 Go 中。不過從 Go 1.9 開始，已經完全支持這個特性了。
讓我們看看可以用 Go 做哪些好玩的事情：
- type handle int
- func main() {
- var var1 int = 1
- var var2 handle = 2
- types(var1)
- types(var2)
- }
- func types(val interface{}) {
- switch v := val.(type) {
- case int:
- fmt.Println(fmt.Sprintf("I am an int: %d", v))
- case handle:
- fmt.Println(fmt.Sprintf("I am an handle: %d", v))
- }
- }
- I am an int: 1
- I am an handle: 2
在這個例子中，我們使用了 Go 的幾個非常酷的特性。switch-type-case 語句是一種類型模式匹配，類似于 Java 的 instanceof 或 JavaScript 的 typeof。我們把 interface{}與 Java 中的 Object 等同起來，因為它是一個空的接口，每個 Go 類都會自動實現(xiàn)它。
有趣的是，Java 開發(fā)人員希望handle也是一個int，這樣就會匹配到***個 case。但事實并非如此，因為面向對象中的類型繼承在 Go 中并不適用。
另一種可能的情況是，handle 是 int 的別名，就像 C/C++ 中的typedef一樣，但事實也并非如此。Go 編譯器會創(chuàng)建一個新的 TypeSpec，可以說是原始類型的克隆。因此，它們之間是完全獨立的。
不過，從 Go 1.9 開始，支持真正的類型別名。下面的例子只稍微做了點修改。
- type handle = int
- func main() {
- var var1 int = 1
- var var2 handle = 2
- types(var1)
- types(var2)
- }
- func types(val interface{}) {
- switch v := val.(type) {
- case int:
- fmt.Println(fmt.Sprintf("I am an int: %d", v))
- }
- switch v := val.(type) {
- case handle:
- fmt.Println(fmt.Sprintf("I am an handle: %d", v))
- }
- }
- I am an int: 1
- I am an int: 2
- I am an handle: 1
- I am an handle: 2
你有沒有注意到它們的區(qū)別？實際上，我們現(xiàn)在不使用type handle int，而是使用type handle=int為int創(chuàng)建一個額外的名稱（別名），即handle。這意味著 switch 語句也必須做出修改，因為這個時候，int 和 handle 對于編譯器來說是完全相同的類型，除非你有另一個 double case，否則會出現(xiàn)編譯錯誤。由于類型別名實在 Go 1.9 中引入的，很多人會認為上述的類型克隆就是類別別名。
為了方便演示，讓我們定義一個名為Callable的類型，它由一個沒有參數(shù)和返回值的簡單函數(shù)組成。
type Callable func()
現(xiàn)在創(chuàng)建一個相應的函數(shù)。
- func main() {
- myCallable := func() {
- fmt.Println("callable")
- }
- test(myCallable)
- }
- func test(callable Callable) {
- callable()
- }
看，很簡單。由于 Go 的類型推斷機制，編譯器自動識別出myCallable應該對應Callable的函數(shù)簽名。編譯器因此能夠隱式地將myCallable轉換為Callable。隨后，myCallable被傳遞給test函數(shù)。這是執(zhí)行隱式轉換的少數(shù)例外之一，通常情況下，所有形式的轉換必須全部明確地指出。
現(xiàn)在我們已經到了不得不使用Reflection的地步。與其他語言一樣，Reflection提供了在運行時分析或改變行為的能力。類型信息通常被用于根據(jù)值的數(shù)據(jù)類型來改變運行時行為。
- type Callable func()
- func main() {
- callable1 := func() {
- fmt.Println("callable1")
- }
- var callable2 Callable
- callable2 = func() {
- fmt.Println("callable2")
- }
- test(callable1)
- test(callable2)
- }
- func test(val interface{}) {
- switch v := val.(type) {
- case func():
- v()
- default:
- fmt.Println("wrong type")
- }
- }
- callable1
- wrong type
callable1現(xiàn)在是函數(shù)類型func()，而callable2被顯式聲明為Callable。 Callable是一個單獨的TypeSpec，因此與func()的類型不一樣。這兩種情況現(xiàn)在都必須由我們的Reflection處理程序單獨攔截處理。不過這些問題可以通過在 Go 1.9 中引入的類型別名來解決。
type Callable=func()
3. 懶惰是囊地鼠的天性！
Go 語言萌萌噠的 logo 囊地鼠生性懶散，選這個 logo 也是有一定的代表意義的。
我最喜歡的 Go 特性之一是惰性求值（Lazy Evaluation），即延遲執(zhí)行代碼。自從 Java 推出 Stream API 以來，Java 開發(fā)人員對該特性也所了解。
我們來看看下面的代碼片段：
- func main() {
- functions := make([]func(), 3)
- for i := 0; i < 3; i++ {
- functions[i] = func() {
- fmt.Println(fmt.Sprintf("iterator value: %d", i))
- }
- }
- functions[0]()
- functions[1]()
- functions[2]()
- }
這里有一個包含三個元素的數(shù)組、一個循環(huán)和閉包，而結果會是什么？
- iterator value: 3
- iterator value: 3
- iterator value: 3
我們會認為是 0,1,2，但實際上卻是 3,3,3。沒錯！
在其他編程語言（如 Java）中，在創(chuàng)建閉包時會捕獲變量的值，而 Go 僅捕獲指向變量本身的指針。問題是，在迭代期間，變量的值不斷變化。循環(huán)完成后，我們執(zhí)行閉包，只看到***的值。我們知道我們只擁有指針，所以也就可以理解這種行為，但確實不是很直觀。
如果我們想保存這個值，需要知道在創(chuàng)建閉包時如何計算這個值。
- func main() {
- functions := make([]func(), 3)
- for i := 0; i < 3; i++ {
- functions[i] = func(y int) func() {
- return func() {
- fmt.Println(fmt.Sprintf("iterator value: %d", y))
- }
- }(i)
- }
- functions[0]()
- functions[1]()
- functions[2]()
- }
我們創(chuàng)建了一個臨時函數(shù)，它將變量作為參數(shù)并返回閉包。我們立即調用這個函數(shù)。由于在調用外部函數(shù)時必須先計算變量的值，所以內部閉包就可以捕獲到正確的值。我們得到的是 0,1,2。
在寫這篇文章不久之前，我找到了另一種方式。我們可以在循環(huán)中創(chuàng)建一個具有相同名稱的變量，并為其分配實際值。這樣也可以捕獲到變量的值，因為這個方法在循環(huán)的每次迭代中都會創(chuàng)建一個新的變量（因此是一個新的指針）。
- func main() {
- functions := make([]func(), 3)
- for i := 0; i < 3; i++ {
- i := i // Trick mit neuer Variable
- functions[i] = func() {
- fmt.Println(fmt.Sprintf("iterator value: %d", i))
- }
- }
- functions[0]()
- functions[1]()
- functions[2]()
- }
從執(zhí)行速度來看，懶求值通常是一個有趣的話題。畢竟，我可以在不使用它的情況下創(chuàng)建閉包。既然這樣，為什么還要求值？在我看來，這也是非常不直觀的。
4. 我們是不是都有點像囊地鼠？
我們已經知道，Go 中的interface{}就像 Java 中的Object——Go 中的每個類型都會自動實現(xiàn)這個空接口。不過，自動實現(xiàn)接口不僅適用于空接口，每一個實現(xiàn)了某個接口所有方法的結構體或類型也會自動實現(xiàn)這個接口。
為了更好地說明這個問題，讓我們來看看下面的例子：
- type Sortable interface {
- Sort(other Sortable)
- }
定義了這個方法的結構體會自動成為 Sortable。
- type MyStruct struct{}
- func (m MyStruct) Sort(other Sortable){}
除了接收器類型的語法，它用于將函數(shù)綁定到類型（在本例中為結構體），我們已經實現(xiàn)了Sortable接口的所有方法。我們現(xiàn)在是一個 Sortable！
var sortable Sortable = &MyStruct{}
自動實現(xiàn)接口乍一看似乎很有用，但這樣會讓事情變得復雜，特別是在大型應用中，如果有幾個接口擁有相同的方法，那么就會點讓人摸不著頭腦。開發(fā)者實際想要實現(xiàn)哪個接口？或許他們應該在代碼的注釋中寫清楚！
Go 還有一個解決方案用于確保一個類型實現(xiàn)了一個接口，就像 Java 的implements關鍵字一樣，這實在是太簡單了。
- type MyStruct struct{}
- func (m MyStruct) Sort(other Sortable){}
- var _ Sortable = MyStruct{}
- var _ Sortable = (*MyStruct)(nil)
5. nil 和 nothing
現(xiàn)在我們都知道，“null”和“nil”之間有很大的差別，但可能不是所有人都知道，“nothing”并不總是意味著“什么都沒有”。為了證明這點，我們定義了自己的錯誤類型（異常）。
- type MyError string
- func (m MyError) Error() string {
- return string(m)
- }
我們創(chuàng)建了一個新的類型，它是從字符串類型克隆過來的。我們只是想要一個錯誤消息，所以這樣做就足夠了。要實現(xiàn)error接口（是的，小寫，理論上它不應該是公開的，但 Go 無所不能），就必須實現(xiàn)Error方法。
接下來，我們需要另一個總是返回 Nil 的函數(shù)。
- func test(v bool) error {
- var e *MyError = nil
- if v {
- return nil
- }
- return e
- }
無論我們傳進去的是true還是false，這個函數(shù)總是返回nil，是這樣的嗎？c`
- func main() {
- fmt.Println(nil == test(true))
- fmt.Println(nil == test(false))
- }
- true
- false
在返回e時，*MyError指針指向接口error的一個實例，它不是nil！這樣合邏輯嗎？當你知道接口在 Go 中的表示方式，你就會知道這是合乎邏輯的。
在 Go 內部，接口是一個結構體，包含了實際目標實例（這里為nil）和接口類型（在這里是error），而且根據(jù) Go 語言規(guī)范，只有在這個結構體的兩個值都為nil時，接口實例才為nil。因此，如果真想要返回nil，那就顯式地返回吧。
特別之處
還有一點是值得一提的，如前所述，Go 根據(jù)名稱來推斷出類型和功能的可見性。如果***個字母是大寫字母（如Foo），則該函數(shù)或類型是公開的，如果***個字母是小寫字母（如foo），那么就是私有的。不過，在 Java 中有 private，而在 Go 中只有package-private。
一般來說，除了在 Go 中使用駝峰式命名法，我們都可以使用這種可見性規(guī)則，無論是函數(shù)、結構體還是常量，但我們的 IDE 有語法突出顯示，所以誰會在乎這個！
有趣的是，Go 支持 Unicode 的標識符。因此，日本語（Nihongo 是日語的意思）是完全合法的標識符，但通常被認為是私有的。為什么？因為日文字符沒有大寫字母。
“GO 斯拉”發(fā)來問候
某種程度上，Go 是一門非常獨特的語言。在日常工作中，你可以享受 Go 帶來的樂趣。如果你已經知道我們在這里所提到的陷阱（還有更多），那么即使開發(fā)再大型的應用程序也不成問題。盡管如此，還是會不斷出現(xiàn)各種提醒，說這門語言有問題。
Go 在近幾年發(fā)生了很多事情，除了增加新特性，Go 2 中還列出了很多需要改進的地方，包括一些語法和運行時行為的不一致性。不過 Go 2 的推出時間還不得而知，還沒有清晰的路線圖。
如果你想要用 Go，那么就用吧，盡管存在很多坑。不過你要為此做好準備：有時候你會感到困惑，需要長時間的調試，或通過閱讀 FAQ 或訪問 Gopher Slack 頻道來解決問題。
