近年來，Go從新出現(xiàn)的編程語言中脫穎而出。不過要把Go稱為“新晉者”似乎并不合適，因?yàn)楣雀柙缭?009年就推出了Go，并于2012年發(fā)布了第一個(gè)最終版（Go 1.0）。到現(xiàn)在為止，Go已經(jīng)發(fā)展到了1.10版本，這個(gè)版本令人印象深刻，而且還在不斷添加新的特性。

為什么它被稱為eGOtistic（自大狂）……

大家都知道，Go在實(shí)現(xiàn)或語法方面喜歡“我行我素”。在英語中，這種情況被描述為“自以為是”。很多來自其他編程語言的概念在Go中并不存在，或者即使存在，它們的行為也變得“面目全非”。后一種情況可能會(huì)導(dǎo)致意想不到的錯(cuò)誤，甚至讓開發(fā)人員感到疑惑。

嚴(yán)格的Go語法通常會(huì)讓開發(fā)人員感到疲倦。Go編譯器不允許出現(xiàn)未使用的導(dǎo)入和變量，并竭盡所能將它們攔截下來，甚至讓花括號(hào)另起一行都不行。Go強(qiáng)制使用相對(duì)固定且?guī)缀踅y(tǒng)一的編程風(fēng)格。只要Go編譯器不喜歡某些東西，到最后都變成了編譯錯(cuò)誤。

Go提供了非常嚴(yán)格的類型安全。因?yàn)樘�過嚴(yán)格，我們甚至可以通過它來實(shí)現(xiàn)一些特殊效果和編程錯(cuò)誤，其中一些我們稍后會(huì)在文中討論。不過，我們很少有必要在Go中顯式地聲明類型，因?yàn)轭愋屯ǔ？梢詮馁x值中獲得，也就是類型推斷。

我不是要提供問答！

一年多以前，我開始在工作中大量使用Go。Go算不上是我最喜歡的編程語言，但我承認(rèn)，Go在提升開發(fā)效率方面起到了一定作用。事實(shí)上，我已經(jīng)使用Go完成了幾個(gè)小項(xiàng)目，主要是一些嵌入式應(yīng)用。Go Toolchain的跨平臺(tái)編譯功能（編譯后可用于其他操作系統(tǒng)或CPU平臺(tái)）非常棒，已經(jīng)遙遙領(lǐng)先于它的競(jìng)爭(zhēng)對(duì)手。

現(xiàn)在讓我們來看看Go的一些比較特別的特性。入門Go其實(shí)很容易，可能只需要一個(gè)周末來了解它的基礎(chǔ)知識(shí)。但當(dāng)你開始用Go做一些更復(fù)雜的事情時(shí)，各種奇奇怪怪的事件開始浮出水面。

有時(shí)候，這些特性非常奇怪，谷歌為此提供了問題解答，用于解釋類似“為什么X的行為是這樣或者那樣的”這類問題。Go在很多方面都表現(xiàn)得與其他語言不太一樣，感覺好像程序員在某個(gè)時(shí)候一定會(huì)被某些陷阱絆倒一樣。gopher Slack頻道已經(jīng)證實(shí)了這種情況的存在，其中就有這樣的描述：“現(xiàn)在你真的應(yīng)該好好了解一下Go了，因?yàn)槊總�(gè)開發(fā)人員在他們的Go職業(yè)生涯中都會(huì)問到這個(gè)問題”。通常情況下，我們的直覺與Go的特性并不相符。例如，在谷歌的C語言變種中，公開類型、函數(shù)、常量等都以大寫字母作為開頭來表示它們是公開的，而標(biāo)識(shí)符開頭的小寫字母表示它們是私有的。

盡管如此，有關(guān)Go的很多決策都是在郵件列表或提案文件中經(jīng)過了長(zhǎng)時(shí)間的討論，因此還是得到了肯定。然而，討論所使用的用例都非常特殊，以至于很多開發(fā)人員仍然不清楚這與他們要解決的問題究竟有什么關(guān)系。

