Go 语言 15 个内置函数详解-51CTO.COM

01 介绍

Go 语言为了方便我们开发，提供了 15 个内置函数，比如 len、cap、make 和 new 等。

本文我们结合 Go 内置函数官方文档[1]，介绍一下 Go 语言中的内置函数。

02 内置函数

内置函数append：

内置函数 append 可以将元素追加到切片的末尾。

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

当我们使用 append 向切片中追加元素时，切片的底层数组必须具有足够的容量，否则，将会分配一个新的底层数组。

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

输出结果：

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

所以，我们需要注意的是，append 之后的切片赋值给同一个变量。

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

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

此外，还可以使用 append 将字符串追加到字节切片中，例如：

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

内置函数copy：

内置函数 copy 可以将源切片中的元素拷贝到目标切片。

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

输出结果：

[go vue] 2

copy 的返回值是拷贝元素的个数，返回值是 len(src) 和 len(dst) 的最小值。

需要注意的是，源切片和目标切片中的元素可能会重叠。

此外，还可以使用 copy 将一个字符串中的字节拷贝到一个字节切片中，例如：

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

内置函数delete：

内置函数 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)
}

输出结果：

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

内置函数 len：

内置函数 len 返回值的长度，值的类型不同，值的长度含义也不同。

array 数组中元素的个数。
*array 数组指针中元素的个数，即使数组指针的值是 nil。
slice 和 map 切片或映射中元素的个数，如果切片或映射的值是 nil，len(v) 值的长度是 0。
string 字符串中字节的个数。
channel 通道缓冲区中未读元素的个数，如果缓冲通道的值是 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))
}

输出结果：

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

需要注意的是，slice、map 和 channel 必须先使用内置函数 make 初始化后，该类型的值才可以使用。

内置函数 cap：

内置函数 cap 返回值的容量，值的类型不同，值的容量含义也不同。

array 数组中元素的个数，数组的 cap(v) 与 len(v) 相等。
*array 数组指针中元素的个数，数组指针的 cap(v) 和 len(v) 相等。
slice 切片可以容纳元素的最大长度，如果切片的值是 nil，该切片 cap(v) 值的容量是 0。
channel 通道缓冲区的容量，如果通道的值是 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))
}

输出结果：

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

内置函数 make：

内置函数 make 仅限为 slice、map 和 channel 分配内存并初始化。

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

make 第一个参数是类型，而不是值；第二个参数是可选（变长）参数，整型类型的值，返回值是该类型的值本身。

需要注意的是，第一个参数不同（不同类型），第二个参数的含义不同。

slice 第一个参数是切片类型，第二个参数的含义是指定切片的长度。如果没有传递第三个参数（整型类型的值），切片的容量等同于切片的长度，否则，切片的容量等同于第三个参数的值，需要注意的是，切片的容量必须不小于切片的长度。
map 分配一个有足够空间可以容纳指定数量元素的空映射，第二个参数可以省略，如果省略第二个参数，将分配一个起始值 0。
channel 指定缓冲区大小，初始化通道，如果第二个参数省略，或指定值为 0，该通道将被初始化为一个无缓冲通道。

内置函数 new：

内置函数 new 也可以分配内存，与 make 的区别是，它仅分配内存，而未初始化。

和 make 相同，第一个参数是类型，而不是值；

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

内置函数 complex：

内置函数 complex 将两个浮点型的值构造为一个复合类型的值，需要注意的是，实部和虚部必须是相同类型，即都是 float32 或 float64。

返回值是对应的复合类型，即 complex64 对应 float32 或 complex128 对应 float64。

内置函数 real：

内置函数 real 用于返回复合类型的值的实部，返回值是对应的浮点数类型。

内置函数 imag：

内置函数 imag 用于返回复合类型的值的虚部，返回值是对应的浮点数类型。

注意：complex、real 和 imag 三个内置函数，一般不常用，读者朋友们只需简单了解即可。

内置函数 close：

内置函数 close 关闭通道，被关闭的通道必须是一个双向通道或仅支持发送的单向通道。

并且 close 应该由发送者执行，结果是在最后一个发送的值被接收后，关闭该通道。

通道被关闭后，任何该通道的接收者将返回成功而不会阻塞，接收者得到的返回值是该通道的类型零值和一个布尔类型的零值 false。

需要注意的是，不仅是关闭通道会返回 false，空通道也会返回 false。

内置函数 panic：

内置函数 panic 停止当前 goroutine 正常执行，当一个函数 F 调用 panic 时，该函数 F 立即停止正常执行。

该函数 F 通过 defer 延迟调用的任意函数，仍然会执行，并将执行结果返回给 F 调用者。

对于 F 的调用者 F2，调用 F 也会像调用 panic，停止 F2 的执行，并运行 F2 通过 defer 延迟调用的任意函数。以此类推，一直持续到当前 goroutine 中的所有函数都以相反的顺序停止运行。

此时，程序以非 0 退出代码终止运行。

以上终止程序运行的序列称为“恐慌”，可以通过接下来我们要介绍的内置函数 recover 进行控制。

内置函数 recover：

内置函数 recover 允许程序管理“恐慌”的 goroutine 的行为。

可以在 defer 中调用 recover 恢复正常执行来停止“恐慌”，并且检索导致“恐慌”的错误。

但是，如果在 defer 之外调用 recover，它不会恢复正常执行来停止“恐慌”。此种情况，recover 的返回值是 nil。此外，当前执行 recover 的 goroutine 未“恐慌”，或调用 panic(nil) 时，recover 的返回值也是 nil。

因此，我们可以通过 recover 的返回值，判断当前 goroutine 是否“恐慌”。

注意：此处讲的在 defer 中调用 recover，是指在 defer 本身中，而不是任何被 defer 调用的函数中。

内置函数 print：

内置函数 print 可以通过指定格式来格式化其参数，并将结果输出。

内置函数 println：

内置函数 println 可以通过指定格式来格式化其参数，并将结果输出。与 print 的区别是，参数之间会添加空格，末尾会添加换行符。

注意：print 和 println 与标准库 fmt 中的 fmt.Print() 和 fmt.Println() 的区别是，前者是标准错误输出，后者是标准输出。在 Go 语言开发中，官方推荐使用标准库 fmt 包，感兴趣的读者朋友们可以查阅相关资料进一步了解。

03 总结

本文我们介绍 Go 语言的内置函数，读者朋友们需要重点掌握的内置函数是 len、cap、make、new、append、copy、delete、close、panic 和 recover。

Go 语言 15 个内置函数详解

​01 介绍

02 内置函数

03 总结

01 介绍