Go语言基本语法 (中)-白红宇的个人博客

Go语言基本语法 (中)

发布日期：2021-06-29 18:10:28 浏览次数：3 分类：技术文章

本文共 24528 字，大约阅读时间需要 81 分钟。

原作者博客链接：[https://www.liwenzhou.com/][https://www.liwenzhou.com/]

Golang 中文文档地址：

1. 运算符

Go 语言内置的运算符有：

算术运算符

关系运算符

逻辑运算符

位运算符

赋值运算符

算数运算符

运算符	描述
+	相加
-	相减
*	相乘
/	相除
%	求余

注意： ++（自增）和--（自减）在Go语言中是单独的语句，并不是运算符。

关系运算符

运算符	描述
==	检查两个值是否相等，如果相等返回 True 否则返回 False。
!=	检查两个值是否不相等，如果不相等返回 True 否则返回 False。
>	检查左边值是否大于右边值，如果是返回 True 否则返回 False。
>=	检查左边值是否大于等于右边值，如果是返回 True 否则返回 False。
<	检查左边值是否小于右边值，如果是返回 True 否则返回 False。
<=	检查左边值是否小于等于右边值，如果是返回 True 否则返回 False。

逻辑运算符

运算符	描述
&&	逻辑 AND 运算符。如果两边的操作数都是 True，则为 True，否则为 False。
\|\|	逻辑 OR 运算符。如果两边的操作数有一个 True，则为 True，否则为 False。
!	逻辑 NOT 运算符。如果条件为 True，则为 False，否则为 True。

位运算符

位运算符对整数在内存中的二进制位进行操作。

运算符	描述
&	参与运算的两数各对应的二进位相与。（两位均为1才为1）
\|	参与运算的两数各对应的二进位相或。（两位有一个为1就为1）
^	参与运算的两数各对应的二进位相异或，当两对应的二进位相异时，结果为1。（两位不一样则为1）
<<	左移n位就是乘以2的n次方。 “a<<b”是把a的各二进位全部左移b位，高位丢弃，低位补0。
>>	右移n位就是除以2的n次方。 “a>>b”是把a的各二进位全部右移b位。

赋值运算符

运算符	描述
=	简单的赋值运算符，将一个表达式的值赋给一个左值
+=	相加后再赋值
-=	相减后再赋值
*=	相乘后再赋值
/=	相除后再赋值
%=	求余后再赋值
<<=	左移后赋值
>>=	右移后赋值
&=	按位与后赋值
\|=	按位或后赋值
^=	按位异或后赋值

2. 数组

数组是同一种数据类型元素的集合。在Go语言中，数组从声明时就确定，使用时可以修改数组成员，但是数组大小不可变化。基本语法：

// 定义一个长度为3元素类型为int的数组avar a [3]int

2.1 数组定义：

var 数组变量名 [元素数量]T

比如：var a [5]int，数组的长度必须是常量，并且长度是数组类型的一部分。一旦定义，长度不能变。 [5]int和[10]int是不同的类型。

var a [3]intvar b [4]inta = b //不可以这样做，因为此时a和b是不同的类型

数组可以通过下标进行访问，下标是从0开始，最后一个元素下标是：len-1，访问越界（下标在合法范围之外），则触发访问越界，会panic。

2.2 数组的初始化：

数组的初始化也有很多方式。

方法一

初始化数组时可以使用初始化列表来设置数组元素的值。

func main() {
   	var testArray [3]int                        //数组会初始化为int类型的零值	var numArray = [3]int{
   1, 2}                 //使用指定的初始值完成初始化	var cityArray = [3]string{
   "北京", "上海", "深圳"} //使用指定的初始值完成初始化	fmt.Println(testArray)                      //[0 0 0]	fmt.Println(numArray)                       //[1 2 0]	fmt.Println(cityArray)                      //[北京 上海 深圳]}

方法二

按照上面的方法每次都要确保提供的初始值和数组长度一致，一般情况下我们可以让编译器根据初始值的个数自行推断数组的长度，例如：

func main() {
   	var testArray [3]int	var numArray = [...]int{
   1, 2}	var cityArray = [...]string{
   "北京", "上海", "深圳"}	fmt.Println(testArray)                          //[0 0 0]	fmt.Println(numArray)                           //[1 2]	fmt.Printf("type of numArray:%T\n", numArray)   //type of numArray:[2]int	fmt.Println(cityArray)                          //[北京 上海 深圳]	fmt.Printf("type of cityArray:%T\n", cityArray) //type of cityArray:[3]string}

方法三

我们还可以使用指定索引值的方式来初始化数组，例如:

func main() {
   	a := [...]int{
   1: 1, 3: 5}	fmt.Println(a)                  // [0 1 0 5]	fmt.Printf("type of a:%T\n", a) //type of a:[4]int}

2.3 数组的遍历：

遍历数组a有以下两种方法：

func main() {
   	var a = [...]string{
   "北京", "上海", "深圳"}	// 方法1：for循环遍历	for i := 0; i < len(a); i++ {
   		fmt.Println(a[i])	}	// 方法2：for range遍历	for index, value := range a {
   		fmt.Println(index, value)	}}

3. 多维数组

Go语言是支持多维数组的，我们这里以二维数组为例（数组中又嵌套数组）。

3.1 二维数组的定义：