我個(gè)人最喜歡的部分是Go沒有提供可重入鎖，即同一線程或Goroutine（Coroutine或Green Thread的變體）可遞歸獲取的鎖。如果不通過hack的方式就無法自行實(shí)現(xiàn)這樣的功能，因?yàn)榫�程在Go中不可用，而Goroutine也并沒有提供可用于遞歸識(shí)別相同Coroutine的標(biāo)識(shí)符。

在這篇文章中，我想介紹Go的五個(gè)特性及其語法，這些特性都很隱晦。

1. 瘋狂的影子

讓我們從最簡(jiǎn)單的事情開始：每個(gè)優(yōu)秀的開發(fā)人員都聽說過Shadowing，它通常會(huì)發(fā)生在變量的上下文中。下面是只包含兩個(gè)作用域的簡(jiǎn)單示例：

foo("foo")
func foo(var1 string) {
  for {
    var1 := "bar"
    fmt.Println(var1)
    break
  }

我們通過:=賦值符號(hào)創(chuàng)建了一個(gè)變量，并通過所賦的值（類型引用）來推斷變量的類型。在這里，它是一個(gè)字符串。因此，我們?cè)趦?nèi)部作用域（for循環(huán)）中創(chuàng)建了一個(gè)與函數(shù)參數(shù)名稱相同的變量。我們覆蓋（shadow）了輸入?yún)��?shù)，并輸出“bar”。

到現(xiàn)在為止還挺好。但是，在Go中，需要為其他包的屬性指定包名（即結(jié)構(gòu)體、方法、函數(shù)等），這個(gè)可以在提供Println函數(shù)的fmt包中看到。

所以我們對(duì)之前的例子稍微做一下重構(gòu)：

foo("foo")
func foo(var1 string) {
  for {
    fmt := "bar"
    fmt.Println(var1)
    break
  }
}

這一次，我們遇到了編譯錯(cuò)誤，我們?cè)噲D在一個(gè)字符串上調(diào)用Println函數(shù)。但這種情況并不總是這么明顯。當(dāng)代碼突然停止編譯時(shí)，即使只有幾行代碼也會(huì)給我們帶來“驚喜”。

如果結(jié)構(gòu)體發(fā)生重疊，就會(huì)很麻煩。讓我們舉一個(gè)奇怪的例子：

type task struct {
}
  
func main() {
  task := &task{}
}

我們創(chuàng)建了一個(gè)叫作task的結(jié)構(gòu)體和它的一個(gè)實(shí)例。我們有意使用小寫task作為結(jié)構(gòu)體的名稱，因?yàn)槿缜八�述，Go使用第一個(gè)字母來確定可見性，所以task在這里是私有的。

到目前為止，它看起來很不錯(cuò)，Go編譯了我們創(chuàng)建的task。但是，當(dāng)我們嘗試添加另一行代碼時(shí)，情況突然發(fā)生了變化。

type task struct {
}
  
func main() {
  task := &task{}
  task = &task{}
}

現(xiàn)在無法通過編譯，并顯示task不是一個(gè)類型。此時(shí)，Go分不清類型和變量之間的區(qū)別。也許有人會(huì)說，在JavaScript中，變量task可以是對(duì)類型的引用，但這在Go中是不可能的，因?yàn)轭愋筒豢梢宰鳛橹蒂x給變量。

現(xiàn)在的問題是：這算不算是悲劇？一般來說不算，但它卻經(jīng)常在我沒有意識(shí)到的情況下發(fā)生。后面可能還會(huì)有一些代碼嘗試訪問相同名稱的結(jié)構(gòu)體或包，而每次都需要花幾分鐘時(shí)間才能找到問題所在。

說到類型問題，讓我們看看另外一個(gè)例子。

2.類型還是無類型，這是個(gè)問題！

我們已經(jīng)知道如何創(chuàng)建結(jié)構(gòu)體和函數(shù)。有時(shí)候，我們會(huì)偶爾“重命名”一下類型，比如：

type handle int

