[[421872]]

本文轉載自微信公眾號「Golang技術分享」，作者機器鈴砍菜刀。轉載本文請聯系Golang技術分享公眾號。

在 Go 語言的日常編碼工作中，有一個非常普遍但詭異的編譯錯誤，曾讓我十分困惑。這個問題我相信不少 Gopher 都遇到過，不妨來看一下。

背景回顧

我們定義一個帶有 WriteGoCode() 方法的 Gopher 接口，同時定義了 person 結構體，它存在 WriteGoCode() 方法。

type Gopher interface { 
 WriteGoCode() 
} 
 
type person struct { 
 name string 
} 
 
func (p person) WriteGoCode() { 
 fmt.Printf("I am %s, i am writing go code!\n", p.name) 
} 

在 Go 語言中，只要某對象擁有接口的所有方法，那該對象即實現了該接口。p 是 person 結構體的實例化對象， Coding() 函數的入參是 Gopher 接口， person 對象實現了 Gopher 接口，因此 p 入參成功被運行。

func Coding(g Gopher) { 
 g.WriteGoCode() 
} 
 
func main() { 
 p := person{name: "小菜刀"} 
 Coding(p) 
} 
 
// output: 
I am 小菜刀, i am writing go code! 

此時，我們將 Coding() 函數的入參改為 []Gopher 類型，入參為 []person 。

func Coding(g Gopher) { 
 g.WriteGoCode() 
} 
 
func main() { 
 p := person{name: "小菜刀"} 
 Coding(p) 
} 
 
// output: 
I am 小菜刀, i am writing go code! 

但是，這個時候，編譯卻不能通過!

./main.go:29:8: cannot use p (type []person) as type []Gopher in argument to Coding 

明明 person 類型實現了 Gopher 接口，且當函數入參為 Gopher 類型時，能夠順利被執行，但參數變為 []Gopher 時，卻過不了編譯，這是為什么?

語法通用規則

這個問題在 stackoverflow 上被熱議，詳情見文末參考鏈接1。

在 Go 中，有一個通用規則，即語法不應隱藏復雜/昂貴的操作。轉換一個 string 到 interface{} 它的時間復雜度是 O(1)，轉換 []string 到 interface{} 同樣也是一個 O(1) 操作，因為它還是一個單一值的轉換。

如果要將 []string 轉換為 []interface{}，它是 O(N) 操作。因為切片的每個元素都必須轉換為 interface{}，這違背了 Go 的語法原則。

這個回答，你們同意嗎?

當然，此規則存在一個例外：轉換字符串。在將 string 轉換為 []byte 或 []rune 時，即使需要 O(n) 操作，但 Go 會允許執行。

InterfaceSlice 問題

Ian Lance Taylor(Go 核心開發者) 在 Go 官方倉庫中也回答了這個問題，詳情見文末參考鏈接2。他給出了這樣做的兩個主要原因。

原因一：類型為 []interface{} 的變量不是 interface!它僅僅是一個元素類型恰好為 interface{} 的切片。

原因二：[]interface{} 變量有特定大小的內存布局，在編譯期可知。這與 []MyType 是不同的。

每個 interface{} (運行時通過 runtime.eface 表示)占兩個字長(一個字代表所包含內容的類型 _type，另外一個字表示所包含的數據 data 或者指向它的指針 )

因此，類型為 []interface{} 的長度為 N 的變量，它是由 N*2 個字長的數據塊支持。而這與類型為 []MyType 的長度為 N 的變量的數據塊大小是不同的，因為后者的數據塊是 N*sizeof(MyType) 字長。

數據塊的不同，造成的結果是編譯器無法快速地將 []MyType 類型的內容分配給 []interface{} 類型的內容。

同理，[]Gopher 變量也是特定大小的內存布局(運行時通過 runtime.iface 表示)。這同樣不能快速地將 []MyType 類型的內容分配給 []Gopher 類型。

因此，Ian Lance Taylor 回答閉環了 Go 的語法通用規則：Go 語法不應隱藏復雜/昂貴的操作，編譯器會拒絕它們。

代碼解決方案

再次將文章開頭的例子附上，如果我們需要 [] person 類型的 p 能夠成功入參 Coding() 函數，應該如何做呢。

func Coding(gs []Gopher) { 
 for _, g := range gs { 
  g.WriteGoCode() 
 } 
} 
 
func main() { 
 p := []person{ 
  {name: "小菜刀1號"}, 
  {name: "小菜刀2號"}, 
 } 
 Coding(p) 
} 

代碼方案如下，核心是需要一個 []Gopher 類型的轉換變量。

func main() { 
 p := []person{ 
  {name: "小菜刀1號"}, 
  {name: "小菜刀2號"}, 
 } 
 var interfaceSlice []Gopher = make([]Gopher, len(p)) 
 for i, g := range p { 
  interfaceSlice[i] = g 
 } 
 Coding(interfaceSlice) 
} 
 
// output: 
I am 小菜刀1號, i am writing go code! 
I am 小菜刀2號, i am writing go code! 

總結

由于 []MyType 到 []interface{} 的轉換，是昂貴的操作，Go 編譯器不會允許這種情況通過編譯，故而將這種開銷的責任傳遞給開發者。

Go 是一門編譯速度很快的語言，得益于它語法設計中貫徹著 “simpler is better” 的理念，這可不是說說而已。

參考鏈接

【1. Type converting slices of interfaces】https://stackoverflow.com/questions/12753805/type-converting-slices-of-interfaces/12754757#12754757

【2. InterfaceSlice】https://github.com/golang/go/wiki/InterfaceSlice