func main() {
   	a := [3][2]string{
   		{
   "北京", "上海"},		{
   "广州", "深圳"},		{
   "成都", "重庆"},	}	fmt.Println(a) //[[北京 上海] [广州 深圳] [成都 重庆]]	fmt.Println(a[2][1]) //支持索引取值:重庆}

3.2 二维数组的遍历：

func main() {
   	a := [3][2]string{
   		{
   "北京", "上海"},		{
   "广州", "深圳"},		{
   "成都", "重庆"},	}	for _, v1 := range a {
   		for _, v2 := range v1 {
   			fmt.Printf("%s\t", v2)		}		fmt.Println()	}}

输出：

北京	上海	广州	深圳	成都	重庆

注意： 多维数组只有第一层可以使用...来让编译器推导数组长度。例如：

//支持的写法a := [...][2]string{
   	{
   "北京", "上海"},	{
   "广州", "深圳"},	{
   "成都", "重庆"},}//不支持多维数组的内层使用...b := [3][...]string{
   	{
   "北京", "上海"},	{
   "广州", "深圳"},	{
   "成都", "重庆"},}

3.4 数组是值类型

数组是值类型，赋值和传参会复制整个数组。因此改变副本的值，不会改变本身的值。

func modifyArray(x [3]int) {
   	x[0] = 100}func modifyArray2(x [3][2]int) {
   	x[2][0] = 100}func main() {
   	a := [3]int{
   10, 20, 30}	modifyArray(a) //在modify中修改的是a的副本x	fmt.Println(a) //[10 20 30]	b := [3][2]int{
   		{
   1, 1},		{
   1, 1},		{
   1, 1},	}	modifyArray2(b) //在modify中修改的是b的副本x	fmt.Println(b)  //[[1 1] [1 1] [1 1]]}

注意：

数组支持 “==“、”!=” 操作符，因为内存总是被初始化过的。

[n]*T表示指针数组，*[n]T表示数组指针。

完整代码：

package mainimport "fmt"func main() {
   	// 数组的定义	var a1 [3]bool	fmt.Println(a1) // [false false false]	var a2 [4]bool	fmt.Printf("a1:%T  a2:%T\n", a1, a2)	// 数组的初始化	a1 = [3]bool{
   true,true,false}// 方式 1	fmt.Println(a1)	a3 := [...]int{
   1,2,3,4,5,6,7,8,9}// 方式 2	fmt.Println(a3)	a4 := [5]int{
   1,2}// 方式 3	fmt.Println(a4)// [1 2 0 0 0]	a5 := [5]int{
   0:1,4:2}// 方式 4	fmt.Println(a5)// [1 0 0 0 2]	// 数组的遍历	citys := [...]string{
   "北京","上海","深圳"}	// 1.根据索引遍历	for i:=0;i

4. 切片

4.1 引子

因为数组的长度是固定的并且数组长度属于类型的一部分，所以数组有很多的局限性。例如：

func arraySum(x [3]int) int{
       sum := 0    for _, v := range x{
           sum = sum + v    }    return sum}

这个求和函数只能接受[3]int类型，其他的都不支持。再比如，

a := [3]int{
   1, 2, 3}

数组a中已经有三个元素了，我们不能再继续往数组a中添加新元素了。

4.1 切片的定义

切片（Slice）是一个拥有相同类型元素的可变长度的序列。它是基于数组类型做的一层封装。它非常灵活，支持自动扩容。

切片是一个引用类型，它的内部结构包含地址、长度和容量。切片一般用于快速地操作一块数据集合。

4.2 切片声明语法

声明切片类型的基本语法如下：

var name []T

其中：

name：表示变量名

T：表示切片中的元素类型

举个例子：

func main() {
   	// 声明切片类型	var a []string              //声明一个字符串切片	var b = []int{
   }             //声明一个整型切片并初始化	var c = []bool{
   false, true} //声明一个布尔切片并初始化	var d = []bool{
   false, true} //声明一个布尔切片并初始化	fmt.Println(a)              //[]	fmt.Println(b)              //[]	fmt.Println(c)              //[false true]	fmt.Println(a == nil)       //true	fmt.Println(b == nil)       //false	fmt.Println(c == nil)       //false	// fmt.Println(c == d)   //切片是引用类型，不支持直接比较，只能和nil比较}

4.3 切片的长度和容量

切片拥有自己的长度和容量，我们可以通过使用内置的len()函数求长度，使用内置的cap()函数求切片的容量。

4.4 切片表达式

切片表达式从字符串、数组、指向数组或切片的指针构造子字符串或切片。它有两种变体：一种指定low和high两个索引界限值的简单的形式，另一种是除了low和high索引界限值外还指定容量的完整的形式。

简单切片表达式

切片的底层就是一个数组，所以我们可以基于数组通过切片表达式得到切片。切片表达式中的low和high表示一个索引范围（左包含，右不包含），也就是下面代码中从数组a中选出1<=索引值<4的元素组成切片s，得到的切片长度=high-low，容量等于得到的切片的底层数组的容量。