這將創(chuàng)建一個(gè)叫作handle的類型，它的行為類似int。通常，這個(gè)特性被稱為類型別名。你可能也想到過這個(gè)特性，但不是在Go中。不過從Go 1.9開始，已經(jīng)完全支持這個(gè)特性了。

讓我們看看可以用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

在這個(gè)例子中，我們使用了Go的幾個(gè)非�？岬奶匦�。switch-type-case語句是一種類型模式匹配，類似于Java的instanceof或JavaScript的typeof。我們把interface{}與Java中的Object等同起來，因?yàn)樗�是一個(gè)空的接口，每個(gè)Go類都會(huì)自動(dòng)實(shí)現(xiàn)它。

有趣的是，Java開發(fā)人員希望handle也是一個(gè)int，這樣就會(huì)匹配到第一個(gè)case。但事實(shí)并非如此，因?yàn)槊嫦驅(qū)ο笾械念愋屠^承在Go中并不適用。

另一種可能的情況是，handle是int的別名，就像C/C++中的typedef一樣，但事實(shí)也并非如此。Go編譯器會(huì)創(chuàng)建一個(gè)新的TypeSpec，可以說是原始類型的克隆。因此，它們之間是完全獨(dú)立的。

不過，從Go 1.9開始，支持真正的類型別名。下面的例子只稍微做了點(diǎn)修改。

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ū)別？實(shí)際上，我們現(xiàn)在不使用type handle int，而是使用type handle=int為int創(chuàng)建一個(gè)額外的名稱（別名），即handle。這意味著switch語句也必須做出修改，因?yàn)檫@個(gè)時(shí)候，int和handle對(duì)于編譯器來說是完全相同的類型，除非你有另一個(gè)double case，否則會(huì)出現(xiàn)編譯錯(cuò)誤。由于類型別名實(shí)在Go 1.9中引入的，很多人會(huì)認(rèn)為上述的類型克隆就是類別別名。

為了方便演示，讓我們定義一個(gè)名為Callable的類型，它由一個(gè)沒有參數(shù)和返回值的簡(jiǎn)單函數(shù)組成。

type Callable func()

現(xiàn)在創(chuàng)建一個(gè)相應(yīng)的函數(shù)。

func main() {
  myCallable := func() {
    fmt.Println("callable")
  }
  test(myCallable)
}
  
func test(callable Callable) {
  callable()
}

看，很簡(jiǎn)單。由于Go的類型推斷機(jī)制，編譯器自動(dòng)識(shí)別出myCallable應(yīng)該對(duì)應(yīng)Callable的函數(shù)簽名。編譯器因此能夠隱式地將myCallable轉(zhuǎn)換為Callable。隨后，myCallable被傳遞給test函數(shù)。這是執(zhí)行隱式轉(zhuǎn)換的少數(shù)例外之一，通常情況下，所有形式的轉(zhuǎn)換必須全部明確地指出。

現(xiàn)在我們已經(jīng)到了不得不使用Reflection的地步。與其他語言一樣，Reflection提供了在運(yùn)行時(shí)分析或改變行為的能力。類型信息通常被用于根據(jù)值的數(shù)據(jù)類型來改變運(yùn)行時(shí)行為。

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是一個(gè)單獨(dú)的TypeSpec，因此與func()的類型不一樣。這兩種情況現(xiàn)在都必須由我們的Reflection處理程序單獨(dú)攔截處理。不過這些問題可以通過在Go 1.9中引入的類型別名來解決。

type Callable=func()

3.懶惰是囊地鼠的天性！

Go語言萌萌噠的logo囊地鼠生性懶散，選這個(gè)logo也是有一定的代表意義的。

我最喜歡的Go特性之一是惰性求值（Lazy Evaluation），即延遲執(zhí)行代碼。自從Java推出Stream API以來，Java開發(fā)人員對(duì)該特性也所了解。

我們來看看下面的代碼片段：

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]()
}

這里有一個(gè)包含三個(gè)元素的數(shù)組、一個(gè)循環(huán)和閉包，而結(jié)果會(huì)是什么？

iterator value: 3
iterator value: 3
iterator value: 3

