GO语言基础

一、绪论

1 Go语言介绍

Go 即Golang，是Google公司2009年11月正式对外公开的一门编程语言。

Go是静态强类型语言，是区别于解析型语言的编译型语言(静态：类型固定 强类型：不同类型不允许直接运算)。

解析型语言——源代码是先翻译为中间代码，然后由解析器对代码进行解释执行。

编译型语言——源代码编译生成机器语言，然后由机器直接执行机器码即可执行。

2 Go语言特性

• 跨平台的编译型语言

• 交叉编译（在win平台可编译出mac平台的可执行文件）

• 语法接近C语言

• 管道（channel），切片（slice），并发（routine）

• 有垃圾回收的机制

• 支持面向对象和面向过程的编程模式

3 go适合做什么

• 服务端开发
• 分布式系统，微服务
• 网络编程
• 区块链开发
• 内存KV数据库，例如boltDB、levelDB
• 云平台

4 下载和安装

开发环境：

• 官网下载地址为：https://golang.org/dl/

• 如果打不开可以使用这个地址：https://golang.google.cn/dl/

IDE：

• GoLand

• vscode

5 配置GOPATH和GOROOT

• GOPATH：代码存放路径，该目录下有三个文件夹（如果没有，要手动创建）,
  windows和mac默认在用户名下的go文件夹（GOPATH=“/Users/用户名/go”），所有代码必须写在这个路径下的src文件夹下，否则无法编译，可以手动修改。

-src——源码（包含第三方的和自己项目的）
-bin——编译生成的可执行程序
-pkg——编译时生成的对象文件

• GOROOT：go开发工具包的安装路径，默认：C:\go

  将GOROOT下的bin路径加入环境变量（默认已处理），这样任意位置敲 go 都能找到该命令

6 命令介绍

直接在终端中输入 go help 即可显示所有的 go 命令以及相应命令功能简介，主要有下面这些:

• build: 编译包和依赖
• clean: 移除对象文件（go clean ：删除编译的可执行文件）
• doc: 显示包或者符号的文档
• env: 打印go的环境信息
• bug: 启动错误报告
• fix: 运行go tool fix
• fmt: 运行gofmt进行格式化（go fmt ：自动将代码格式）
• generate: 从processing source生成go文件
• get: 下载并安装包和依赖（go get github.com/astaxie/beego：下载beego框架）
• install: 编译并安装包和依赖（go install 项目名：会将go编译，并放到bin路径下）
• list: 列出包
• run: 编译并运行go程序
• test: 运行测试
• tool: 运行go提供的工具
• version: 显示go的版本
• vet: 运行go tool vet

6.1 build 和 run 命令

就像其他静态类型语言一样，要执行 go 程序,需要先编译，然后在执行产生的可执行文件。go build 命令就是用来编译 go程序生成可执行文件的。但并不是所有的 go 程序都可以编译生成可执行文件的, 要生成可执行文件，go程序需要满足两个条件:

• 该go程序需要属于main包
• 在main包中必须还得包含main函数

也就是说go程序的入口就是 main.main, 即main包下的main函数,　例子(test.go):

编译hello.go,然后运行可执行程序:

$ go build test.go   # 将会生成可执行文件 test
$ ./test           # 运行可执行文件
Hello, World!

上面就是 go build 的基本用法，另外如果使用 go build 编译的不是一个可执行程序，而是一个包，那么将不会生成可执行文件。

而 go run 命令可以将上面两步并为一步执行(不会产生中间文件)。

$ go run test.go
Hello, World!

上面两个命令都是在开发中非常常用的。

此外 go clean 命令，可以用于将清除产生的可执行程序:

$ go clean    # 不加参数，可以删除当前目录下的所有可执行文件
$ go clean hello.go  # 会删除对应的可执行文件

6.2 get 命令

这个命令同样也是很常用的，我们可以使用它来下载并安装第三方包, 使用方式:

go get src

从指定源上面下载或者更新指定的代码和依赖，并对他们进行编译和安装，例如我们想使用 beego 来开发web应用，我们首先就需要获取 beego:

go get github.com/astaxie/beego

这条命令将会自动下载安装 beego 以及它的依赖，然后我们就可以使用下面的方式使用:

package main

import "github.com/astaxie/beego"   # 这里需要使用 src 下的完整路径

func main() {
    beego.Run()
}

7 第一个go程序

![第一个go程序](../../../../桌面备份/note/第一个go程序.jpg)// go语言的注释

/*多行

注释*/

package main // 声明包名是main，每一个go文件都必须属于某一个包

import "fmt" // 导入内置包

func main() {  // func函数关键字，定义main函数 类似c语言，编译型语言需要有入口函数： main包下的main函数
	fmt.Println("hello,world!")  // 打印函数
}

bulid命令编译，再执行exe：

或者使用run命令，编译并执行：

go run 1.go

8 命名规范

Go语言中的函数名、变量名、常量名、类型名、语句标号和包名等所有的命名，都遵循一个简单的命名规则：

1 一个名字必须以一个字母（Unicode字母）或下划线开头，后面可以跟任意数量的字母、数字或下划线

2 大写字母和小写字母是不同的：Name和name是两个不同的变量

3 关键字和保留字都不建议用作变量名

Go语言中关键字有25个；关键字不能用于自定义名字，只能在特定语法结构中使用。

break      default       func     interface   select
case       defer         go       map         struct
chan       else          goto     package     switch
const      fallthrough   if       range       type
continue   for           import   return      var

go语言中有37个保留字，主要对应内建的常量、类型和函数

内建常量: true false iota nil

内建类型:  int int8 int16 int32 int64
          uint uint8 uint16 uint32 uint64 uintptr
          float32 float64 complex128 complex64
          bool byte rune string error

内建函数: make len cap new append copy close delete
          complex real imag
          panic recover

注意：

1. 这些保留字并不是关键字，可以在定义中重新使用它们。在一些特殊的场景中重新定义它们也是有意义的，但是也要注意避免过度而引起语义混乱
2. 如果一个名字是在函数内部定义，那么它就只在函数内部有效。如果是在函数外部定义，那么将在当前包的所有文件中都可以访问。名字的开头字母的大小写决定了名字在包外的可见性。如果一个名字是大写字母开头的（必须是在函数外部定义的包级名字；包级函数名本身也是包级名字），那么它将是导出的，也就是说可以被外部的包访问，例如fmt包的Printf函数就是导出的，可以在fmt包外部访问。包本身的名字一般总是用小写字母
3. 名字的长度没有逻辑限制，但是Go语言的风格是尽量使用短小的名字，对于局部变量尤其是这样；你会经常看到i之类的短名字，而不是冗长的theLoopIndex命名。通常来说，如果一个名字的作用域比较大，生命周期也比较长，那么用长的名字将会更有意义
4. 在习惯上，Go语言程序员推荐使用 驼峰式 命名，当名字由几个单词组成时优先使用大小写分隔，而不是优先用下划线分隔。因此，在标准库有QuoteRuneToASCII和parseRequestLine这样的函数命名，但是一般不会用quote_rune_to_ASCII和parse_request_line这样的命名。而像ASCII和HTML这样的缩略词则避免使用大小写混合的写法，它们可能被称为htmlEscape、HTMLEscape或escapeHTML，但不会是escapeHtml
5. go文件的名字，建议用下划线的方式命名（参见go源码）

二、变量和常量

1 定义单个变量

func main(){
	// 定义变量的第一种方法：全定义 var name type/var关键字 变量名 变量类型
	// var name type = initialvalue  该语法可以声明并初始化
	var age int = 10 // 变量如果声明就必须在后面使用，否则会报错
	fmt.Println(age)

	// 定义变量的第二种方法：类型推导 var name = initialvalue  var关键字 变量名 = 值
	// Go 能够自动推断具有初始值的变量的类型
	var a = 50
	fmt.Println(a)
	fmt.Printf("%T", a) // %T 打印变量a的类型
    
    // 定义变量的第三种方法：简略声明 var和类型都不写
    // 简短声明要求 := 操作符左边的所有变量都有初始值
	b:=20
	fmt.Println(b)
}

2 定义多个变量

Go 能够通过一条语句声明多个变量。

// 定义多个变量var name1, name2 type = initialvalue1, initialvalue
var s1,s2 int = 10,20
fmt.Println(s1,s2)

在有些情况下，我们可能会想要在一个语句中声明不同类型的变量。其语法如下：

var (  
    name1 = initialvalue1,
    name2 = initialvalue2
)

使用上述语法，下面的程序声明不同类型的变量。

package main

import "fmt"

func main() {
    var (
        name   = "naveen"
        age    = 29
        height int
    )
    fmt.Println("my name is", name, ", age is", age, "and height is", height)
}

3 注意

简短声明的语法要求 := 操作符的左边至少有一个变量是尚未声明的。考虑下面的程序：

package main

import "fmt"

func main() {
    a, b := 20, 30 // 声明变量a和b
    fmt.Println("a is", a, "b is", b)
    b, c := 40, 50 // b已经声明，但c尚未声明
    fmt.Println("b is", b, "c is", c)
    b, c = 80, 90 // 给已经声明的变量b和c赋新值
    fmt.Println("changed b is", b, "c is", c)
}

在上面程序中的第 8 行，由于 b 已经被声明，而 c 尚未声明，因此运行成功

但是如果我们运行下面的程序

package main

import "fmt"

func main() {  
    a, b := 20, 30 // 声明a和b
    fmt.Println("a is", a, "b is", b)
    a, b := 40, 50 // 错误，没有尚未声明的变量
}

变量也可以在运行时进行赋值。考虑下面的程序：

package main

import (  
    "fmt"
    "math"
)

func main() {  
    a, b := 145.8, 543.8
    c := math.Min(a, b)
    fmt.Println("minimum value is ", c)
}

