?01 介紹

Go 語言為了方便我們開發(fā)，提供了 15 個內(nèi)置函數(shù)，比如 len、cap、make? 和 new 等。

本文我們結(jié)合 Go 內(nèi)置函數(shù)官方文檔[1]，介紹一下 Go 語言中的內(nèi)置函數(shù)。

02 內(nèi)置函數(shù)

內(nèi)置函數(shù)?append：

內(nèi)置函數(shù) append 可以將元素追加到切片的末尾。

func append(slice []Type, elems ...Type) []Type

當我們使用 append 向切片中追加元素時，切片的底層數(shù)組必須具有足夠的容量，否則，將會分配一個新的底層數(shù)組。

func main() {
 s := []int{1, 2, 3}
 fmt.Printf("%p %d\n", s, s)
 s = append(s, 4)
 fmt.Printf("%p %d\n", s, s)
}

輸出結(jié)果：

0xc0000b2018 [1 2 3]
0xc0000ae030 [1 2 3 4]

所以，我們需要注意的是，append 之后的切片賦值給同一個變量。

除了使用 append 向切片中追加元素之外，我們還可以向切片中追加另一個切片，例如：

s1 := []int{5, 6, 7}
s = append(s, s1...)

此外，還可以使用 append 將字符串追加到字節(jié)切片中，例如：

str := "hello "
bs := append([]byte(str), "world"...)

內(nèi)置函數(shù)?copy：

內(nèi)置函數(shù) copy 可以將源切片中的元素拷貝到目標切片。

func main() {
 src := []string{"go", "vue"}
 dst := make([]string, 2)
 n := copy(dst, src)
 fmt.Printf("%s %d\n", dst, n)
}

輸出結(jié)果：

[go vue] 2

copy? 的返回值是拷貝元素的個數(shù)，返回值是 len(src)? 和 len(dst) 的最小值。

需要注意的是，源切片和目標切片中的元素可能會重疊。

此外，還可以使用 copy 將一個字符串中的字節(jié)拷貝到一個字節(jié)切片中，例如：

func main() {
 str := "hello"
 bs := make([]byte, 5)
 n := copy(bs, str)
 fmt.Printf("%s %d\n", bs, n)
}

內(nèi)置函數(shù)?delete：

內(nèi)置函數(shù) delete? 通過指定鍵 m[key]? 刪除 map 中的元素。

如果 map? 是 nil? 或沒有元素，delete 不做任何操作。

func main() {
 var m map[int]string
 fmt.Println(m)
 delete(m, 0)
 fmt.Println(m)
 m1 := make(map[int]string)
 fmt.Println(m1)
 delete(m1, 0)
 fmt.Println(m1)
 m2 := make(map[int]string, 2)
 m2[0] = "hello"
 m2[1] = "world"
 fmt.Println(m2)
 delete(m2, 0)
 fmt.Println(m2)
}

輸出結(jié)果：

map[]
map[]
map[]
map[]
map[0:hello 1:world]
map[1:world]

內(nèi)置函數(shù) ?len：

內(nèi)置函數(shù) len 返回值的長度，值的類型不同，值的長度含義也不同。

• array 數(shù)組中元素的個數(shù)。
• *array? 數(shù)組指針中元素的個數(shù)，即使數(shù)組指針的值是 nil。
• slice? 和 map? 切片或映射中元素的個數(shù)，如果切片或映射的值是 nil，len(v) 值的長度是 0。
• string 字符串中字節(jié)的個數(shù)。
• channel? 通道緩沖區(qū)中未讀元素的個數(shù)，如果緩沖通道的值是 nil，len(v) 值的長度是 0。