我們會(huì)認(rèn)為是0,1,2，但實(shí)際上卻是3,3,3。沒錯(cuò)！

在其他編程語言（如Java）中，在創(chuàng)建閉包時(shí)會(huì)捕獲變量的值，而Go僅捕獲指向變量本身的指針。問題是，在迭代期間，變量的值不斷變化。循環(huán)完成后，我們執(zhí)行閉包，只看到最后的值。我們知道我們只擁有指針，所以也就可以理解這種行為，但確實(shí)不是很直觀。

如果我們想保存這個(gè)值，需要知道在創(chuàng)建閉包時(shí)如何計(jì)算這個(gè)值。

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)建了一個(gè)臨時(shí)函數(shù)，它將變量作為參數(shù)并返回閉包。我們立即調(diào)用這個(gè)函數(shù)。由于在調(diào)用外部函數(shù)時(shí)必須先計(jì)算變量的值，所以內(nèi)部閉包就可以捕獲到正確的值。我們得到的是0,1,2。

在寫這篇文章不久之前，我找到了另一種方式。我們可以在循環(huán)中創(chuàng)建一個(gè)具有相同名稱的變量，并為其分配實(shí)際值。這樣也可以捕獲到變量的值，因?yàn)檫@個(gè)方法在循環(huán)的每次迭代中都會(huì)創(chuàng)建一個(gè)新的變量（因此是一個(gè)新的指針）。

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í)行速度來看，懶求值通常是一個(gè)有趣的話題。畢竟，我可以在不使用它的情況下創(chuàng)建閉包。既然這樣，為什么還要求值？在我看來，這也是非常不直觀的。

4.我們是不是都有點(diǎn)像囊地鼠？

我們已經(jīng)知道，Go中的interface{}就像Java中的Object——Go中的每個(gè)類型都會(huì)自動(dòng)實(shí)現(xiàn)這個(gè)空接口。不過，自動(dòng)實(shí)現(xiàn)接口不僅適用于空接口，每一個(gè)實(shí)現(xiàn)了某個(gè)接口所有方法的結(jié)構(gòu)體或類型也會(huì)自動(dòng)實(shí)現(xiàn)這個(gè)接口。

為了更好地說明這個(gè)問題，讓我們來看看下面的例子：

type Sortable interface {
  Sort(other Sortable)
}

定義了這個(gè)方法的結(jié)構(gòu)體會(huì)自動(dòng)成為Sortable。

type MyStruct struct{}
func (m MyStruct) Sort(other Sortable){}

除了接收器類型的語法，它用于將函數(shù)綁定到類型（在本例中為結(jié)構(gòu)體），我們已經(jīng)實(shí)現(xiàn)了Sortable接口的所有方法。我們現(xiàn)在是一個(gè)Sortable！

var sortable Sortable = &MyStruct{}

自動(dòng)實(shí)現(xiàn)接口乍一看似乎很有用，但這樣會(huì)讓事情變得復(fù)雜，特別是在大型應(yīng)用中，如果有幾個(gè)接口擁有相同的方法，那么就會(huì)點(diǎn)讓人摸不著頭腦。開發(fā)者實(shí)際想要實(shí)現(xiàn)哪個(gè)接口？或許他們應(yīng)該在代碼的注釋中寫清楚！

Go還有一個(gè)解決方案用于確保一個(gè)類型實(shí)現(xiàn)了一個(gè)接口，就像Java的implements關(guān)鍵字一樣，這實(shí)在是太簡(jiǎn)單了。

type MyStruct struct{}
func (m MyStruct) Sort(other Sortable){}
var _ Sortable = MyStruct{}
var _ Sortable = (*MyStruct)(nil)

5.nil和nothing

現(xiàn)在我們都知道，“null”和“nil”之間有很大的差別，但可能不是所有人都知道，“nothing”并不總是意味著“什么都沒有”。為了證明這點(diǎn)，我們定義了自己的錯(cuò)誤類型（異常）。

type MyError string
func (m MyError) Error() string {
  return string(m)
}