在上面的程序中，c 的值是运行过程中计算得到的，即 a 和 b 的最小值

4 常量

常量是一个简单值的标识符，在程序运行时，不会被修改的量。

常量中的数据类型只可以是布尔型、数字型（整数型、浮点型和复数）和字符串型。

常量的定义格式：

const identifier [type] = value

你可以省略类型说明符 [type]，因为编译器可以根据变量的值来推断其类型。

• 显式类型定义： const b string = "abc"
• 隐式类型定义： const b = "abc"

多个相同类型的声明可以简写为：

const c_name1, c_name2 = value1, value2

顾名思义，常量不能再重新赋值为其他的值。因此下面的程序将不能正常工作，它将出现一个编译错误: cannot assign to a.。

package main

func main() {  
    const a = 55 // 允许
    a = 89       // 不允许重新赋值
}

常量的值会在编译的时候确定。因为函数调用发生在运行时，所以不能将函数的返回值赋值给常量。

5 iota

iota，特殊常量，可以认为是一个可以被编译器修改的常量。

iota 在 const关键字出现时将被重置为 0(const 内部的第一行之前)，const 中每新增一行常量声明将使 iota 计数一次(iota 可理解为 const 语句块中的行索引)。

iota 可以被用作枚举值：

const (
    a = iota
    b = iota
    c = iota
)

第一个 iota 等于 0，每当 iota 在新的一行被使用时，它的值都会自动加 1；所以 a=0, b=1, c=2 可以简写为如下形式：

const (
    a = iota
    b
    c
)

实例：

package main

import "fmt"

func main() {
    const (
            a = iota   //0
            b          //1
            c          //2
            d = "ha"   //独立值，iota += 1
            e          //"ha"   iota += 1
            f = 100    //iota +=1
            g          //100  iota +=1
            h = iota   //7,恢复计数
            i          //8
    )
    fmt.Println(a,b,c,d,e,f,g,h,i)
}

以上实例运行结果为：

0 1 2 ha ha 100 100 7 8

三、运算符

1 算数运算符

下表列出了所有Go语言的算术运算符。假定 A 值为 10，B 值为 20。

运算符	描述	实例
+	相加	A + B 输出结果 30
-	相减	A - B 输出结果 -10
*	相乘	A * B 输出结果 200
/	相除	B / A 输出结果 2
%	求余	B % A 输出结果 0
++	自增	A++ 输出结果 11
–	自减	A-- 输出结果 9

2 关系运算符

下表列出了所有Go语言的关系运算符。假定 A 值为 10，B 值为 20。

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

3 逻辑运算符

下表列出了所有Go语言的逻辑运算符。假定 A 值为 True，B 值为 False。

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

4 位运算符

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

下表列出了位运算符 &, |, 和 ^ 的计算：

p	q	p & q	p | q	p ^ q
0	0	0	0	0
0	1	0	1	1
1	1	1	1	0
1	0	0	1	1

Go 语言支持的位运算符如下表所示。假定 A 为60，B 为13：

运算符	描述	实例
&	按位与运算符"&"是双目运算符。 其功能是参与运算的两数各对应的二进位相与。	(A & B) 结果为 12, 二进制为 0000 1100
|	按位或运算符"|"是双目运算符。 其功能是参与运算的两数各对应的二进位相或	(A | B) 结果为 61, 二进制为 0011 1101
^	按位异或运算符"^"是双目运算符。 其功能是参与运算的两数各对应的二进位相异或，当两对应的二进位相异时，结果为1。	(A ^ B) 结果为 49, 二进制为 0011 0001
<<	左移运算符"<<“是双目运算符。左移n位就是乘以2的n次方。 其功能把”<<“左边的运算数的各二进位全部左移若干位，由”<<"右边的数指定移动的位数，高位丢弃，低位补0。	A << 2 结果为 240 ，二进制为 1111 0000
>>	右移运算符">>“是双目运算符。右移n位就是除以2的n次方。 其功能是把”>>“左边的运算数的各二进位全部右移若干位，”>>"右边的数指定移动的位数。	A >> 2 结果为 15 ，二进制为 0000 1111

5 赋值运算符

下表列出了所有Go语言的赋值运算符。

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

6 其它运算符

下表列出了Go语言的其他运算符。

运算符	描述	实例
&	返回变量存储地址	&a; 将给出变量的实际地址。
*	指针变量。	*a; 是一个指针变量

7 运算符优先级

有些运算符拥有较高的优先级，二元运算符的运算方向均是从左至右。下表列出了所有运算符以及它们的优先级，由上至下代表优先级由高到低：

优先级	运算符
5	* / % << >> & &^
4	+ - | ^
3	== != < <= > >=
2	&&
1	||

当然，你可以通过使用括号来临时提升某个表达式的整体运算优先级。

四、数据类型

下面是 Go 支持的基本类型：

• bool 布尔型
• 数字类型
  • int8, int16, int32, int64, int 整型
  • uint8, uint16, uint32, uint64, uint 无符号整型
  • float32, float64 浮点型
  • complex64, complex128 复数
  • byte 类似 uint8
  • rune 类似 int32
• string 字符串类型

1 bool

bool 类型表示一个布尔值，值为 true 或者 false

2 有符号整型

int8：表示 8 位有符号整型
大小：8 位
范围：-128～127

int16：表示 16 位有符号整型
大小：16 位
范围：-32768～32767

int32：表示 32 位有符号整型
大小：32 位
范围：-2147483648～2147483647

int64：表示 64 位有符号整型
大小：64 位
范围：-9223372036854775808～9223372036854775807

int：根据不同的底层平台（Underlying Platform），表示 32 或 64 位整型。除非对整型的大小有特定的需求，否则你通常应该使用 int 表示整型。
大小：在 32 位系统下是 32 位，而在 64 位系统下是 64 位。
范围：在 32 位系统下是 -2147483648～2147483647，而在 64 位系统是 -9223372036854775808～9223372036854775807。

3 无符号整型

uint8：表示 8 位无符号整型
大小：8 位
范围：0～255

uint16：表示 16 位无符号整型
大小：16 位
范围：0～65535

uint32：表示 32 位无符号整型
大小：32 位
范围：0～4294967295

uint64：表示 64 位无符号整型
大小：64 位
范围：0～18446744073709551615

uint：根据不同的底层平台，表示 32 或 64 位无符号整型。
大小：在 32 位系统下是 32 位，而在 64 位系统下是 64 位。
范围：在 32 位系统下是 0～4294967295，而在 64 位系统是 0～18446744073709551615。

4 浮点型

float32：32 位浮点数
float64：64 位浮点数

5 复数类型

complex64：实部和虚部都是 float32 类型的的复数。
complex128：实部和虚部都是 float64 类型的的复数。

内建函数 complex用于创建一个包含实部和虚部的复数。complex 函数的定义如下：

func complex(r, i FloatType) ComplexType

该函数的参数分别是实部和虚部，并返回一个复数类型。实部和虚部应该是相同类型，也就是 float32 或 float64。如果实部和虚部都是 float32 类型，则函数会返回一个 complex64 类型的复数。如果实部和虚部都是 float64 类型，则函数会返回一个 complex128 类型的复数。

还可以使用简短语法来创建复数：

c := 6 + 7i

6 string 类型

在 Golang 中，字符串是字节的集合。如果你现在还不理解这个定义，也没有关系。我们可以暂且认为一个字符串就是由很多字符组成的。我们后面会在一个教程中深入学习字符串。 下面编写一个使用字符串的程序。

package main

import (  
    "fmt"
)

func main() {  
    first := "Naveen"
    last := "Ramanathan"
    name := first +" "+ last
    fmt.Println("My name is",name)
}

上面程序中，first 赋值为字符串 “Naveen”，last 赋值为字符串 “Ramanathan”。+ 操作符可以用于拼接字符串。我们拼接了 first、空格

和 last，并将其赋值给 name。上述程序将打印输出 My name is Naveen Ramanathan。

7 类型转换

Go 有着非常严格的强类型特征。Go 没有自动类型提升或类型转换。

package main

import (  
    "fmt"
)

func main() {  
    i := 55      //int
    j := 67.8    //float64
    sum := i + j //不允许 int + float64
    fmt.Println(sum)
}

上面的代码在 C 语言中是完全合法的，然而在 Go 中，却是行不通的。i 的类型是 int ，而 j 的类型是 float64 ，我们正试图把两个不同类型的数相加，Go 不允许这样的操作。如果运行程序，你会得到 main.go:10: invalid operation: i + j (mismatched types int and float64)。

要修复这个错误，i 和 j 应该是相同的类型。在这里，我们把 j 转换为 int 类型。把 v 转换为 T 类型的语法是 T(v)。

package main

import (  
    "fmt"
)

func main() {  
    i := 55      //int
    j := 67.8    //float64
    sum := i + int(j) //j is converted to int 舍弃小数点后的数字
    fmt.Println(sum)
}

现在，当你运行上面的程序时，会看见输出 122。

赋值的情况也是如此。把一个变量赋值给另一个不同类型的变量，需要显式的类型转换。下面程序说明了这一点。

package main

import (  
    "fmt"
)

func main() {  
    i := 10
    var j float64 = float64(i) // 若没有显式转换，该语句会报错
    fmt.Println("j", j)
}

在第 9 行，i 转换为 float64 类型，接下来赋值给 j。如果不进行类型转换，当你试图把 i 赋值给 j 时，编译器会抛出错误。

8 数据类型的默认值

如果只定义不赋值，则：

• 数字类型是0
• 字符串类型是空字符串
• 布尔类型是false

func main() {
	var a int
	var b string
	var c bool
	fmt.Println(a,b,c)
}

五、条件语句

1 if…else语句

