Go语言15个内置函数详解

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

输出结果：

需要注意的是，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

3
[]
0
[go]
1

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个内置函数详解
标题URL：http://www.shufengxianlan.com/qtweb/news39/179389.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源：创新互联

猜你还喜欢下面的内容

Go语言15个内置函数详解

​01 介绍

02 内置函数

03 总结

01 介绍