func main() {
   	a := [5]int{
   1, 2, 3, 4, 5}	s := a[1:3]  // s := a[low:high]	fmt.Printf("s:%v len(s):%v cap(s):%v\n", s, len(s), cap(s))}

输出：

s:[2 3] len(s):2 cap(s):4

为了方便起见，可以省略切片表达式中的任何索引。省略了low则默认为0；省略了high则默认为切片操作数的长度:

a[2:]  // 等同于 a[2:len(a)]a[:3]  // 等同于 a[0:3]a[:]   // 等同于 a[0:len(a)]

注意：

对于数组或字符串，如果0 <= low <= high <= len(a)，则索引合法，否则就会索引越界（out of range）。

对切片再执行切片表达式时（切片再切片），high的上限边界是切片的容量cap(a)，而不是长度。常量索引必须是非负的，并且可以用int类型的值表示;对于数组或常量字符串，常量索引也必须在有效范围内。如果low和high两个指标都是常数，它们必须满足low <= high。如果索引在运行时超出范围，就会发生运行时panic。

func main() {
   	a := [5]int{
   1, 2, 3, 4, 5}	s := a[1:3]  // s := a[low:high]	fmt.Printf("s:%v len(s):%v cap(s):%v\n", s, len(s), cap(s))	s2 := s[3:4]  // 索引的上限是cap(s)而不是len(s)	fmt.Printf("s2:%v len(s2):%v cap(s2):%v\n", s2, len(s2), cap(s2))}

输出：

s:[2 3] len(s):2 cap(s):4s2:[5] len(s2):1 cap(s2):1

完整切片表达式

对于数组，指向数组的指针，或切片a(注意不能是字符串)支持完整切片表达式：

a[low : high : max]

上面的代码会构造与简单切片表达式a[low: high]相同类型、相同长度和元素的切片。另外，它会将得到的结果切片的容量设置为max-low。在完整切片表达式中只有第一个索引值（low）可以省略；它默认为0。

func main() {
   	a := [5]int{
   1, 2, 3, 4, 5}	t := a[1:3:5]	fmt.Printf("t:%v len(t):%v cap(t):%v\n", t, len(t), cap(t))}

输出结果：

t:[2 3] len(t):2 cap(t):4

完整切片表达式需要满足的条件是0 <= low <= high <= max <= cap(a)，其他条件和简单切片表达式相同。

4.5 使用make()函数构造切片

我们上面都是基于数组来创建的切片，如果需要动态的创建一个切片，我们就需要使用内置的make()函数，格式如下：

make([]T, size, cap)

其中：

T: 切片的元素类型

size: 切片中元素的数量

cap: 切片的容量

举个例子：

func main() {
   	a := make([]int, 2, 10)	fmt.Println(a)      //[0 0]	fmt.Println(len(a)) //2	fmt.Println(cap(a)) //10}

上面代码中a的内部存储空间已经分配了10个，但实际上只用了2个。容量并不会影响当前元素的个数，所以len(a)返回2，cap(a)则返回该切片的容量。

4.6 切片的本质

切片的本质就是对底层数组的封装，它包含了三个信息：底层数组的指针、切片的长度（len）和切片的容量（cap）。

举个例子，现在有一个数组a := [8]int{0, 1, 2, 3, 4, 5, 6, 7}，切片s1 := a[:5]，相应示意图如下。

在这里插入图片描述

切片s2 := a[3:6]，相应示意图如下：

在这里插入图片描述

4.7 判断切片是否为空

要检查切片是否为空，请始终使用len(s) == 0来判断，而不应该使用s == nil来判断。

4.8 切片不能直接比较

切片之间是不能比较的，我们不能使用==操作符来判断两个切片是否含有全部相等元素。切片唯一合法的比较操作是和nil比较。一个nil值的切片并没有底层数组，一个nil值的切片的长度和容量都是0。但是我们不能说一个长度和容量都是0的切片一定是nil，例如下面的示例：

var s1 []int         //len(s1)=0;cap(s1)=0;s1==nils2 := []int{
   }        //len(s2)=0;cap(s2)=0;s2!=nils3 := make([]int, 0) //len(s3)=0;cap(s3)=0;s3!=nil

所以要判断一个切片是否是空的，要是用len(s) == 0来判断，不应该使用s == nil来判断。

4.9 切片的赋值拷贝

下面的代码中演示了拷贝前后两个变量共享底层数组，对一个切片的修改会影响另一个切片的内容，这点需要特别注意。

func main() {
   	s1 := make([]int, 3) //[0 0 0]	s2 := s1             //将s1直接赋值给s2，s1和s2共用一个底层数组	s2[0] = 100	fmt.Println(s1) //[100 0 0]	fmt.Println(s2) //[100 0 0]}

4.10 切片遍历

切片的遍历方式和数组是一致的，支持索引遍历和for range遍历。

func main() {
   	s := []int{
   1, 3, 5}	for i := 0; i < len(s); i++ {
   		fmt.Println(i, s[i])	}	for index, value := range s {
   		fmt.Println(index, value)	}}

4.11 append()方法为切片添加元素

Go语言的内建函数append()可以为切片动态添加元素。可以一次添加一个元素，可以添加多个元素，也可以添加另一个切片中的元素（后面加…）。

func main(){
   	var s []int	s = append(s, 1)        // [1]	s = append(s, 2, 3, 4)  // [1 2 3 4]	s2 := []int{
   5, 6, 7}  	s = append(s, s2...)    // [1 2 3 4 5 6 7]}

**注意：**通过var声明的零值切片可以在append()函数直接使用，无需初始化。

var s []ints = append(s, 1, 2, 3)

没有必要像下面的代码一样初始化一个切片再传入append()函数使用，

s := []int{
   }  // 没有必要初始化s = append(s, 1, 2, 3)var s = make([]int)  // 没有必要初始化s = append(s, 1, 2, 3)

每个切片会指向一个底层数组，这个数组的容量够用就添加新增元素。当底层数组不能容纳新增的元素时，切片就会自动按照一定的策略进行“扩容”，此时该切片指向的底层数组就会更换。“扩容”操作往往发生在append()函数调用时，所以我们通常都需要用原变量接收append函数的返回值。

举个例子：

func main() {
   	//append()添加元素和切片扩容	var numSlice []int	for i := 0; i < 10; i++ {
   		numSlice = append(numSlice, i)		fmt.Printf("%v  len:%d  cap:%d  ptr:%p\n", numSlice, len(numSlice), cap(numSlice), numSlice)	}}

输出：

[0]  len:1  cap:1  ptr:0xc0000a8000[0 1]  len:2  cap:2  ptr:0xc0000a8040[0 1 2]  len:3  cap:4  ptr:0xc0000b2020[0 1 2 3]  len:4  cap:4  ptr:0xc0000b2020[0 1 2 3 4]  len:5  cap:8  ptr:0xc0000b6000[0 1 2 3 4 5]  len:6  cap:8  ptr:0xc0000b6000[0 1 2 3 4 5 6]  len:7  cap:8  ptr:0xc0000b6000[0 1 2 3 4 5 6 7]  len:8  cap:8  ptr:0xc0000b6000[0 1 2 3 4 5 6 7 8]  len:9  cap:16  ptr:0xc0000b8000[0 1 2 3 4 5 6 7 8 9]  len:10  cap:16  ptr:0xc0000b8000

从上面的结果可以看出：

append()函数将元素追加到切片的最后并返回该切片。

切片numSlice的容量按照1，2，4，8，16这样的规则自动进行扩容，每次扩容后都是扩容前的2倍。

append()函数还支持一次性追加多个元素。例如：

var citySlice []string// 追加一个元素citySlice = append(citySlice, "北京")// 追加多个元素citySlice = append(citySlice, "上海", "广州", "深圳")// 追加切片a := []string{
   "成都", "重庆"}citySlice = append(citySlice, a...)fmt.Println(citySlice) //[北京 上海 广州 深圳 成都 重庆]

4.12 copy()函数复制切片

首先我们来看一个问题：

func main() {
   	a := []int{
   1, 2, 3, 4, 5}	b := a	fmt.Println(a) //[1 2 3 4 5]	fmt.Println(b) //[1 2 3 4 5]	b[0] = 1000	fmt.Println(a) //[1000 2 3 4 5]	fmt.Println(b) //[1000 2 3 4 5]}

由于切片是引用类型，所以a和b其实都指向了同一块内存地址。修改b的同时a的值也会发生变化。

Go语言内建的copy()函数可以迅速地将一个切片的数据复制到另外一个切片空间中，copy()函数的使用格式如下：

copy(destSlice, srcSlice []T)

其中：

srcSlice: 数据来源切片

destSlice: 目标切片

举个例子：

func main() {
   	// copy()复制切片	a := []int{
   1, 2, 3, 4, 5}	c := make([]int, 5, 5)	copy(c, a)     //使用copy()函数将切片a中的元素复制到切片c	fmt.Println(a) //[1 2 3 4 5]	fmt.Println(c) //[1 2 3 4 5]	c[0] = 1000	fmt.Println(a) //[1 2 3 4 5]	fmt.Println(c) //[1000 2 3 4 5]}

4.13 从切片中删除元素

Go语言中并没有删除切片元素的专用方法，我们可以使用切片本身的特性来删除元素。代码如下：

func main() {
   	// 从切片中删除元素	a := []int{
   30, 31, 32, 33, 34, 35, 36, 37}	// 要删除索引为2的元素	a = append(a[:2], a[3:]...)	fmt.Println(a) //[30 31 33 34 35 36 37]}

总结一下就是：要从切片a中删除索引为index的元素，操作方法是a = append(a[:index], a[index+1:]...)

5. 指针

区别于C/C++中的指针，Go语言中的指针不能进行偏移和运算，是安全指针。

要搞明白Go语言中的指针需要先知道3个概念：指针地址、指针类型和指针取值。

5.1 Go语言中的指针介绍

任何程序数据载入内存后，在内存都有他们的地址，这就是指针。而为了保存一个数据在内存中的地址，我们就需要指针变量。

比如，“永远不要高估自己”这句话是我的座右铭，我想把它写入程序中，程序一启动这句话是要加载到内存（假设内存地址0x123456），我在程序中把这段话赋值给变量A，把内存地址赋值给变量B。这时候变量B就是一个指针变量。通过变量A和变量B都能找到我的座右铭。

Go语言中的指针不能进行偏移和运算，因此Go语言中的指针操作非常简单，我们只需要记住两个符号：

&：取地址

*：根据地址取值

5.2 指针地址和指针类型

每个变量在运行时都拥有一个地址，这个地址代表变量在内存中的位置。Go语言中使用&字符放在变量前面对变量进行“取地址”操作。 Go语言中的值类型（int、float、bool、string、array、struct）都有对应的指针类型，如：*int、*int64、*string等。

取变量指针的语法如下：

ptr := &v    // v的类型为T

其中：

v: 代表被取地址的变量，类型为T

ptr: 用于接收地址的变量，ptr的类型就为*T，称做 T 的指针类型。*代表指针。

举个例子：

func main() {
   	a := 10	b := &a	fmt.Printf("a:%d ptr:%p\n", a, &a) // a:10 ptr:0xc00001a078	fmt.Printf("b:%p type:%T\n", b, b) // b:0xc00001a078 type:*int	fmt.Println(&b)                    // 0xc00000e018}

我们来看一下b := &a的图示：

在这里插入图片描述

5.3 指针取值

在对普通变量使用&操作符取地址后会获得这个变量的指针，然后可以对指针使用*操作，也就是指针取值，代码如下。

func main() {
   	//指针取值	a := 10	b := &a // 取变量a的地址，将指针保存到b中	fmt.Printf("type of b:%T\n", b)	c := *b // 指针取值（根据指针去内存取值）	fmt.Printf("type of c:%T\n", c)	fmt.Printf("value of c:%v\n", c)}

输出如下：

type of b:*inttype of c:intvalue of c:10

总结： 取地址操作符&和取值操作符*是一对互补操作符，&取出地址，*根据地址取出地址指向的值。

变量、指针地址、指针变量、取地址、取值的相互关系和特性如下：

对变量进行取地址（&）操作，可以获得这个变量的指针变量。

指针变量的值是指针地址。

对指针变量进行取值（*）操作，可以获得指针变量指向的原变量的值。

指针传值示例：

func modify1(x int) {
   	x = 100}func modify2(x *int) {
   	*x = 100}func main() {
   	a := 10	modify1(a)	fmt.Println(a) // 10	modify2(&a)	fmt.Println(a) // 100}

5.4 new和make

我们先来看一个例子：

func main() {
   	var a *int	*a = 100	fmt.Println(*a)	var b map[string]int	b["沙河娜扎"] = 100	fmt.Println(b)}

执行上面的代码会引发panic，为什么呢？在Go语言中对于引用类型的变量，我们在使用的时候不仅要声明它，还要为它分配内存空间，否则我们的值就没办法存储。而对于值类型的声明不需要分配内存空间，是因为它们在声明的时候已经默认分配好了内存空间。要分配内存，就引出来今天的new和make。 Go语言中new和make是内建的两个函数，主要用来分配内存。

new

new是一个内置的函数，它的函数签名如下：

func new(Type) *Type

其中，

Type表示类型，new函数只接受一个参数，这个参数是一个类型

*Type表示类型指针，new函数返回一个指向该类型内存地址的指针。

new函数不太常用，使用new函数得到的是一个类型的指针，并且该指针对应的值为该类型的零值。举个例子：

func main() {
   	a := new(int)	b := new(bool)	fmt.Printf("%T\n", a) // *int	fmt.Printf("%T\n", b) // *bool	fmt.Println(*a)       // 0	fmt.Println(*b)       // false}

本节开始的示例代码中var a *int只是声明了一个指针变量a但是没有初始化，指针作为引用类型需要初始化后才会拥有内存空间，才可以给它赋值。应该按照如下方式使用内置的new函数对a进行初始化之后就可以正常对其赋值了：

func main() {
   	var a *int	a = new(int)	*a = 10	fmt.Println(*a)}

make

make也是用于内存分配的，区别于new，它只用于slice、map以及chan的内存创建，而且它返回的类型就是这三个类型本身，而不是他们的指针类型，因为这三种类型就是引用类型，所以就没有必要返回他们的指针了。make函数的函数签名如下：

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

make 函数是无可替代的，我们在使用slice、map以及channel的时候，都需要使用make进行初始化，然后才可以对它们进行操作。这个我们在上一章中都有说明，关于channel我们会在后续的章节详细说明。

本节开始的示例中var b map[string]int只是声明变量b是一个map类型的变量，需要像下面的示例代码一样使用make函数进行初始化操作之后，才能对其进行键值对赋值：

func main() {
   	var b map[string]int	b = make(map[string]int, 10)	b["沙河娜扎"] = 100	fmt.Println(b)}

new与make的区别

二者都是用来做内存分配的。

make只用于slice、map以及channel的初始化，返回的还是这三个引用类型本身；

而new用于类型的内存分配，并且内存对应的值为类型零值，返回的是指向类型的指针。

6. Map

Go语言中提供的映射关系容器为map，其内部使用散列表（hash）实现。

6.1 map 介绍

map是一种无序的基于key-value的数据结构，Go语言中的map是引用类型，必须初始化才能使用。

6.2 map定义

Go语言中 map的定义语法如下：

map[KeyType]ValueType

其中，

KeyType: 表示键的类型。

ValueType: 表示键对应的值的类型。

map类型的变量默认初始值为nil，需要使用make()函数来分配内存。语法为：

make(map[KeyType]ValueType, [cap])

其中cap表示map的容量，该参数虽然不是必须的，但是我们应该在初始化map的时候就为其指定一个合适的容量。

6.3 map基本使用

map中的数据都是成对出现的，map的基本使用示例代码如下：

func main() {
   	scoreMap := make(map[string]int, 8)	scoreMap["张三"] = 90	scoreMap["小明"] = 100	fmt.Println(scoreMap)	fmt.Println(scoreMap["小明"])	fmt.Printf("type of a:%T\n", scoreMap)}

输出：

map[小明:100 张三:90]100type of a:map[string]int

map也支持在声明的时候填充元素，例如：

func main() {
   	userInfo := map[string]string{
   		"username": "沙河小王子",		"password": "123456",	}	fmt.Println(userInfo) // map[password:123456 username:沙河小王子]}

6.4 判断某个键是否存在

Go语言中有个判断map中键是否存在的特殊写法，格式如下:

value, ok := map[key]

举个例子：

func main() {
   	scoreMap := make(map[string]int)	scoreMap["张三"] = 90	scoreMap["小明"] = 100	// 如果key存在ok为true,v为对应的值；不存在ok为false,v为值类型的零值	v, ok := scoreMap["张三"]	if ok {
   		fmt.Println(v)	} else {
   		fmt.Println("查无此人")	}}

6.5 map的遍历

Go语言中使用for range遍历map。

func main() {
   	scoreMap := make(map[string]int)	scoreMap["张三"] = 90	scoreMap["小明"] = 100	scoreMap["娜扎"] = 60	for k, v := range scoreMap {
   		fmt.Println(k, v)	}}

但我们只想遍历key的时候，可以按下面的写法：

func main() {
   	scoreMap := make(map[string]int)	scoreMap["张三"] = 90	scoreMap["小明"] = 100	scoreMap["娜扎"] = 60	for k := range scoreMap {
   		fmt.Println(k)	}}

注意： 遍历map时的元素顺序与添加键值对的顺序无关。

6.6 delete()函数删除键值对

使用delete()内建函数从map中删除一组键值对，delete()函数的格式如下：

delete(map, key)

其中：

map: 表示要删除键值对的map

key: 表示要删除的键值对的键

示例代码如下：

func main(){
   	scoreMap := make(map[string]int)	scoreMap["张三"] = 90	scoreMap["小明"] = 100	scoreMap["娜扎"] = 60	delete(scoreMap, "小明")//将小明:100从map中删除	for k,v := range scoreMap{
   		fmt.Println(k, v)	}}

6.7 按照指定顺序遍历map

func main() {
   	rand.Seed(time.Now().UnixNano()) //初始化随机数种子	var scoreMap = make(map[string]int, 200)	for i := 0; i < 100; i++ {
   		key := fmt.Sprintf("stu%02d", i) //生成stu开头的字符串		value := rand.Intn(100)          //生成0~99的随机整数		scoreMap[key] = value	}	//取出map中的所有key存入切片keys	var keys = make([]string, 0, 200)	for key := range scoreMap {
   		keys = append(keys, key)	}	//对切片进行排序	sort.Strings(keys)	//按照排序后的key遍历map	for _, key := range keys {
   		fmt.Println(key, scoreMap[key])	}}

6.8 元素为map类型的切片

下面的代码演示了切片中的元素为map类型时的操作：

func main() {
   	var mapSlice = make([]map[string]string, 3)	for index, value := range mapSlice {
   		fmt.Printf("index:%d value:%v\n", index, value)	}	fmt.Println("after init")	// 对切片中的map元素进行初始化	mapSlice[0] = make(map[string]string, 10)	mapSlice[0]["name"] = "小王子"	mapSlice[0]["password"] = "123456"	mapSlice[0]["address"] = "沙河"	for index, value := range mapSlice {
   		fmt.Printf("index:%d value:%v\n", index, value)	}}

6.9 值为切片类型的map

下面的代码演示了map中值为切片类型的操作：

func main() {
   	var sliceMap = make(map[string][]string, 3)	fmt.Println(sliceMap)	fmt.Println("after init")	key := "中国"	value, ok := sliceMap[key]	if !ok {
   		value = make([]string, 0, 2)	}	value = append(value, "北京", "上海")	sliceMap[key] = value	fmt.Println(sliceMap)}

7. 函数

Go语言中支持函数、匿名函数和闭包，并且函数在Go语言中属于“一等公民”。

7.1 函数定义

Go语言中定义函数使用func关键字，具体格式如下：

func 函数名(参数)(返回值){
       函数体}

其中：

函数名：由字母、数字、下划线组成。但函数名的第一个字母不能是数字。在同一个包内，函数名也称不能重名（包的概念详见后文）。

参数：参数由参数变量和参数变量的类型组成，多个参数之间使用,分隔。

返回值：返回值由返回值变量和其变量类型组成，也可以只写返回值的类型，多个返回值必须用()包裹，并用,分隔。

函数体：实现指定功能的代码块。

我们先来定义一个求两个数之和的函数：

func intSum(x int, y int) int {
   	return x + y}

函数的参数和返回值都是可选的，例如我们可以实现一个既不需要参数也没有返回值的函数：

func sayHello() {
   	fmt.Println("Hello 沙河")}

7.2 函数的调用

定义了函数之后，我们可以通过函数名()的方式调用函数。例如我们调用上面定义的两个函数，代码如下：

func main() {
   	sayHello()	ret := intSum(10, 20)	fmt.Println(ret)}

注意，调用有返回值的函数时，可以不接收其返回值。

7.3 参数

7.3.1 类型简写

函数的参数中如果相邻变量的类型相同，则可以省略类型，例如：

func intSum(x, y int) int {
   	return x + y}

上面的代码中，intSum函数有两个参数，这两个参数的类型均为int，因此可以省略x的类型，因为y后面有类型说明，x参数也是该类型。

7.3.2 可变参数

可变参数是指函数的参数数量不固定。Go语言中的可变参数通过在参数名后加...来标识。

注意：可变参数通常要作为函数的最后一个参数。

举个例子：

func intSum2(x ...int) int {
   	fmt.Println(x) //x是一个切片	sum := 0	for _, v := range x {
   		sum = sum + v	}	return sum}

调用上面的函数：

ret1 := intSum2()ret2 := intSum2(10)ret3 := intSum2(10, 20)ret4 := intSum2(10, 20, 30)fmt.Println(ret1, ret2, ret3, ret4) //0 10 30 60

固定参数搭配可变参数使用时，可变参数要放在固定参数的后面，示例代码如下：

func intSum3(x int, y ...int) int {
   	fmt.Println(x, y)	sum := x	for _, v := range y {
   		sum = sum + v	}	return sum}

调用上述函数：

ret5 := intSum3(100)ret6 := intSum3(100, 10)ret7 := intSum3(100, 10, 20)ret8 := intSum3(100, 10, 20, 30)fmt.Println(ret5, ret6, ret7, ret8) //100 110 130 160

本质上，函数的可变参数是通过切片来实现的。

7.4 返回值

Go语言中通过return关键字向外输出返回值。

7.4.1 多返回值

Go语言中函数支持多返回值，函数如果有多个返回值时必须用()将所有返回值包裹起来。

举个例子：

func calc(x, y int) (int, int) {
   	sum := x + y	sub := x - y	return sum, sub}

7.4.2 返回值命名

函数定义时可以给返回值命名，并在函数体中直接使用这些变量，最后通过return关键字返回。

例如：

func calc(x, y int) (sum, sub int) {
   	sum = x + y	sub = x - y	return}

7.4.3 返回值补充

当我们的一个函数返回值类型为slice时，nil可以看做是一个有效的slice，没必要显示返回一个长度为0的切片。

func someFunc(x string) []int {
   	if x == "" {
   		return nil // 没必要返回[]int{}	}	...}

7.5 变量作用域

7.5.1 全局变量

全局变量是定义在函数外部的变量，它在程序整个运行周期内都有效。在函数中可以访问到全局变量。

package mainimport "fmt"//定义全局变量numvar num int64 = 10func testGlobalVar() {
   	fmt.Printf("num=%d\n", num) //函数中可以访问全局变量num}func main() {
   	testGlobalVar() //num=10}

7.5.2 局部变量

局部变量又分为两种：函数内定义的变量无法在该函数外使用，例如下面的示例代码main函数中无法使用testLocalVar函数中定义的变量x：

func testLocalVar() {
   	//定义一个函数局部变量x,仅在该函数内生效	var x int64 = 100	fmt.Printf("x=%d\n", x)}func main() {
   	testLocalVar()	fmt.Println(x) // 此时无法使用变量x}

如果局部变量和全局变量重名，优先访问局部变量。

package mainimport "fmt"//定义全局变量numvar num int64 = 10func testNum() {
   	num := 100	fmt.Printf("num=%d\n", num) // 函数中优先使用局部变量}func main() {
   	testNum() // num=100}

接下来我们来看一下语句块定义的变量，通常我们会在if条件判断、for循环、switch语句上使用这种定义变量的方式。

func testLocalVar2(x, y int) {
   	fmt.Println(x, y) //函数的参数也是只在本函数中生效	if x > 0 {
   		z := 100 //变量z只在if语句块生效		fmt.Println(z)	}	//fmt.Println(z)//此处无法使用变量z}

还有我们之前讲过的for循环语句中定义的变量，也是只在for语句块中生效：

func testLocalVar3() {
   	for i := 0; i < 10; i++ {
   		fmt.Println(i) //变量i只在当前for语句块中生效	}	//fmt.Println(i) //此处无法使用变量i}

7.6 函数类型与变量

7.6.1 定义函数类型

我们可以使用type关键字来定义一个函数类型，具体格式如下：

type calculation func(int, int) int

上面语句定义了一个calculation类型，它是一种函数类型，这种函数接收两个int类型的参数并且返回一个int类型的返回值。

简单来说，凡是满足这个条件的函数都是calculation类型的函数，例如下面的add和sub是calculation类型。

func add(x, y int) int {
   	return x + y}func sub(x, y int) int {
   	return x - y}

add和sub都能赋值给calculation类型的变量。

var c calculationc = add

7.6.2 函数类型变量

我们可以声明函数类型的变量并且为该变量赋值：

func main() {
   	var c calculation               // 声明一个calculation类型的变量c	c = add                         // 把add赋值给c	fmt.Printf("type of c:%T\n", c) // type of c:main.calculation	fmt.Println(c(1, 2))            // 像调用add一样调用c	f := add                        // 将函数add赋值给变量f1	fmt.Printf("type of f:%T\n", f) // type of f:func(int, int) int	fmt.Println(f(10, 20))          // 像调用add一样调用f}

7.7 高阶函数

高阶函数分为函数作为参数和函数作为返回值两部分。

7.7.1 函数作为参数

函数可以作为参数：

func add(x, y int) int {
   	return x + y}func calc(x, y int, op func(int, int) int) int {
   	return op(x, y)}func main() {
   	ret2 := calc(10, 20, add)	fmt.Println(ret2) //30}

7.7.2 函数作为返回值

函数也可以作为返回值：

func do(s string) (func(int, int) int, error) {
   	switch s {
   	case "+":		return add, nil	case "-":		return sub, nil	default:		err := errors.New("无法识别的操作符")		return nil, err	}}

7.8 匿名函数和闭包

7.8.1 匿名函数

函数当然还可以作为返回值，但是在Go语言中函数内部不能再像之前那样定义函数了，只能定义匿名函数。匿名函数就是没有函数名的函数，匿名函数的定义格式如下：

func(参数)(返回值){
       函数体}

匿名函数因为没有函数名，所以没办法像普通函数那样调用，所以匿名函数需要保存到某个变量或者作为立即执行函数:

func main() {
   	// 将匿名函数保存到变量	add := func(x, y int) {
   		fmt.Println(x + y)	}	add(10, 20) // 通过变量调用匿名函数	//自执行函数：匿名函数定义完加()直接执行	func(x, y int) {
   		fmt.Println(x + y)	}(10, 20)}

匿名函数多用于实现回调函数和闭包。

7.8.2 闭包

闭包指的是一个函数和与其相关的引用环境组合而成的实体。简单来说，闭包=函数+引用环境。首先我们来看一个例子：

func adder() func(int) int {
   	var x int	return func(y int) int {
   		x += y		return x	}}func main() {
   	var f = adder()	fmt.Println(f(10)) //10	fmt.Println(f(20)) //30	fmt.Println(f(30)) //60	f1 := adder()	fmt.Println(f1(40)) //40	fmt.Println(f1(50)) //90}

变量f是一个函数并且它引用了其外部作用域中的x变量，此时f就是一个闭包。在f的生命周期内，变量x也一直有效。闭包进阶示例1：

func adder2(x int) func(int) int {
   	return func(y int) int {
   		x += y		return x	}}func main() {
   	var f = adder2(10)	fmt.Println(f(10)) //20	fmt.Println(f(20)) //40	fmt.Println(f(30)) //70	f1 := adder2(20)	fmt.Println(f1(40)) //60	fmt.Println(f1(50)) //110}

闭包进阶示例2：

func makeSuffixFunc(suffix string) func(string) string {
   	return func(name string) string {
   		if !strings.HasSuffix(name, suffix) {
   			return name + suffix		}		return name	}}func main() {
   	jpgFunc := makeSuffixFunc(".jpg")	txtFunc := makeSuffixFunc(".txt")	fmt.Println(jpgFunc("test")) //test.jpg	fmt.Println(txtFunc("test")) //test.txt}

闭包进阶示例3：

func calc(base int) (func(int) int, func(int) int) {
   	add := func(i int) int {
   		base += i		return base	}	sub := func(i int) int {
   		base -= i		return base	}	return add, sub}func main() {
   	f1, f2 := calc(10)	fmt.Println(f1(1), f2(2)) //11 9	fmt.Println(f1(3), f2(4)) //12 8	fmt.Println(f1(5), f2(6)) //13 7}

闭包其实并不复杂，只要牢记闭包=函数+引用环境。

7.9 defer语句

Go语言中的defer语句会将其后面跟随的语句进行延迟处理。在defer归属的函数即将返回时，将延迟处理的语句按defer定义的逆序进行执行，也就是说，先被defer的语句最后被执行，最后被defer的语句，最先被执行。

举个例子：

func main() {
   	fmt.Println("start")	defer fmt.Println(1)	defer fmt.Println(2)	defer fmt.Println(3)	fmt.Println("end")}

输出结果：

startend321

由于defer语句延迟调用的特性，所以defer语句能非常方便的处理资源释放问题。比如：资源清理、文件关闭、解锁及记录时间等。

7.9.1 defer执行时机

在Go语言的函数中return语句在底层并不是原子操作，它分为给返回值赋值和RET指令两步。而defer语句执行的时机就在返回值赋值操作后，RET指令执行前。具体如下图所示：

在这里插入图片描述

7.9.2 defer经典案例

阅读下面的代码，写出最后的打印结果。

func f1() int {
   	x := 5	defer func() {
   		x++	}()	return x}func f2() (x int) {
   	defer func() {
   		x++	}()	return 5}func f3() (y int) {
   	x := 5	defer func() {
   		x++	}()	return x}func f4() (x int) {
   	defer func(x int) {
   		x++	}(x)	return 5}func main() {
   	fmt.Println(f1())	fmt.Println(f2())	fmt.Println(f3())	fmt.Println(f4())}

7.10 内置函数介绍

内置函数	介绍
close	主要用来关闭channel
len	用来求长度，比如string、array、slice、map、channel
new	用来分配内存，主要用来分配值类型，比如int、struct。返回的是指针
make	用来分配内存，主要用来分配引用类型，比如chan、map、slice
append	用来追加元素到数组、slice中
panic和recover	用来做错误处理

7.10.1 panic/recover

Go语言中目前（Go1.12）是没有异常机制，但是使用panic/recover模式来处理错误。 panic可以在任何地方引发，但recover只有在defer调用的函数中有效。首先来看一个例子：

func funcA() {
   	fmt.Println("func A")}func funcB() {
   	panic("panic in B")}func funcC() {
   	fmt.Println("func C")}func main() {
   	funcA()	funcB()	funcC()}

输出：

func Apanic: panic in Bgoroutine 1 [running]:main.funcB(...)        .../code/func/main.go:12main.main()        .../code/func/main.go:20 +0x98

程序运行期间funcB中引发了panic导致程序崩溃，异常退出了。这个时候我们就可以通过recover将程序恢复回来，继续往后执行。

func funcA() {
   	fmt.Println("func A")}func funcB() {
   	defer func() {
   		err := recover()		//如果程序出出现了panic错误,可以通过recover恢复过来		if err != nil {
   			fmt.Println("recover in B")		}	}()	panic("panic in B")}func funcC() {
   	fmt.Println("func C")}func main() {
   	funcA()	funcB()	funcC()}

注意：

recover()必须搭配defer使用。

defer一定要在可能引发panic的语句之前定义。

转载地址：https://csp1999.blog.csdn.net/article/details/110679378 如侵犯您的版权，请留言回复原文章的地址，我们会给您删除此文章，给您带来不便请您谅解！

上一篇：Go语言基本语法 (下)

下一篇：@JsonFormat和@DataFormat注解解决前后端日期格式一致性问题

发表评论

关于作者

喝酒易醉，品茶养心，人生如梦，品茶悟道，何以解忧？唯有杜康！

-- 愿君每日到此一游！

1. 运算符

2. 数组

2.1 数组定义：

2.2 数组的初始化：

2.3 数组的遍历：

3. 多维数组

3.1 二维数组的定义：

3.2 二维数组的遍历：

3.4 数组是值类型

4. 切片

4.1 引子

4.1 切片的定义

4.2 切片声明语法

4.3 切片的长度和容量

4.4 切片表达式

4.5 使用make()函数构造切片

4.6 切片的本质

4.7 判断切片是否为空

4.8 切片不能直接比较

4.9 切片的赋值拷贝

4.10 切片遍历

4.11 append()方法为切片添加元素

4.12 copy()函数复制切片

4.13 从切片中删除元素

5. 指针

5.1 Go语言中的指针介绍

5.2 指针地址和指针类型

5.3 指针取值

5.4 new和make

new

make

new与make的区别

6. Map

6.1 map 介绍

6.2 map定义

6.3 map基本使用

6.4 判断某个键是否存在

6.5 map的遍历

6.6 delete()函数删除键值对

6.7 按照指定顺序遍历map

6.8 元素为map类型的切片

6.9 值为切片类型的map

7. 函数

7.1 函数定义

7.2 函数的调用

7.3 参数

7.3.1 类型简写

7.3.2 可变参数

7.4 返回值

7.4.1 多返回值

7.4.2 返回值命名

7.4.3 返回值补充

7.5 变量作用域

7.5.1 全局变量

7.5.2 局部变量

7.6 函数类型与变量

7.6.1 定义函数类型

7.6.2 函数类型变量

7.7 高阶函数

7.7.1 函数作为参数

7.7.2 函数作为返回值

7.8 匿名函数和闭包

7.8.1 匿名函数

7.8.2 闭包

7.9 defer语句

7.9.1 defer执行时机

7.9.2 defer经典案例

7.10 内置函数介绍

7.10.1 panic/recover

发表评论

最新留言

关于作者

推荐文章