func main() {
	var a int = 10
	if a<20 {
		fmt.Println("如果条件为true则执行if内部")
	}else {
		fmt.Println("如果条件为false则执行else内部")
	}

}

2 switch语句

switch 语句用于基于不同条件执行不同动作，每一个 case 分支都是唯一的，从上至下逐一测试，直到匹配为止。

switch 语句执行的过程从上至下，直到找到匹配项，与c语言不同，匹配项后面也不需要再加 break。

switch 默认情况下 case 最后自带 break 语句，匹配成功后就不会执行其他 case，如果我们需要执行后面的 case，可以使用

fallthrough 。

func main() {
	/* 定义局部变量 */
	var grade string = "B"
	var marks int = 90

	switch marks {
	case 90: grade = "A"
	case 80: grade = "B"
	case 50,60,70 : grade = "C"
	default: grade = "D"
	}

	switch {
	case grade == "A" :
		fmt.Printf("优秀!\n" )
	case grade == "B", grade == "C" :
		fmt.Printf("良好\n" )
	case grade == "D" :
		fmt.Printf("及格\n" )
	case grade == "F":
		fmt.Printf("不及格\n" )
	default:
		fmt.Printf("差\n" );
	}
	fmt.Printf("你的等级是 %s\n", grade );
}

六、循环语句

Go没有while循环语句，只有for循环。

for 循环是一个循环控制结构，可以执行指定次数的循环。

Go 语言的 For 循环有 3 种形式，只有其中的一种使用分号。

和 C 语言的 for 一样：

for init; condition; post { }

和 C 的 while 一样：

for condition { }

和 C 的 for(;;) 一样：

for { }

• init： 一般为赋值表达式，给控制变量赋初值；
• condition： 关系表达式或逻辑表达式，循环控制条件；
• post： 一般为赋值表达式，给控制变量增量或减量。

for 循环的range格式可以对 slice、map、数组、字符串等进行迭代循环。格式如下：

for key, value := range oldMap {
    newMap[key] = value
}

计算 1 到 10 的数字之和：

package main

import "fmt"

func main() {
    sum := 0
    for i := 0; i <= 10; i++ {
        sum += i
    }
    fmt.Println(sum)
}

init 和 post 参数是可选的，我们可以直接省略它，类似 While 语句。

func main() {
        sum := 1
        for ; sum <= 10; {
                sum += sum
        }
        fmt.Println(sum)

        // 这样写也可以，更像 While 语句形式
        for sum <= 10{
                sum += sum
        }
        fmt.Println(sum)
}

无限循环

func main() {
        sum := 0
        for {
            sum++ // 无限循环下去
        }
        fmt.Println(sum) // 无法输出
}
要停止无限循环，可以在命令窗口按下ctrl-c 。

• 关键字break

  break 语句用于在完成正常执行之前突然终止 for 循环，之后程序将会在 for 循环下一行代码开始执行。

• 关键字continue

  continue 语句用来跳出 for 循环中当前循环。在 continue 语句后的所有的 for 循环语句都不会在本次循环中执行。循环体会在一下次循环中继续执行。

七、函数

函数是基本的代码块，用于执行一个任务。

Go 语言至少有一个入口main() 函数。

1 函数定义

函数定义的格式如下：

func function_name( [parameter list] ) [return_types] {
   函数体
} // 函数的作用范围就在大括号之间{}

函数定义解析：

• func：函数由 func 开始声明
• function_name：函数名称，参数列表和返回值类型构成了函数签名。
• parameter list：参数列表，参数就像一个占位符，当函数被调用时，你可以将值传递给参数，这个值被称为实际参数。参数列表指定的是参数类型、顺序、及参数个数。参数是可选的，也就是说函数也可以不包含参数。声明一个参数的语法采用 参数名 参数类型 的方式，多个参数的声明用逗号隔开。
• return_types：返回类型，规定了函数的返回值类型return_types。有些功能不需要返回值，这种情况下 return_types 不是必须的。
• 函数体：函数定义的代码集合。

举例：

// 定义一个函数
func max(a,b int) int { //如果有连续若干个参数，它们的类型一致，那么我们无须一一罗列，只需在最后一个参数后添加该类型。
	ret := a
	if a>b{
		fmt.Println("a比b大")
	}else if a==b {
		fmt.Println("a等于b")
	}else {
		fmt.Println("b比a大")
		ret = b
	}
	return ret
}

2 函数调用

调用函数，（如果需要参数）向函数传递参数，（如果有返回值）并得到返回值，例如：

func main() {
	ret := max(10,20) // 调用函数，得到返回值
	fmt.Println(ret)
}

得到输出：b比a大\n20

3 其它

调用函数，可以通过两种方式来传递参数：值传递和引用传递。

默认情况下，Go 语言使用的是值传递，即在调用过程中不会影响到实际参数。

Go 语言支持一个函数可以有多个返回值。如果一个函数有多个返回值，那么这些返回值必须用括号括起来。

func swap(x, y string) (string, string) { //这些返回值必须用括号括起来
   return y, x
}

func main() {
   a, b := swap("Google", "baidu")
   fmt.Println(a, b)
}

还可以在定义的时候命名返回值，从函数中可以返回一个命名值。

func rectProps(length, width float64)(area, perimeter float64) {  
    area = length * width
    perimeter = (length + width) * 2
    return // 不需要明确指定返回值，默认返回 area, perimeter 的值
}
/*请注意, 函数中的 return 语句没有显式返回任何值。由于 area 和 perimeter 在函数声明中指定为返回值, 因此当遇到 return 语句时, 它们将自动从函数返回。*/

下划线_在 Go 中被用作空白符，可以用作表示任何类型的任何值。

func swap(x, y string) (string, string) {
	return y, x
}

func main() {
	a, _ := swap("Google", "baidu") // 空白符_ 用来跳过不想要的返回结果
	fmt.Println(a)
}

4 函数作为另外一个函数的实参

Go 语言可以很灵活的创建函数，并作为另外一个函数的实参。

func square(a int) int {
	return a*a
}
func swap(a,b int) (int,int){
	return b,a
}
func main() {
	reta,retb := swap(20,square(5))
	fmt.Println(reta,retb)
}

5 闭包和匿名函数

Go 语言支持匿名函数，可作为闭包。匿名函数是一个"内联"语句或表达式。匿名函数的优越性在于可以直接使用函数内的变量，不必申明。

func getSequence() func() int {
   i:=0
   return func() int {
      i+=1
     return i  
   }
}

func main(){
   /* nextNumber 为一个函数，函数 i 为 0 */
   nextNumber := getSequence()  

   /* 调用 nextNumber 函数，i 变量自增 1 并返回 */
   fmt.Println(nextNumber())
   fmt.Println(nextNumber())
   fmt.Println(nextNumber())
   
   /* 创建新的函数 nextNumber1，并查看结果 */
   nextNumber1 := getSequence()  
   fmt.Println(nextNumber1())
   fmt.Println(nextNumber1())
}

以上代码执行结果为：

1
2
3
1
2

八、数组

Go 语言提供了数组类型的数据结构。

数组是同一类型元素的集合，这种类型可以是任意的原始类型例如整型、字符串或者自定义类型。例如，整数集合 5,8,9,79,76 形成一个

数组。Go 语言中不允许混合不同类型的元素，例如包含字符串和整数的数组。（当然，如果是 interface{} 类型数组，可以包含任意类

型）

1 声明数组

Go 语言数组声明需要指定元素类型及元素个数，语法格式如下：

var variable_name [SIZE] variable_type

以上为一维数组的定义方式。举例：

var a [3]int

var a[3]int 声明了一个长度为 3 的整型数组。数组中的所有元素都被自动赋值为数组类型的零值，在这种情况下，a 是一个整型数组，

因此 a 的所有元素都被赋值为 0，即 int 型的零值。运行上述程序将 输出 [0 0 0]。

以下定义了数组 balance 长度为 10 类型为 float32：

var balance [10] float32

数组的索引从 0 开始到 length - 1 结束。

2 初始化数组

先声明，再赋值：

var arr [5]int // 声明数组
arr[0] = 1 // 通过索引赋值

声明并赋值：

var arr = [5]int{1,2,3,4,5} // 全定义
arr := [5]int{1,2,3,4,5} // 简便定义

如果数组长度不确定，可以使用 ...代替数组的长度，编译器会根据元素个数自行推断数组的长度：