func main() {
 arr := [3]int{1, 2, 3}
 fmt.Println(arr)
 fmt.Println(len(arr))
 var arr1 *[3]int
 fmt.Println(arr1)
 fmt.Println(len(arr1))
 var s []int
 fmt.Println(len(s))
 s = []int{1, 2, 3}
 fmt.Println(len(s))
 var m map[int]string
 fmt.Println(len(m))
 m = make(map[int]string)
 m[0] = "hello"
 fmt.Println(len(m))
 str := "frank"
 fmt.Println(len(str))
 var c chan int
 fmt.Println(c)
 fmt.Println(len(c))
 c = make(chan int)
 fmt.Println(len(c))
}

輸出結(jié)果：

[1 2 3]
3
<nil>
3
0
3
0
1
5
<nil>
0
0

需要注意的是，slice、map? 和 channel? 必須先使用內(nèi)置函數(shù) make 初始化后，該類型的值才可以使用。

內(nèi)置函數(shù) ?cap：

內(nèi)置函數(shù) cap 返回值的容量，值的類型不同，值的容量含義也不同。

• array? 數(shù)組中元素的個數(shù)，數(shù)組的 cap(v)? 與 len(v) 相等。
• *array? 數(shù)組指針中元素的個數(shù)，數(shù)組指針的 cap(v)? 和 len(v) 相等。
• slice? 切片可以容納元素的最大長度，如果切片的值是 nil?，該切片 cap(v) 值的容量是 0。
• channel? 通道緩沖區(qū)的容量，如果通道的值是 nil?，該通道 cap(v) 值的容量是 0。

func main() {
 var arr [3]int
 fmt.Println(arr)
 fmt.Println(cap(arr))
 var arr1 *[3]int
 fmt.Println(arr1)
 fmt.Println(cap(arr1))
 var s []string
 fmt.Println(s)
 fmt.Println(cap(s))
 s = make([]string, 1)
 s[0] = "go"
 fmt.Println(s)
 fmt.Println(cap(s))
 var c chan int
 fmt.Println(c)
 fmt.Println(cap(c))
}

輸出結(jié)果：

[0 0 0]
3
<nil>
3
[]
0
[go]
1
<nil>
0

內(nèi)置函數(shù) ?make：

內(nèi)置函數(shù) make? 僅限為 slice、map? 和 channel 分配內(nèi)存并初始化。

func make(t Type, size ...IntegerType) Type

make 第一個參數(shù)是類型，而不是值；第二個參數(shù)是可選（變長）參數(shù)，整型類型的值，返回值是該類型的值本身。

需要注意的是，第一個參數(shù)不同（不同類型），第二個參數(shù)的含義不同。

• slice 第一個參數(shù)是切片類型，第二個參數(shù)的含義是指定切片的長度。如果沒有傳遞第三個參數(shù)（整型類型的值），切片的容量等同于切片的長度，否則，切片的容量等同于第三個參數(shù)的值，需要注意的是，切片的容量必須不小于切片的長度。
• map 分配一個有足夠空間可以容納指定數(shù)量元素的空映射，第二個參數(shù)可以省略，如果省略第二個參數(shù)，將分配一個起始值 0。
• channel 指定緩沖區(qū)大小，初始化通道，如果第二個參數(shù)省略，或指定值為 0，該通道將被初始化為一個無緩沖通道。

內(nèi)置函數(shù) ?new：

內(nèi)置函數(shù) new? 也可以分配內(nèi)存，與 make 的區(qū)別是，它僅分配內(nèi)存，而未初始化。

和 make 相同，第一個參數(shù)是類型，而不是值；

和 make 不同，返回值是新分配的類型零值的指針。

內(nèi)置函數(shù) ?complex：

內(nèi)置函數(shù) complex? 將兩個浮點型的值構(gòu)造為一個復合類型的值，需要注意的是，實部和虛部必須是相同類型，即都是 float32? 或 float64。

返回值是對應的復合類型，即 complex64? 對應 float32? 或 complex128? 對應 float64。

內(nèi)置函數(shù) ?real：