我們創(chuàng)建了一個(gè)新的類型，它是從字符串類型克隆過來的。我們只是想要一個(gè)錯(cuò)誤消息，所以這樣做就足夠了。要實(shí)現(xiàn)error接口（是的，小寫，理論上它不應(yīng)該是公開的，但Go無所不能），就必須實(shí)現(xiàn)Error方法。

接下來，我們需要另一個(gè)總是返回Nil的函數(shù)。

func test(v bool) error {
  var e *MyError = nil
  if v {
    return nil
  }
  return e
}

無論我們傳進(jìn)去的是true還是false，這個(gè)函數(shù)總是返回nil，是這樣的嗎？

func main() {
  fmt.Println(nil == test(true))
  fmt.Println(nil == test(false))
}

true
false

在返回e時(shí)，*MyError指針指向接口error的一個(gè)實(shí)例，它不是nil！這樣合邏輯嗎？當(dāng)你知道接口在Go中的表示方式，你就會(huì)知道這是合乎邏輯的。

在Go內(nèi)部，接口是一個(gè)結(jié)構(gòu)體，包含了實(shí)際目標(biāo)實(shí)例（這里為nil）和接口類型（在這里是error），而且根據(jù)Go語言規(guī)范，只有在這個(gè)結(jié)構(gòu)體的兩個(gè)值都為nil時(shí)，接口實(shí)例才為nil。因此，如果真想要返回nil，那就顯式地返回吧。

特別之處

還有一點(diǎn)是值得一提的，如前所述，Go根據(jù)名稱來推斷出類型和功能的可見性。如果第一個(gè)字母是大寫字母（如Foo），則該函數(shù)或類型是公開的，如果第一個(gè)字母是小寫字母（如foo），那么就是私有的。不過，在Java中有private，而在Go中只有package-private。

一般來說，除了在Go中使用駝峰式命名法，我們都可以使用這種可見性規(guī)則，無論是函數(shù)、結(jié)構(gòu)體還是常量，但我們的IDE有語法突出顯示，所以誰會(huì)在乎這個(gè)！

有趣的是，Go支持Unicode的標(biāo)識(shí)符。因此，日本語（Nihongo是日語的意思）是完全合法的標(biāo)識(shí)符，但通常被認(rèn)為是私有的。為什么？因?yàn)槿瘴淖址麤]有大寫字母。

“GO斯拉”發(fā)來問候

某種程度上，Go是一門非常獨(dú)特的語言。在日常工作中，你可以享受Go帶來的樂趣。如果你已經(jīng)知道我們?cè)谶@里所提到的陷阱（還有更多），那么即使開發(fā)再大型的應(yīng)用程序也不成問題。盡管如此，還是會(huì)不斷出現(xiàn)各種提醒，說這門語言有問題。

Go在近幾年發(fā)生了很多事情，除了增加新特性，Go 2中還列出了很多需要改進(jìn)的地方，包括一些語法和運(yùn)行時(shí)行為的不一致性。不過Go 2的推出時(shí)間還不得而知，還沒有清晰的路線圖。

如果你想要用Go，那么就用吧，盡管存在很多坑。不過你要為此做好準(zhǔn)備：有時(shí)候你會(huì)感到困惑，需要長(zhǎng)時(shí)間的調(diào)試，或通過閱讀FAQ或訪問Gopher Slack頻道來解決問題。

原文鏈接： https://jaxenter.com/5-things-you-hate-about-go-143422.html

感謝張嬋對(duì)本文的審校。

 

來自：http://www.infoq.com/cn/articles/5-things-you-hate-about-go

 

標(biāo)簽： 安全 代碼 谷歌 開發(fā)者

版權(quán)申明：本站文章部分自網(wǎng)絡(luò)，如有侵權(quán)，請(qǐng)聯(lián)系：west999com@outlook.com
特別注意：本站所有轉(zhuǎn)載文章言論不代表本站觀點(diǎn)！
本站所提供的圖片等素材，版權(quán)歸原作者所有，如需使用，請(qǐng)與原作者聯(lián)系。