var balance = [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
或
balance := [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}

如果设置了数组的长度，我们还可以通过指定下标来初始化元素：

//  将索引为 1 和 3 的元素初始化
balance := [5]float32{1:2.0,3:7.0}

初始化数组中 {} 中的元素个数不能大于[]中的数字。

如果忽略[]中的数字不设置数组大小，Go 语言会根据元素的个数来设置数组的大小：

// []内可以不写，自动推算
arr := []int{1,2,3,4,5} 

数组一经声明 ，长度固定，无法改变。

Go 中的数组是值类型而不是引用类型。这意味着当数组赋值给一个新的变量时，该变量会得到一个原始数组的一个副本。如果对新变量

进行更改，则不会影响原始数组。

同样，当数组作为参数传递给函数时，它们是按值传递，而原始数组保持不变。

3 访问数组元素

数组元素可以通过索引（位置）来读取。格式为数组名后加中括号，中括号中为索引的值（从0开始）。

arr := []int{1,2,3,4,5}
arr[3] = 100  // 索引取值

4 多维数组

Go 语言支持多维数组，以下为常用的多维数组声明方式：

var variable_name [SIZE1][SIZE2]...[SIZEN] variable_type

以下实例声明了三维的整型数组：

var threedim [5][10][4]int

多维数组可通过大括号来初始值。以下实例为一个 3 行 4 列的二维数组：

a := [3][4]int{  
 {0, 1, 2, 3} ,   /*  第一行索引为 0 */
 {4, 5, 6, 7} ,   /*  第二行索引为 1 */
 {8, 9, 10, 11}, // 这里要有逗号,   /* 第三行索引为 2 */ 
}

5 数组长度

通过将数组作为参数传递给 len 函数，可以得到数组的长度。

arr := []int{1,2,3,4,5}
fmt.Println(len(arr))

6 数组的遍历

我们可以使用类c语言经典的遍历方法：

arr := [5]int{1,2,3,4,5}
for i :=0;i<len(arr);i++{
    fmt.Println(i)
}

Go 提供了一种更好、更简洁的方法，通过使用 for 循环的 range 方法来遍历数组。range 返回索引和该索引处的值。让我们使用 range 重写上面的代码。我们还可以获取数组中所有元素的总和。

arr := [5]int{11,22,33,44,55}
for index,value :=range arr{ // range函数返回数组的索引，索引处的值
    fmt.Println(index,value)
}

如果你只需要值并希望忽略索引，则可以通过用 _ 空白标识符替换索引来执行。

九、包

到目前为止，我们看到的 Go 程序都只有一个文件，文件里包含一个 main 函数和几个其他的函数。在实际中，这种把所有源代码编写在

一个文件的方法并不好用。以这种方式编写，代码的重用和维护都会很困难。而包（Package）解决了这样的问题。

包用于组织 Go 源代码，提供了更好的可重用性与可读性。由于包提供了代码的封装，因此使得 Go 应用程序易于维护。

1 main包

所有可执行的 Go 程序都必须包含一个 main 函数。这个函数是程序运行的入口。main 函数应该放置于 main 包中。

package main

2 创建包

首先，go的所有代码必须放在gopath下的src目录下，包的导入也是从scr开始搜索。

我们在src下新建一个test文件夹，下面创建两个go文件。

- src
	- test
		1.go
		2.go
- abc.go
- bin

两个go文件内部的第一行，定义包：

// 1.go
package test //  虽然文件名与包名没有直接关系，但建议包名和文件夹名相同

import "fmt"

func Test1()  { // 包内定义的变量或者函数想要给外部包使用，首字母必须大写
	fmt.Println("test包下的1.go")
}


// 2.go
package test

import "fmt"

func Test2()  { // 包内定义的变量或者函数想要给外部包使用，首字母必须大写
	fmt.Println("test包下的2.go")
}

注意：同一个文件夹下的文件只能有一个包名，否则编译报错，这里1.go和2.go的包名必须相同。

当定义了包之后，同一个包的变量名和函数名是唯一的，它们也可以直接使用。

在 Go 中，任何以大写字母开头的变量或者函数都是被导出的名字。其它包只能访问被导出的函数和变量。

我们把abc.go定义为main包，在main函数内使用定义好的test包：

// abc.go
package main

import "test" // 导入包

func main() {
	test.Test1()
	test.Test2()
}
// 输出：
test包下的1.go
test包下的2.go

3 init函数

所有包都可以包含一个 init 函数。init 函数不应该有任何返回值类型和参数，在我们的代码中也不能显式地调用它。init 函数的形式如下：

func init() {  

}

init 函数可用于执行初始化任务，也可用于在开始执行之前验证程序的正确性。

包的初始化顺序如下：

1. 首先初始化包级别（Package Level）的变量
2. 紧接着调用 init 函数。包可以有多个 init 函数（在一个文件或分布于多个文件中），它们按照编译器解析它们的顺序进行调用。

如果一个包导入了另一个包，会先初始化被导入的包。

尽管一个包可能会被导入多次，但是它只会被初始化一次。

4 其它

导入了包，却不在代码中使用它，这在 Go 中是非法的。当这么做时，编译器是会报错的。其原因是为了避免导入过多未使用的包，从而

导致编译时间显著增加。

然而，在程序开发的活跃阶段，又常常会先导入包，而暂不使用它。遇到这种情况就可以使用空白标识符 _。

package main

import (  
    "test" 
)

var _ = test.Name // 错误屏蔽器

func main() {

}

有时候我们导入一个包，只是为了确保它进行了初始化，而无需使用包中的任何函数或变量，这种情况也可以使用空白标识符。

十、Go包管理

1 使用GO111MODULE

在1.11版本后，推出 modules 机制，简称 mod，用于包管理。

使用 Go modules 之前需要环境变量 GO111MODULE，命令行输入go env可以 打印go的环境信息。

• GO111MODULE=off: 不使用 modules 功能，查找vendor和GOPATH目录
• GO111MODULE=on: 使用 modules 功能，不会去 GOPATH 下面查找依赖包。
• GO111MODULE=auto: Golang 自己检测是不是使用 modules 功能，如果当前目录不在$GOPATH 并且 当前目录（或者父目录）下有go.mod文件，则使用 GO111MODULE， 否则仍旧使用 GOPATH mode

我们这里将GO111MODULE设置为on

set GO111MODULE=on    //windows
export GO111MODULE=on //linux

我们在gopath之外，新建一个demo文件夹作为我们的项目根目录

切换到根目录下执行命令，然后会生成一个 go.mod

go mod init demo
// 这里的demo换成你文件夹的名字

这里比较关键的就是这个 go.mod 文件，这个文件中标识了我们的项目的依赖的 package 的版本。执行 init 暂时还没有将所有的依赖管

理起来。我们需要将程序 run 起来（比如执行 go run/test），或者 build（执行命令 go build）的时候，才会触发依赖的解析。

这里我们下载一个第三方包作为测试：

go get github.com/beego/beego/v2@v2.0.0

当开启了mod模式之后，包不会下载到src目录下

go.mod文件内会有 module 和 require 模块，除此之外还可以包含 replace 和 exclude 模块。

下载的 package 并不是直接存储到 GOPATH/src，而是存储到 GOPATH/pkg/mod 下面。

// go.mod
module demo

go 1.17

require github.com/beego/beego/v2 v2.0.0 // indirect

有indirect注释的代表间接依赖，没有的代表直接依赖，这里是版本号+时间戳+hash

2 自己写的包如何导入

直接在go.mod中写包名即可

3 go vender

1.5 版本推出了 vendor 机制。所谓 vendor 机制，就是每个项目的根目录下可以有一个 vendor 目录，里面存放了该项目的依赖的 package。go build 的时候会先去 vendor 目录查找依赖，如果没有找到会再去 GOPATH 目录下查找。

go mod vendor

4 使用代理GoProxy

有些 Golang 的 package 在国内是无法直接 go get 的。

GoProxy 相当于官方提供了一种 proxy 的方式让用户来进行包下载。要使用 GoProxy 只需要设置环境变量 GOPROXY 即可。目前公开的

GOPROXY 有：

• goproxy.io 在goland–>Go–>Go Modules(ego)中配置这个地址
• goproxy.cn: 由七牛云提供，参考 github repo

这里介绍Goland使用代理：

网址：https://goproxy.cn/

进入GoLand—>settings—>Go—>Go modules

完成。

十一、切片

Go 语言切片是对数组的抽象，因此切片是引用类型。但自身是结构体，值拷贝传递。

Go 数组的长度不可改变，在特定场景中这样的集合就不太适用，Go 中提供了一种灵活，功能强悍的内置类型切片(“动态数组”)，与数组

相比切片的长度是不固定的，可以追加元素，在追加时可能使切片的容量增大。

切片本身不拥有任何数据，它是对现有数组的引用。

切片遍历方式和数组一样，可以用len()求长度。表示可用元素数量，读写操作不能超过该限制。

1 切片的定义

你可以声明一个未指定大小的数组来定义切片，切片不需要说明长度。

var 变量名 []类型

// 比如 var str []string 
//     var arr []int。
// []括号内什么都不写 就是切片类型

或使用 make() 函数来创建切片:

var slice []type = make([]type, len)

// 也可以简写，其中 capacity 为可选参数。这里 len 是数组的长度并且也是切片的初始长度

slice := make([]type, len)
slice := make([]type, length, capacity)

2 创建切片的各种方式

func main() {
	//1.声明切片
	var s1 []int
	if s1 == nil {
		fmt.Println("是空")
	} else {
		fmt.Println("不是空")
	}
	// 2.:=
	s2 := []int{}
	// 3.make()
	var s3 []int = make([]int, 0)
	fmt.Println(s1, s2, s3)
	// 4.初始化赋值
	var s4 []int = make([]int, 0, 0)
	fmt.Println(s4)
	s5 := []int{1, 2, 3}
	fmt.Println(s5)
	// 5.从数组切片
	arr := [5]int{1, 2, 3, 4, 5} // 定义数组
	var s6 []int  // 定义切片
	// 索引区间前闭后开
	s6 = arr[1:4]
	fmt.Println(s6)
}

一个切片在未初始化之前默认为 nil，长度为 0。

3 切片初始化

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

直接初始化切片，[] 表示是切片类型，{1,2,3} 初始化值依次是 1,2,3，其 cap=len=3。

var arr = [...]int{0,1,2,3,4,5,6,7,8,9,}
var slice0 []int = arr[start:end]
var slice1 []int = arr[:end]
var slice2 []int = arr[start:]
var slice3 []int = arr[:]
var slice4 = arr[:len(arr)-1]

举例：

var arr = [...]int{0,1,2,3,4,5,6,7,8,9,}
var slice0 []int = arr[2:8]			// 左闭右开，len=high-low
var slice1 []int = arr[0:6]        //0可以省略： var slice []int = arr[:end]
var slice2 []int = arr[5:10]       //如果切片到结尾，可以省略： var slice[]int = arr[start:]
var slice3 []int = arr[0:len(arr)] //var slice []int = arr[:]
var slice4 = arr[:len(arr)-1]      //去掉切片的最后一个元素
fmt.Printf("arr %v\n", arr)
fmt.Printf("slice0 %v\n", slice0)
fmt.Printf("slice1 %v\n", slice1)
fmt.Printf("slice2 %v\n", slice2)
fmt.Printf("slice3 %v\n", slice3)
fmt.Printf("slice4 %v\n", slice4)

// 输出：
arr [0 1 2 3 4 5 6 7 8 9]
slice0 [2 3 4 5 6 7]
slice1 [0 1 2 3 4 5]
slice2 [5 6 7 8 9]
slice3 [0 1 2 3 4 5 6 7 8 9]
slice4 [0 1 2 3 4 5 6 7 8]

4 len() 和 cap() 函数

切片是可索引的，并且可以由 len() 方法获取长度。

切片提供了计算容量的方法 cap() 可以测量切片最长可以达到多少。

以下为具体实例：

package main

import "fmt"

func main() {
   var numbers = make([]int,3,5)

   printSlice(numbers)
}

func printSlice(x []int){
   fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}

// 输出
len=3 cap=5 slice=[0 0 0]

5 追加切片元素

正如我们已经知道数组的长度是固定的，它的长度不能增加。 切片是动态的，使用 append 可以将新元素追加到切片上。append 函数的定义是

func append（s[]T，x ... T）[]T
// x … T 在函数定义中表示该函数接受参数 x 的个数是可变的。这些类型的函数被称为[可变函数]。
// append ：向 slice 尾部添加数据，返回新的 slice 对象。

如果切片由数组支持，并且数组本身的长度是固定的，那么切片如何具有动态长度。以及内部发生了什么？

当新的元素被添加到切片时，会创建一个新的数组。现有数组的元素被复制到这个新数组中，并返回这个新数组的新切片引用。

新切片的容量是旧切片的两倍。

举例：

cars := []string{"Ferrari", "Honda", "Ford"}
	fmt.Println("cars:", cars, "has old length", len(cars), "and capacity", cap(cars)) // capacity of cars is 3
	cars = append(cars, "Toyota")
	fmt.Println("cars:", cars, "has new length", len(cars), "and capacity", cap(cars)) // capacity of cars is doubled to 6

// 输出
cars: [Ferrari Honda Ford] has old length 3 and capacity 3
cars: [Ferrari Honda Ford Toyota] has new length 4 and capacity 6

6 切片的长度和容量

切片的长度是切片中的元素数。

切片的容量是从创建切片索引位置开始的底层数组中元素数。

7 copy() 函数和内存优化

切片持有对底层数组的引用。只要切片在内存中，数组就不能被垃圾回收。在内存管理方面，这是需要注意的。让我们假设我们有一个非

常大的数组，我们只想处理它的一小部分。然后，我们由这个数组创建一个切片，并开始处理切片。这里需要重点注意的是，在切片引用

时数组仍然存在内存中。

一种解决方法是使用 [copy] 函数 func copy(dst，src[]T)int 来生成一个切片的副本。这样我们可以使用新的切片，原始数组可以被

垃圾回收。

func countries() []string {
    countries := []string{"USA", "Singapore", "Germany", "India", "Australia"}
    neededCountries := countries[:len(countries)-2] // 创建一个去掉尾部 2 个元素的切片
    countriesCpy := make([]string, len(neededCountries))
    copy(countriesCpy, neededCountries) //copies neededCountries to countriesCpy
    return countriesCpy
}
func main() {
    countriesNeeded := countries()
    fmt.Println(countriesNeeded)
}

//现在 countries 数组可以被垃圾回收, 因为 neededCountries 不再被引用。

8 切片的函数传递

切片在内部可由一个结构体类型表示。这是它的表现形式，

type slice struct {  
    Length        int
    Capacity      int
    ZerothElement *byte
}

切片包含长度、容量和指向数组第零个元素的指针。当切片传递给函数时，即使它通过值传递，指针变量也将引用相同的底层数组。因

此，当切片作为参数传递给函数时，函数内所做的更改也会在函数外可见。

十二、map

1 map集合

Map 是一种无序的键值对的集合。Map 最重要的一点是通过 key 来快速检索数据。Map 是一种集合，所以我们可以像迭代数组和切片那样迭代它。

2 创建map

声明一个map集合

var map_variable map[key_data_type]value_data_type
// 比如，声明一个key和value都是字符串类型的集合
var countryCapitalMap map[string]string 

上面的例子中，如果声明但不初始化 map，那么就会创建一个 nil map。nil map不能用来存放键值对，如果你添加键值，编译器会提示panic: assignment to entry in nil map错误，所以需要使用 make 函数初始化。

var countryCapitalMap map[string]string  // 声明一个nil集合
countryCapitalMap = make(map[string]string) // 使用make初始化
countryCapitalMap["k1"] = "v1"
countryCapitalMap["k2"] = "v2"
fmt.Println(countryCapitalMap)

可以使用类型推导，省去声明的步骤，直接用make函数创建集合

map_variable := make(map[key_data_type]value_data_type)
// key_data_type是key的类型
// value_data_type是value的类型

你也可以在声明时初始化集合，比如

money := map[string]int {
    "steve": 12000,
    "jamie": 15000,
}

3 添加元素

你可以使用中括号为map赋值，要注意key不能重复

countryCapitalMap["k1"] = "v1"
countryCapitalMap["k2"] = "v2"

也可以声明时初始化赋值

status := map[int]string{
    200: "OK",
    404: "Not Found",
}
fmt.Println(status)

4 获取元素

获取map中元素的方法很简单，使用中括号取值即可。

status := map[int]string{
    200: "OK",
    404: "Not Found",
}
//res := status[200]
res := status[404]
fmt.Println(status)
fmt.Println(res)

如果获取一个不存在的元素，会返回一个0而不会返回错误。

student := make(map[string]int)
student["mike"] = 18
student["lily"] = 20
student["bob"] = 22
fmt.Println(student["bbb"])

要查看元素在集合中是否存在，可以这样做：

value, ok := student["bbb"]
fmt.Println(value) // 返回'bbb'对应的值，如果不存在返回0
fmt.Println(ok)   // 如果key存在返回true，key不存在返回false

5 遍历map

可以使用for range语法遍历map，但是每次遍历都是无序的，我们无法决定它的返回顺序，这是因为 Map 是使用哈希表来实现的。

countryCapitalMap := map[string]string{"France": "Paris", "Italy": "Rome", "Japan": "Tokyo", "India": "New delhi"}
for country, capital := range countryCapitalMap {
    fmt.Print(country)
    fmt.Print(capital)
    fmt.Print("\n")
}

6 delete函数删除元素

要删除map中的元素，使用delete函数，语法是 delete(map, key)

student := make(map[string]int)
student["mike"] = 18
student["lily"] = 20
student["bob"] = 22
delete(student, "mike")  // 删除key为mike的元素
fmt.Println(student)

7 获取map的长度

使用len函数获取map长度

countryCapitalMap := map[string]string{"France": "Paris", "Italy": "Rome", "Japan": "Tokyo", "India": "New delhi"}
fmt.Println(len(countryCapitalMap))

8 map的函数传递

集合map可以作为参数传递。map和切片一样是引用类型，当map作为参数传递给函数时，即使是值传递，也将引用相同的底层数据结构，函数内所做的更改也会在函数外可见。

func add(m map[string]int) {
	for key, value := range m {
		m[key] = value + 1
	}
}

func main() {
	people := map[string]int{"mike": 18, "lily": 17, "bob": 15}
	add(people)
	fmt.Println(people)
	// 函数内的更改，影响原来的元素
}

十三、指针

相比于c或c++，go语言的指针是很容易学习的，它可以更简单地执行一些任务。

1 取地址操作符&

变量是一种使用方便的占位符，用于引用计算机内存地址，使用&符号获取变量的内存地址，如下：

func main() {
	var str = "hello world"
	fmt.Println(&str)
    // 返回结果为0xc00004c230
}

2 指针的定义

指针是一个变量，这个变量存储了另一个变量的内存地址。

在使用指针前，你需要声明指针。指针声明格式如下

var var_name *var-type
// var_name 为指针变量名
// var-type 为指针类型

举例：

var ptr1 *string // 指向字符串
var ptr2 *int  // 指向整型

当一个指针被定义后没有分配到任何变量时，它的初始值为nil，也被称为空指针

func main() {
	var ptr *int
	fmt.Println(ptr) // 未分配的指针初值为<nil>
	fmt.Println(&ptr) // 指针作为一个变量，也可以取到它的内存地址
    fmt.Println(*ptr) // 未分配的指针，获取指针指向的内容时会报错panic: runtime error: invalid memory address or nil pointer dereference
}

3 使用指针

定义指针后，需要给指针变量赋值，使用*操作符可以获取指针指向的内容（也称解引用）。

func main() {
	var ptr *int // 声明指针变量，它指向一个整型变量，初始化一个空指针
	b := 3   // 创建变量b为整型变量
	ptr = &b  // 将变量b的内存地址赋值给指针，也称'指针ptr指向了b'
	fmt.Println(ptr)
	fmt.Println(b)
  	fmt.Println(*ptr) // 指针解引用，获取指针所指向的变量的值
}

4 指针的函数传递

指针也是一个变量，可以向函数传递。

func add(ptr *int) {
	*ptr++
}
func main() {
	a := 10
	var ptr *int = &a
	add(ptr)
	print(a)
}

5 指针运算

与c和c++不同，go中的指针不支持对指针运算，比如指针的递增和递减。

a := 10
var ptr *int = &a
ptr++ // 不支持指针运算，返回错误invalid operation: ptr++ (non-numeric type *int)

6 多级指针

已知指针本身也是变量，指针存放的是变量的内存地址。所以，可以让一个指针存放另一个指针变量的地址，此时称这个指针变量为指向指针的指针（二级指针）。

a := 10
var ptr *int = &a
var pptr **int
pptr = &ptr
fmt.Println(a) // 10
fmt.Println(ptr) // 0xc0000160b8
fmt.Println(pptr) // 0xc000006028
fmt.Println(*pptr) // 0xc0000160b8
fmt.Println(**pptr) // 10

如上面的例子，二级指针解引用时，需要使用两个*

同理，你可以“无限套娃”下去，定义多级指针。

下面是一个三级指针、四级指针的例子：

a := 10
var ptr *int = &a
var pptr **int
var ppptr ***int
var pppptr ****int
pptr = &ptr
ppptr = &pptr
pppptr = &ppptr
fmt.Println(a)
fmt.Println(ptr)
fmt.Println(pptr)
fmt.Println(ppptr)
fmt.Println(pppptr)

十四、结构体

结构体是由一系列具有相同类型或不同类型的数据构成的数据集合。比如你需要定义一些互相有联系的变量，而变量之间的类型不同。

举个实际的例子，保存图书馆的书籍记录，每本书有以下属性：title，author，price，此时就可以使用结构体类型。

1 定义结构体

结构体定义需要使用type和struct语句。struct语句定义一个新的数据类型，结构体中有一个或多个成员。type语句设定了结构体的名称。

type struct_variable_type struct {
   member definition
   member definition
   ...
   member definition
}
// struct_variable_type为自定义的结构体类型名称
// 在结构体内部定义成员（member definition）

一旦定义了结构体，就可以将它作为变量的声明

variable_name := structure_variable_type { key1: value1, key2: value2..., keyn: valuen}

示例：

type Books struct {
	title  string
	author string
	price  int
}

func main() {
	var book Books // 声明变量为Books结构体类型
}

2 访问结构体成员

果要访问结构体成员，需要使用点. 操作符。

type Books struct {
   title  string
   author string
   price  int
}

func main() {
   var book Books // 声明但未初始化赋值
   fmt.Println(book.price) // 未赋值时，结构体为零值
}

3 结构体成员赋值

可以在声明时赋值；也可以先声明，再使用.操作符赋值。

type Books struct {
	title  string
	author string
	price  int
}
func main() {
	var book = Books{
		title:  "西游记",
		author: "吴承恩",
		price:  60,
	}
    // 也可以如下方式赋值
	//book.title = "西游记"
	//book.author = "吴承恩"
	//book.price = 60
	fmt.Println(book)
}

你可以为结构体的部分成员赋值，此时剩下的成员会被赋值为零值。

4 结构体的导出

定义结构体及其成员时，仍遵循大写导出，小写不导出的规则。如下：

type Books struct { // 大写结构体名字，可以导出，外部包可以访问
   title  string // 小写成员名字，不能被导出，外部包无法访问
   author string // 小写成员名字，不能被导出，外部包无法访问
   Price  int // 大写成员名字，可以导出，外部包可以访问
}

如果想要让这个结构体所有成员被外部访问，需要将它们大写。

5 结构体的函数传递

你可以像其他数据类型一样将结构体类型作为参数传递给函数，并且可以访问内部成员。

type Books struct {
	Title  string
	Author string
	Price  int
}

func change(book Books) {
	book.Title = "红楼梦"
	book.Author = "曹雪芹"
	book.Price = 50
}
func main() {

	var book = Books{
		Title:  "西游记",
		Author: "吴承恩",
		Price:  60,
	}
	fmt.Println(book)
	change(book) // 结构体按值传递，在函数内部的更改不影响原来的值
	fmt.Println(book)
}

在函数内修改结构体，原来的结构体不会改变。

6 结构体指针与结构体的函数引用传递

要想在函数内更改结构体，可以利用结构体指针。相当于结构体的引用传递。

type Books struct {
	Title  string
	Author string
	Price  int
}

func change(book *Books) {
	book.Title = "红楼梦"
	book.Author = "曹雪芹"
	book.Price = 50
}
func main() {

	var book = Books{
		Title:  "西游记",
		Author: "吴承恩",
		Price:  60,
	}
	var ptr *Books = &book // 定义结构体指针，指向book
	fmt.Println(book)
	change(ptr) // 传递指针，通过指针修改原结构体
	fmt.Println(book) // 此时是引用传递，函数内的更改在外部生效
}

7 匿名结构体

我们之前定义的结构体称为命名结构体，因为我们创建了新的类型；匿名结构体是是一个变量，不创建新的类型。

func main() {
   // 匿名结构体
   var Book struct {
      title  string
      author string
      price  int
   }
   // 结构体赋值
   Book.title = "西游记"
   Book.author = "吴承恩"
   Book.price = 50
   fmt.Println(Book)
}

也可以在声明同时赋值

func main() {
	// 创建匿名结构体，使用变量Book接收它，并为它的成员赋值
    Book := struct {
		title  string
		author string
		price  int
	}{
		title:  "西游记",
		author: "吴承恩",
		price:  50,
	}
	fmt.Println(Book)
}

8 结构体嵌套

结构体内部还可以定义结构体。示例：

type Book struct {
	Title  string
	Author struct {
		Name string
		Age  int
	}
	price int
}

func main() {
	book := Book{
		Title: "西游记",
		Author: struct {
			Name string
			Age  int
		}{
			Name: "吴承恩",
			Age:  18,
		},
		price: 60,
	}
	fmt.Println(book)
}

9 匿名字段

定义结构体时，成员字段可以只有类型而没有字段名，这种形式的结构体字段为匿名字段。

// 定义匿名字段
type Book struct {
	string
	int
}

func main() {
	book := Book{
		string: "红楼梦",
		int:    60,
	}
	// 如果字段没有名称，那么默认它的名称为它的类型
	fmt.Println(book)
}

如果字段没有名称，那么默认它的名称为它的类型。比如string字段和int字段。

10 结构体比较

结构体是值类型（通过函数传递也可以看出来），如果它的所有字段都可比较，则该结构体也是可比较的；如果结构体包含不可比较的字段，则结构体也不可比较。

11 字段提升

如果结构体中有匿名结构体类型的字段，该匿名结构体里的字段就称为提升字段。这些字段自动提升，可以用外部结构体直接访问。

type Book struct {
	title  string
	author // 匿名字段
}

type author struct {
	name string
	age  int
}

如上，Book中有一个匿名字段author，author是结构体类型，包含name和age两个成员，那么我们通过Book就可以访问到它们。

十五、方法

1 方法定义

go语言中同时有函数和方法。一个方法就是一个包含了接收器的函数，接收器一般是结构体类型中的字段，也可以是非结构体。它的定义如下：

func (variable_name variable_data_type) function_name() [return_type]{
   /* 函数体*/
}

通俗来说就是定义一个函数，指定一个接收器来接收这个函数。

通过一个示例学习方法的使用：

type Book struct {
	title string
	price int
}

func (book Book) printprice() {
	fmt.Println(book.price)
	book.price += 2
}
func main() {
	book := Book{
		title: "红楼梦",
		price: 58,
	}
	book.printprice()
	fmt.Println(book.price)
}

在上面的示例中，我们定义一个结构体含两个字段；然后定义一个函数，指定接收器为book，此时相当于在Book类型上绑定了一个方法。我们在main函数中可以通过.操作符调用这个方法。

2 值接收器和指针接收器

在上面的示例中我们发现，printprice方法想让price自增2，但实际上原结构体并不会被改变，这是因为我们使用了值接收器。

我们如果想要在方法内更改字段并使得它对调用者可见，需要使用指针接收器。比如下面的例子：

type Book struct {
	title string
	price int
}

func (book *Book) printprice() {
	fmt.Println(book.price)
	// 这里传递的是指针，但是我们仍然可以取到字段。这是go内部自动转化的结果，如果在c或c++中，你需要先对指针解引用
	fmt.Println((*book).price)
	book.price += 2
}
func main() {
	book := Book{
		title: "红楼梦",
		price: 58,
	}
	book.printprice()
	fmt.Println(book.price)
}

使用指针接收器后，在 printprice 方法中对 Book 结构体的字段 price 所做的改变对调用者是可见的，换句话说在方法内修改值，原来的值也会随之改变。

另外补充一点，如果你有c编程的经验，你可能注意到，在操作结构体的字段时，如果在c或c++中，需要先对指针解引用；而在go中不同，指针直接使用.操作符就可以取到字段。

另外，go可以直接使用指针操作，而c/c++不可以，对比c++代码来理解：

struct Book {
    string title;
    int price;
};
void printprice(Book* book){
    (*book).price +=2; // c 解引用
    cout <<book->price<<endl;// c++ 解引用
}
int main() {
    Book book = {"红楼梦",58};
    printprice(&book);
    return 0;
}

那么该如何选择值接收器与指针接收器？如果你想要方法所做的改变对调用者可见，那么就使用指针接收器；否则就使用值接收器。另外，值接收器需要对原结构体拷贝，如果结构体字段很大，那么付出的内存消耗也大。

3 字段方法提升

和结构体的字段提升一样，接收器是匿名字段的结构体，可以直接在外部使用它的方法。

type Book struct {
	title string
	price int
	Author
}

type Author struct {
	name string
	age  int
}

func (a Author) getage() {
	// 接收器为Author
	fmt.Println(a.age)
}

func main() {
	book := Book{
		title: "红楼梦",
		price: 58,
		Author: Author{
			name: "曹雪芹",
			age:  20,
		},
	}
	book.getage() // 可以直接访问Author的绑定方法
	fmt.Println(book.price)
}

十六、接口

1 定义接口

在面向对象中，接口规范了一个对象的行为，接口指定对象必须实现的方法，而实现的细节由对象自己去完成。go语言中同样提供接口，它把所有的具有共性的方法定义在一起，只要任何其他类型只要实现了这些方法就是实现了这个接口。

接口的定义语法如下：

type interface_name interface {
   method_name1 [return_type]
   method_name2 [return_type]
   method_name3 [return_type]
   ...
   method_namen [return_type]
}

接口是方法的集合，要实现这个接口就必须实现这些方法。示例：

// 定义接口
type Animal interface {
	sleep()
	eat()
}

// 定义结构体
type Dog struct {
	Name string
	Age  int
}

// 为Dog绑定方法实现接口
func (dog Dog) sleep() {
	fmt.Println(dog.Name + "is sleeping!")
}

//为Dog绑定方法实现接口
func (dog Dog) eat() {
	fmt.Println(dog.Name + "is eating!")
}

func main() {
	d := Dog{
		Name: "小狗",
		Age:  5,
	}
	d.eat()
	d.sleep()
}

上面定义了一个Animal接口，要求实现两个方法。然后定义一个Dog结构体，为它绑定这两个方法，go与java不同，不需要显式声明实现的接口，只要这个类型实现了接口的所有方法，就默认实现了这个接口。但是，这样定义与之前为结构体绑定方法没有区别，把接口去掉程序仍然可以正常工作。

2 接口的作用

接口的实际应用是实现多态。接口是一种数据类型，所以我们可以定义接口类型的变量，然后将其它实现接口的结构赋值给它，实现多态。

示例：

// 定义接口
type Animal interface {
	eat()
}

// 定义结构体
type Dog struct {
	Name string
	Age  int
}
type Bird struct {
	Name string
}

//为Dog绑定方法实现接口
func (dog Dog) eat() {
	fmt.Println(dog.Name + "只吃肉")
}

//为Bird绑定方法实现接口
func (bird Bird) eat() {
	fmt.Println(bird.Name + "吃虫子")
}

func main() {
	// 定义nil接口
	var animal Animal
	
	animal = Bird{Name: "麻雀"}
	animal.eat() //麻雀吃虫子

	animal = Dog{Name: "小狗"}
	animal.eat() //小狗只吃肉

}

接口是动态的，就像切片是对数组的动态引用一样，接口也是类似的工作方式。

上面的程序中，我们定义了Animal接口，且Bird和Dog都实现了这个接口，然后我们在main函数中，先定义一个未赋值的接口。首先将Bird指定给它，此时animal的动态类型就是Bird，此时访问animal接口时，只会返回动态值的类型（eat方法），它的静态类型（Name字段）保持隐藏。然后，我们将Dog指定给它，此时的动态类型就是Dog，我们访问的eat方法就是绑定给Dog的方法，由此实现了多态。

3 类型断言

先介绍类型断言的语法：

value, ok := i.(Type)

上节提到接口不能访问低层的静态字段，我们可以使用类型断言来获取这些基础值。

// 定义接口
type Animal interface {
	eat()
}

// 定义结构体
type Dog struct {
	Name string
	Age  int
}
type Bird struct {
	Name string
}

//为Dog绑定方法实现接口
func (dog Dog) eat() {
	fmt.Println(dog.Name + "只吃肉")
}

//为Bird绑定方法实现接口
func (bird Bird) eat() {
	fmt.Println(bird.Name + "吃虫子")
}

func main() {
	// 定义接口
	var animal Animal
	animal = Dog{Name: "小狗", Age: 5}
	// 类型断言，判断animal的具体类型是否为Dog
	value, ok := animal.(Dog)
	fmt.Println(ok)
    // 断言成功，获取底层字段内容
	fmt.Println(value.Age)
	fmt.Println(value.Name)

}

其中，类型断言如果正确，就将此时的底层值赋值给animal，将true赋值给ok；反之，animal为该类型的零值，ok=false。

4 多接口

一个类型可以实现多个接口。例：

// 定义接口
type Animal interface {
	eat()
}

type Habit interface {
	football()
}

// 定义结构体
type Dog struct {
	Name string
}

// 实现Animal接口
func (dog Dog) eat() {
	fmt.Println(dog.Name + "只吃肉")
}
// 实现Habit接口
func (dog Dog) football() {
	fmt.Println(dog.Name + "爱玩足球")
}

上面例子中，Dog实现了两个接口，也就意味着可以将Dog类型的值赋给Animal或Habit接口类型的变量。

5 空接口

当接口没有方法时，它被称为空接口。 除了有名的空接口，还可以定义匿名的。

匿名空接口的定义为 interface{}，一般用于函数的形式参数。空接口不规范任何方法，也就意味着所有类型都实现了空接口。举例说明：

type str string

// 函数接收一个空接口
func foo(in interface{}) {
	fmt.Println(in)
}

func main() {
	s := str("hello world")
	i := 5
	foo(s)
	foo(i)
}

我们自定义一个str类型，还有一个int类型的数据，将它传递给foo，由于任何类型都实现空接口，空接口作为函数的参数可以保存任何类型的值，所以这个函数可以接收所有类型的数据。

6 接口嵌套

顾名思义，举例

// 定义接口
type Animal interface {
	eat()
}

type Habit interface {
	football()
}
type Dog interface {
	sleep()
	Animal
	Habit
}

定义的Dog接口里，包含Animal和Habit，所以要实现Dog必须实现这些接口（类似于面向对象的继承）

十七、面向对象

go不是一个完全面向对象的语言，甚至没有类的概念。但是，这并不意味着go不支持面向对象，因为面向对象只是一种实现形式，只要实现了封装继承和多态，在使用上与其他面向对象语言就没有不同。

在go中，可以使用结构体取代类，使用接口实现多态，使用匿名字段提升实现继承。所以，go是完全可以做到面型对象编程的，毕竟面向对象只是编程思想。

type Animal struct {
	name string
	age  int
}

func New(name string, age int) Animal {
	return Animal{name: name, age: age}
}

我们可以这样定义，定义一个结构体，New函数返回这个结构体类型，直接调用New创建对象，达到与java等语法类似的效果。

十八、并发编程

1 并发和并行

并发是指多个事件在同一时间间隔内发生，或者说并发是具有同时处理多个任务的能力。

并行是指多个事件在同一时刻发生，注意同一时刻和同一时间间隔的区别。并发在宏观上看上去，一段时间内多个任务同时执行，但是在每一时刻，单处理机只能有一道程序执行，只是操作系统会不断的切换多个任务。

举个例子，如果你在0-1分钟切菜，1-2分钟洗水果，2-3分钟切菜，那么在0-3分钟的时间间隔里，切菜和洗水果是并发的；如果你在0-3分钟的每一时刻，左手切菜，右手洗水果，那么这两个动作就是并行的。下图可以帮助你更好地理解：

2 go协程

线程又被称为轻量级进程，它是程序执行的最小单元，线程不拥有系统资源（只拥有一点运行中必须的资源），它可以与同属于一个进程的其他线程共享进程资源，线程的切换由操作系统调度。

协程又称微线程，协程运行在用户态下，由于在进程切换时会消耗很多资源，协程则避免了这个问题，协程完全由程序自己控制，操作系统并不会感知。在go中，创建一个go协程的开销很小，你可以创建千百个协程并发运行。

go协程称为goroutine，go通过goroutine支持并发，goroutine是go中最基本的执行单元。

生成一个goroutine的方式非常简单，使用go关键字就创建了：

import (
	"fmt"
	"time"
)

func main() {
	// 创建10个goroutine
	for i := 0; i < 10; i++ {
		go func() {
			fmt.Println("创建一个goroutine")
		}()
	}
	time.Sleep(3 * time.Second)
}

我们创建了10个go协程，它们与main函数并发执行，main函数运行在主协程上。正如上文所说，go协程的开销很小（几kb），所以可以创建很多goroutine，多个goroutine调度的顺序是乱序的。

另外，在主进程中我们sleep等待了三秒，如果不等待会发生什么呢？尝试把它去掉，你会发现程序什么都没有输出。这就是go协程的性质，主协程不会等待go协程执行完毕。在调用协程之后，主协程会立即执行代码的下一行，忽略该协程的任何返回值。如果主协程结束运行，则其他协程也不会继续运行。所以我们暂且使用sleep等待其他协程执行完毕，才结束主协程，这样就能看到输出。

3 goroutine的GMP调度模型

goroutine的整体调度模型如下图：

其中：

• G指goroutine，在全局有一个Global队列，每当创建一个goroutine就把它入队
• M指machine，它代表一个用户级线程，所有的G任务，最终还是在M上执行
• P指processor处理器，它也维护了一个goroutine队列，里面存储了所有需要它来执行的goroutine。它处在G和M之间，直接与M交互。P默认就是CPU可用的核数，可以通过runtime.GOMAXPROCS修改（一般不修改）。

调度的过程是这样的，当通过go关键字创建一个新的goroutine的时候，它会优先被放入P的本地队列。为了运行goroutine，M需要持有（绑定）一个P，接着M会启动一个内核级线程，循环从P的本地队列里取出一个goroutine并执行。当M执行完了当前P的Local队列里的所有G后，P会先尝试从Global队列寻找G来执行，如果Global队列为空，它会随机挑选另外一个P，从它的队列里中拿走一半的G到自己的队列中执行。

4 channel定义

channel（信道/通道）是go的一种重要特性，类似于管道，其本质是一个先进先出的队列，它实现了goroutine之间的通信，多个goroutine可同时修改一个channel。

channel是一个变量，使用chan来定义。

var 变量名 chan 类型
// channel是有类型的，比如int类型的channel只能存放整型

channel是引用类型，和其他引用类型一样，channel 的空值为nil。channel一定要初始化后才能进行读写操作，否则会永久阻塞，所以一般使用make创建channel。

ch := make(chan int)

5 使用channel进行通信

初始化一个channel，就可以在里面取值放值，

ch := make(chan int)
// 放值
ch <- 3
// 取值
<- ch

默认情况下向channel发送数据和接收数据会阻塞，举例：

func foo(ch chan int) {
	fmt.Println("hello world")
	// 阻塞，直到有其它goroutine从ch放数据
	a := <-ch
	fmt.Println(a)
}
func main() {
	ch := make(chan int)
	go foo(ch)
	// 向channel中放一个值，阻塞，直到有其它goroutine从ch取到数据
	ch <- 3
}

读取数据推荐方法：

a, ok := <-ch
// 如果取到，ok=true；反之为false

6 关闭channel

go提供了内置的close函数对channel进行关闭操作。

ch := make(chan int)

close(ch)

注意以下几点：

• 关闭一个未初始化(nil) 的channel会产生panic

• 重复关闭同一个channel会产生 panic

• 向一个已关闭的channel中发送消息会产生 panic

• 从已关闭的channel读取消息不会产生panic，且能读出channel中还未被读取的消息，若消息均已读出，则会读到类型的零值。从一个已关闭的channel中读取消息永远不会阻塞，并且会返回一个为 false的ok-idiom，可以用它来判断 channel 是否关闭。

• 关闭channel会产生一个广播机制，所有向channel读取消息的goroutine都会收到消息。接收方可以用ok来检查信道是否已经关闭

7 死锁

当go协程给一个channel发送数据时，如果没有其他go协程来接收数据，就会形成死锁。同理，当有go协程等待从一个channel接收数据时，如果没有人发送，也会死锁。

8 单向channel

channel类型是可以带有方向的：

var readOnlyChan <-chan int        // 只读chan，只能读channel，不可写入
var writeOnlyChan chan<- int       // 只写chan，只能写channel，不可读
var ch chan int                    //读写channel

可能你有疑问，前面说过不管读写都会阻塞，如果定义只读或者只写channel不会发生死锁吗？实际上，单独定义确实没有意义，所以一般在主goroutine中定义读写channel，然后在一些函数参数传递时候指明可读还是可写。比如：

func foo(ch <-chan int) { // 定义只读channel 只负责读，不能写
	fmt.Println("hello world")
	a, ok := <-ch
	fmt.Println(a, ok)
}
func main() {
	ch := make(chan int)
	go foo(ch)
	ch <- 3
}

9 遍历channel

可以使用for range遍历信道：

func producer(ch chan int) {
	for i := 0; i < 5; i++ {
		ch <- i
		fmt.Println("存放", i)
	}
	close(ch)
}
func main() {
	ch := make(chan int)
	go producer(ch)
	for v := range ch {
		fmt.Println("接收", v)
	}
}

// 上述代码执行结果为：
存放 0
接收 0
接收 1
存放 1
存放 2
接收 2
接收 3
存放 3
存放 4
接收 4

可以看到，for range一直从信道中尝试接收数据，如果信道没有关闭也没有数据就阻塞等待，一旦某个goroutine发送数据，就立刻取出。直到信道关闭时，循环会自动结束。

10 缓冲channel

带缓冲区channel：定义声明时候制定了缓冲区长度，可以保存多个数据。只在缓冲已满的情况，发送数据时才会阻塞；同样，只有在缓冲为空的时候，接收数据才会阻塞。

不带缓冲区channel：发送数据就阻塞，直到有goroutine读；读取时也会阻塞，直到有goroutine写。

定义一个带缓冲的channel很简单：

ch := make(chan type, [capacity])// 创建channel信道的语法，capacity可选，如果不写默认为0
// 举例
ch := make(chan int) // 不带缓冲区，此时capacity为0
ch := make(chan int,10) // 带缓冲区

要让一个信道有缓冲，上面语法中的 capacity 应该大于 0，一旦定义了缓冲channel，在缓冲满之前不会阻塞。

11 waitgroup

使用waitgroup可以实现同步，即等待所有的goroutine执行完成。举个例子：

func foo(i int) {
	fmt.Printf("foo执行了%d次\n", i+1)

}
func main() {
	for i := 0; i < 5; i++ {
		go foo(i)
	}

}

如果直接执行，主协程不会等待go协程执行完毕，所以看不到任何输出。我们可以定义一个waitgroup：

var wg sync.WaitGroup
// 它不是引用类型，当作参数传递时是值传递，要想修改原来的值需要传指针（地址）

WaitGroup 对象内部有一个计数器，最初从0开始，它有三个方法：Add(), Done(), Wait() 用来控制计数器的数量。我们在上述代码的基础上使用WaitGroup：

func foo(i int, wg *sync.WaitGroup) {
	fmt.Printf("foo执行了%d次\n", i+1)
	wg.Done() // Done() 表示把计数器-1
}
func main() {
	var wg sync.WaitGroup
	for i := 0; i < 5; i++ {
        wg.Add(1) // Add(1)表示把计数器+1
		go foo(i, &wg) // 使用指针类型才可以修改原值
	}
	wg.Wait() // wait() 会阻塞代码运行，直到计数器的值减为0

}

输出结果为

// 顺序是不固定的
foo执行了5次
foo执行了1次
foo执行了4次
foo执行了2次
foo执行了3次

另外，Add(delta int)函数中，参数delta可以为负值；但是如果计数器为负值，会提示panic: sync: negative WaitGroup counter 错误。

12 Mutex

go提供了mutex用多个goroutine的互斥访问。互斥问题的场景很多，比如并发更新同一个资源、并发更新计数器、秒杀活动等等，这些都需要保证数据准确。首先要明确临界资源的概念。不论是进程、线程还是goroutine，互斥问题的概念都是相通的：我们把一次仅允许一个goroutine使用的资源称为临界资源。为了保证临界资源的正确使用，可以划分为四部分

• 进入区：在进入临界区之前，负责阻止其它goroutine同时进入临界区
• 临界区：使用临界资源
• 退出区：某个goroutine退出临界区之后，负责更改临界区状态，允许其它goroutine访问临界区
• 剩余区：其余部分

实现互斥访问的方式有很多，mutex是互斥锁，可确保在某时刻只有一个goroutine在临界区运行，以防止出现竞态条件。

在go的标准库中，package sync提供了锁相关的一系列同步原语，还定义了一个Locker的接口，mutex就实现了这个接口。

type Locker interface {
    Lock()
    Unlock()
}

使用mutex解决互斥问题：

func incr(wg *sync.WaitGroup, m *sync.Mutex) { // mutex需要引用传递
	m.Lock()
	x = x + 1
	m.Unlock()
	wg.Done()
}
func main() {
	var x = 0
	var w sync.WaitGroup
	var m sync.Mutex
	for i := 0; i < 100; i++ {
		w.Add(1)
		go incr(&w, &m) // 传递引用
	}
	w.Wait()
	fmt.Println("x结果是", x)
}

十九、错误、异常处理

本章吐槽：go的异常处理实在是太难用了，一度让我写得十分反胃。

1 error

go中我们通常会在函数或方法中返回error结构对象来判断是否有异常出现。go内置的错误类型error是一个接口类型，自定义的错误类型必须实现它：

type error interface {
      Error() string
}

使用errors.New可返回一个错误信息：

err := errors.New("错误消息")

例：

func Sqrt(f float64) (float64, error) {
	if f < 0 {
		return 0, errors.New("被开方数不能为负")
	}
	return math.Sqrt(f), nil
}

func main() {
	d, err := Sqrt(-3)
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println(d)
}

在上面代码中，我们定义一个简单的开方函数，如果被开方数为负就输出一个错误。

一般按照如下方法使用：

• 如果函数需要处理异常，通常将error作为多值返回的最后一个值，返回的error值为nil则表示无异常，非nil则是有异常。
• 一般先用if语句处理error!=nil，把正常逻辑写在后面。

另外你会发现，返回错误并不会终止程序的运行。

2 panic

error是错误，panic是异常。错误指的是可能出现问题的地方出现了问题，比如打开一个文件时失败，这种情况在人们的意料之中 ；而异常指的是不应该出现问题的地方出现了问题，比如引用了空指针，这种情况在人们的意料之外。可见，错误是业务过程的一部分，而异常不是 。与error不同，panic会终止程序的运行，在执行完所有的defer函数后，程序控制返回到该函数的调用方。这样的过程会一直持续下去，直到当前goroutine的所有函数都返回退出，然后程序会打印出 panic 信息，接着打印出堆栈跟踪（Stack Trace），最后程序终止。

func main() {
	fmt.Println("1")
	fmt.Println("2")
	panic("发生异常") // 主动抛异常，类似于java的throw，python的raise
	fmt.Println("3")
}

上述代码中，使用panic抛出异常后，第三个打印语句不会执行。

3 defer

defer是go语言中的延迟执行语句，用来添加函数结束时执行的代码。

func main() {
	defer fmt.Println("1")
	defer fmt.Println("2")
	fmt.Println("3")
}
/*结果为：
3
2
1
*/

当一个函数内多次调用defer时，go会把defer调用放入到一个栈中，在函数结束之前依次出栈，因此输出结果是逆序。

与panic结合使用：

func main() {
	defer fmt.Println("1")
	defer fmt.Println("2")
	panic("发生异常") // 主动抛异常，类似于java的throw，python的raise
	fmt.Println("3")
}

在抛出异常之前，再逆序执行所有的defer。

4 recover

panic会使后面的语句终止，recover可以让程序能正常运行下去。只有在defer函数的内部，调用 recover才有用。在defer函数内调用 recover，可以取到 panic的错误信息，并且停止 panic 续发事件（Panicking Sequence），程序运行恢复正常。recover的使用如下：

func f1() {
	fmt.Println("f1")
}

func f2() {
	defer func() { // 匿名函数，延迟执行
		if err := recover(); err != nil {
			fmt.Println(err) // 如果出错，恢复错误继续执行，并且打印错误
		}
		fmt.Println("无论是否有异常，此处永远都会执行")
	}()

	fmt.Println("f2")
	panic("抛出异常")

}

func main() {
	f1()
	f2()
}