內(nèi)置函數(shù) real 用于返回復合類型的值的實部，返回值是對應的浮點數(shù)類型。

內(nèi)置函數(shù) ?imag：

內(nèi)置函數(shù) imag 用于返回復合類型的值的虛部，返回值是對應的浮點數(shù)類型。

注意：complex、real? 和 imag 三個內(nèi)置函數(shù)，一般不常用，讀者朋友們只需簡單了解即可。

內(nèi)置函數(shù) ?close：

內(nèi)置函數(shù) close 關閉通道，被關閉的通道必須是一個雙向通道或僅支持發(fā)送的單向通道。

并且 close 應該由發(fā)送者執(zhí)行，結(jié)果是在最后一個發(fā)送的值被接收后，關閉該通道。

通道被關閉后，任何該通道的接收者將返回成功而不會阻塞，接收者得到的返回值是該通道的類型零值和一個布爾類型的零值 false。

需要注意的是，不僅是關閉通道會返回 false?，空通道也會返回 false。

內(nèi)置函數(shù) ?panic：

內(nèi)置函數(shù) panic? 停止當前 goroutine? 正常執(zhí)行，當一個函數(shù) F? 調(diào)用 panic? 時，該函數(shù) F 立即停止正常執(zhí)行。

該函數(shù) F? 通過 defer? 延遲調(diào)用的任意函數(shù)，仍然會執(zhí)行，并將執(zhí)行結(jié)果返回給 F 調(diào)用者。

對于 F? 的調(diào)用者 F2?，調(diào)用 F? 也會像調(diào)用 panic?，停止 F2? 的執(zhí)行，并運行 F2? 通過 defer? 延遲調(diào)用的任意函數(shù)。以此類推，一直持續(xù)到當前 goroutine 中的所有函數(shù)都以相反的順序停止運行。

此時，程序以非 0 退出代碼終止運行。

以上終止程序運行的序列稱為“恐慌”，可以通過接下來我們要介紹的內(nèi)置函數(shù) recover 進行控制。

內(nèi)置函數(shù) ?recover：

內(nèi)置函數(shù) recover? 允許程序管理“恐慌”的 goroutine 的行為。

可以在 defer? 中調(diào)用 recover 恢復正常執(zhí)行來停止“恐慌”，并且檢索導致“恐慌”的錯誤。

但是，如果在 defer? 之外調(diào)用 recover?，它不會恢復正常執(zhí)行來停止“恐慌”。此種情況，recover? 的返回值是 nil?。此外，當前執(zhí)行 recover? 的 goroutine? 未“恐慌”，或調(diào)用 panic(nil)? 時，recover? 的返回值也是 nil。

因此，我們可以通過 recover? 的返回值，判斷當前 goroutine 是否“恐慌”。

注意：此處講的在 defer? 中調(diào)用 recover?，是指在 defer? 本身中，而不是任何被 defer 調(diào)用的函數(shù)中。

內(nèi)置函數(shù) ?print：

內(nèi)置函數(shù) print 可以通過指定格式來格式化其參數(shù)，并將結(jié)果輸出。

內(nèi)置函數(shù) ?println：

內(nèi)置函數(shù) println? 可以通過指定格式來格式化其參數(shù)，并將結(jié)果輸出。與 print 的區(qū)別是，參數(shù)之間會添加空格，末尾會添加換行符。

注意：print? 和 println? 與標準庫 fmt? 中的 fmt.Print()? 和 fmt.Println()? 的區(qū)別是，前者是標準錯誤輸出，后者是標準輸出。在 Go 語言開發(fā)中，官方推薦使用標準庫 fmt 包，感興趣的讀者朋友們可以查閱相關資料進一步了解。

03 總結(jié)

本文我們介紹 Go 語言的內(nèi)置函數(shù)，讀者朋友們需要重點掌握的內(nèi)置函數(shù)是 len、cap、make、new、append、copy、delete、close、panic? 和 recover。