---
# System prepended metadata

title: Golang 学习资料整理
tags: [golang]

---

# Golang 学习资料整理
---
## Go的优缺点
http://www.techug.com/post/bad-and-good-of-golang.html
## 学习资源
### A tour of go
英文版 https://tour.golang.org/list
中文版 https://tour.go-zh.org/list
### go入门指南
https://www.kancloud.cn/kancloud/the-way-to-go
### 极客学院
http://wiki.jikexueyuan.com/list/go
### go by example
https://gobyexample.com/
### go web example
https://gowebexamples.com/
### build web application with golang
https://astaxie.gitbooks.io/build-web-application-with-golang/
### 在线编译运行
https://play.golang.org/
### 在线课程
[Go: The Complete Developer's Guide (Golang)](https://www.udemy.com/go-the-complete-developers-guide/)
[Web Development w/ Google’s Go (golang) Programming Language](https://www.udemy.com/go-programming-language/)
### 高阶资料
Go语言高级编程（中文） https://chai2010.gitbooks.io/advanced-go-programming-book/content/
Go源码剖析（中文） https://github.com/qyuhen/book
Go内部机制（英文） https://github.com/emluque/golang-internals-resources

### 编码规范
https://github.com/golang/go/wiki/CodeReviewComments

### 语言框架
beego
echo
gin
teleport https://github.com/henrylee2cn/teleport
tp-micro 是基于teleport开发的框架 https://github.com/xiaoenai/tp-micro/

### 开发环境搭建
https://www.jianshu.com/p/eb35a47a157e


## 基础
### 包、变量和函数
#### 包
每个 Go 程序都是由包构成的。

程序从 main 包开始运行。

本程序通过导入路径 "fmt" 和 "math/rand" 来使用这两个包。

按照约定，包名与导入路径的最后一个元素一致。例如，"math/rand" 包中的源码均以 package rand 语句开始。

``` go=
package main

import (
	"fmt"
	"math/rand"
)

func main() {
	fmt.Println("My favorite number is", rand.Intn(10))
}

```


#### import语句
此代码用圆括号组合了导入，这是“分组”形式的导入语句。

当然你也可以编写多个导入语句，例如：

> import "fmt"
> import "math"

不过使用分组导入语句是更好的形式。
``` go
package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Printf("Now you have %g problems.", math.Sqrt(7))
}
```


#### 函数
函数可以没有参数或接受多个参数。

在本例中，add 接受两个 int 类型的参数。
``` go=
package main

import "fmt"

func add(x int, y int) int {    // 类型值相同，两个传入的参数也可定义为 x , y int
	return x + y
}

func main() {
	fmt.Println(add(42, 13))
}
```

#### 函数多返回值
函数可以返回任意数量的返回值。

swap 函数返回了两个字符串。
``` go=
package main

import "fmt"

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

func main() {
	a, b := swap("hello", "world")
	fmt.Println(a, b)
}
```

#### 返回值命名
Go 的返回值可在函数名中被定义。

**返回值的名称应当具有一定的意义，它可以作为文档使用。**

没有参数的 return 语句返回已命名的返回值。**不建议直接使用return返回，这会影响代码可读性。**
``` go=
package main

import "fmt"

func split(sum int) (x, y int) {        // 返回值的名字在此已定义
	x = sum * 4 / 9
	y = sum - x
	return                              // 等价于 return x, y
}

func main() {
	fmt.Println(split(17))
}
```

#### 变量
var 语句用于声明一个变量列表，跟函数的参数列表一样，类型在最后。

就像在这个例子中看到的一样，var 语句可以出现在包或函数级别。

变量会自动初始化，int型初始化为0，bool型初始化为false, string型初始化为""

``` go=
package main

import "fmt"

var c, python, java bool

var str string

func main() {
	var i int
	fmt.Println(i, c, python, java, str)
}

// 0 false false false
```

#### 变量声明
变量声明可以包含初始值，每个变量对应一个。

如果初始化值已存在，则可以省略类型；变量会从初始值中获得类型。
``` go=
package main

import "fmt"

var i, j int = 1, 2

func main() {
	var c, python, java = true, false, "no!"    //根据变量赋值自动获取类型
	fmt.Println(i, j, c, python, java)
}

// 1 2 true false no!
```

#### 简洁变量声明(推荐)
**在函数中**，简洁赋值语句 := 可在类型明确的地方代替 var 声明。

函数外的每个语句都必须以关键字开始（var, func 等等），因此 **:= 结构不能在函数外使用**。
``` go=
package main

import "fmt"

func main() {
	var i, j int = 1, 2
	k := 3
	c, python, java := true, false, "no!"

	fmt.Println(i, j, k, c, python, java)
}

// 1 2 3 true false no!
```

#### 基本变量类型
Go 的基本类型有
基本类型都是小写的
> bool
> 
> string
> 
> int  int8  int16  int32  int64
> uint uint8 uint16 uint32 uint64 uintptr
> 
> byte // uint8 的别名
> 
> rune // int32 的别名
>     // 表示一个 Unicode 码点
> 
> float32 float64  //注意：没有float，只有float32 or float64
> 
> complex64 complex128

本例展示了几种类型的变量。 同导入语句一样，变量声明也可以“分组”成一个语法块。

int, uint 和 uintptr 在 32 位系统上通常为 32 位宽，在 64 位系统上则为 64 位宽。 当你需要一个整数值时应使用 int 类型，除非你有特殊的理由使用固定大小或无符号的整数类型。
``` go=
package main

import (
	"fmt"
	"math/cmplx"
)

var (
	ToBe   bool       = false
// 1<<64即1后面跟64个0的二进制数，等价于(1*2)的64次方10进制数，关于<< >>运算符，可以这么理解(x << n == x*2^n ) (x >> n == x*2^(-n))
        MaxInt uint64     = 1<<64 - 1    
	z      complex128 = cmplx.Sqrt(-5 + 12i)
)

// %T代表变量类型，%v代表变量值，go语言有丰富的格式化输出方式，参考此链接 https://programming.guide/go/fmt-printf-reference-cheat-sheet.html 或中文说明 https://blog.csdn.net/chenbaoke/article/details/39932845
func main() {
	fmt.Printf("Type: %T Value: %v\n", ToBe, ToBe)    // 注意这里是fmt.Printf而不是Print or Println,只有Printf才可以格式化输出
	fmt.Printf("Type: %T Value: %v\n", MaxInt, MaxInt)
	fmt.Printf("Type: %T Value: %v\n", z, z)
}

/*
Type: bool Value: false
Type: uint64 Value: 18446744073709551615
Type: complex128 Value: (2+3i)
*/
```
#### 类型转换
表达式 T(v) 将值 v 转换为类型 T。

一些关于数值的转换：

> var i int = 42
> var f float64 = float64(i)
> var u uint = uint(f)

或者，更加简单的形式：

> i := 42
> f := float64(i)
> u := uint(f)

与 C 不同的是，Go 在不同类型的项之间赋值时需要**显式转换**。试着移除例子中 float64 或 uint 的转换看看会发生什么。

``` go=
package main

import (
	"fmt"
	"math"
)

func main() {
	var x, y int = 3, 4
	var f float64 = math.Sqrt(float64(x*x + y*y)) // 右侧float64移除后执行报错
	var z uint = uint(f)    // 右侧uint移除后执行报错
	fmt.Println(x, y, z)    
    
// 3 4 5
}
```

#### 类型推导
在声明一个变量而不指定其类型时（即使用不带类型的 := 语法或 var = 表达式语法），变量的类型由右值推导得出。

当右值声明了类型时，新变量的类型与其相同：

> var i int
> j := i // j 也是一个 int

不过当右边包含未指明类型的数值常量时，新变量的类型就可能是 int, float64 或 complex128 了，这取决于常量的精度：

> i := 42           // int
> f := 3.142        // float64
> g := 0.867 + 0.5i // complex128

尝试修改示例代码中 v 的初始值，并观察它是如何影响类型的。
``` go=
package main

import "fmt"

func main() {
	v := 4.0 // 修改这里！
	fmt.Printf("v is of type %T\n", v)
}
```

#### 常量
常量的声明与变量类似，只不过是使用 **const** 关键字。

常量可以是字符、字符串、布尔值或数值。

**常量不能用 := 语法声明。**
**按照习惯，常量首字母为大写**
``` go=
package main

import "fmt"

const Pi = 3.14

func main() {
	const World = "世界"
	fmt.Println("Hello", World)
	fmt.Println("Happy", Pi, "Day")

	const Truth = true
	fmt.Println("Go rules?", Truth)
}
```

### 流程控制语句：for、if、else、switch 和 defer
#### for
Go 只有一种循环结构：for 循环。

基本的 for 循环由三部分组成，它们用分号隔开：

初始化语句：在第一次迭代前执行
条件表达式：在每次迭代前判断
后置语句：在每次迭代的结尾执行
初始化语句通常为一句短变量声明，该变量声明仅在 for 语句的作用域中可见。

一旦条件表达式的布尔值为 false，循环迭代就会终止。

注意：和 C、Java、JavaScript 之类的语言不同，Go 的 for 语句后面**没有小括号**，大括号 { } 则是必须的。

``` go=
package main

import "fmt"

func main() {
	sum := 0
	for i := 0; i < 10; i++ {
		sum += i
	}
	//fmt.Println(i)    错误示范，报错 undefined: i，i只在for循环中可见
	fmt.Println(sum)
}

// 45
```

#### for(续)
for语句初始化语句和后置语句是可选的
``` go=
package main

import "fmt"

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

/*
2
4
8
16
*/
```

#### for range
for 循环的 range 形式可遍历切片或映射。

当使用 for 循环遍历切片时，每次迭代都会返回两个值。第一个值为当前元素的下标，第二个值为该下标所对应元素的一份副本。

``` go=
package main

import "fmt"

var pow = []int{1, 2, 4, 8, 16, 32, 64, 128}

func main() {
	for i, v := range pow {
		fmt.Printf("2**%d = %d\n", i, v)
	}
}



/*
2**0 = 1
2**1 = 2
2**2 = 4
2**3 = 8
2**4 = 16
2**5 = 32
2**6 = 64
2**7 = 128
*/
```

#### for range（续）
可以将下标或值赋予 _ 来忽略它。

若你只需要索引，去掉 , value 的部分即可。

``` go=
package main

import "fmt"

func main() {
	pow := make([]int, 10)
	for i := range pow {
		pow[i] = 1 << uint(i) // == 2**i
	}
	for _, value := range pow {
		fmt.Printf("%d\n", value)
	}
}

/*
1
2
4
8
16
32
64
128
256
512
*/
```
#### 没有while只有for
其他语言中的while在go中叫做for
``` go=
package main

import "fmt"

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

#### 死循环
如果省略循环条件，该循环就不会结束，因此死循环可以写得很紧凑。
``` go=
package main

func main() {
	for {
	}
}
```

#### if
Go 的 if 语句与 for 循环类似，表达式外无需小括号 ( ) ，而大括号 { } 则是必须的。

``` go=
package main

import (
	"fmt"
	"math"
)

// 正数开平方根得正数，负数开平方根得复数
func sqrt(x float64) string {
	if x < 0 {
		return sqrt(-x) + "i"    //递归调用
	}
	return fmt.Sprint(math.Sqrt(x))
}

func main() {
	fmt.Println(sqrt(2), sqrt(-4))
}

// 1.4142135623730951 2i
```

#### if 的简短语句
同 for 一样， if 语句可以在条件表达式前执行一个简单的语句。

该语句声明的变量作用域仅在 if 之内。

（在最后的 return 语句处使用 v 看看。）

``` go=
package main

import (
	"fmt"
	"math"
)

func pow(x, n, lim float64) float64 {
	if v := math.Pow(x, n); v < lim {
		return v
	}
	return lim
}

func main() {
	fmt.Println(
		pow(3, 2, 10),
		pow(3, 3, 20),
	)
}

// 9 20
```

#### if 和 else
在 if 的简短语句中声明的变量同样可以在任何对应的 else 块中使用。

（在 main 的 fmt.Println 调用开始前，两次对 pow 的调用均已执行并返回。）

``` go=
package main

import (
	"fmt"
	"math"
)

func pow(x, n, lim float64) float64 {
	if v := math.Pow(x, n); v < lim {
		return v
	} else {
		fmt.Printf("%g >= %g\n", v, lim)  //%g, 一般数字格式化输出选择%g,意义为根据情况选择 %e 或 %f 以产生更紧凑的（无末尾的0）输出
	}
	// 这里开始就不能使用 v 了
	return lim
}

func main() {
	fmt.Println(
		pow(3, 2, 10),
		pow(3, 3, 20),
	)
}
```


#### switch
switch 是编写一连串 if - else 语句的简便方法。它运行第一个匹配的 case 语句。

Go 的 switch 语句类似于 C、C++、Java、JavaScript 和 PHP ，不过 Go 只运行选定的 case，而非之后所有的 case。 实际上，Go 自动提供了在这些语言中每个 case 后面所需的 break 语句。 除非以 fallthrough 语句结束，否则分支会自动终止。 Go 的另一点重要的不同在于 switch 的 case 无需为常量，且取值不必为整数。

``` go=
package main

import (
	"fmt"
	"runtime"
)

// 判断操作系统
func main() {
	fmt.Print("Go runs on ")
	switch os := runtime.GOOS; os {  
	case "darwin":      // os == "darwin"
		fmt.Println("OS X.")
	case "linux":       // os == "linux"
		fmt.Println("Linux.")
	default:
		// freebsd, openbsd,
		// plan9, windows...
		fmt.Printf("%s.", os)       // %s代表字符串或切片的无解译字节
	}
}
```

#### switch的求值顺序

switch 的 case 语句从上到下顺次执行，直到匹配成功时停止。

例如

switch i {
case 0:
case f():
}

在 i==0 时 f 不会被调用。


``` go=
package main

import (
	"fmt"
	"time"
)

func main() {
	
	today := time.Now().Weekday()
	fmt.Printf("today's type is: %T and value is %v\n", today,today)
	fmt.Println("When's Saturday?")
	switch time.Saturday {
	case today + 0:
		fmt.Println("Today.")
	case today + 1:
		fmt.Println("Tomorrow.")
	case today + 2:
		fmt.Println("In two days.")
	default:
		fmt.Println("Too far away.")
	}
}

// today的类型是time.Weekday,值为Tuesday,应该属于枚举类型，因为在case语句中还可以实现数学运算

/*
today's type is: time.Weekday and value is Tuesday
When's Saturday?
Too far away.
*/
```

#### 没有条件的 switch
没有条件的 switch 同 switch true 一样。

这种形式能将一长串 if-then-else 写得更加清晰。

``` go=
package main

import (
	"fmt"
	"time"
)

func main() {
	t := time.Now()
	fmt.Println(t)
	switch {
	case t.Hour() < 12:
		fmt.Println("Good morning!")
	case t.Hour() < 17:
		fmt.Println("Good afternoon.")
	default:
		fmt.Println("Good evening.")
	}
}

/*
2009-11-10 23:00:00 +0000 UTC m=+0.000000001
Good evening.
*/
```

#### defer
defer 语句会将函数推迟到外层函数返回之后执行。

推迟调用的函数其参数会立即求值，但直到外层函数返回前该函数都不会被调用。

推迟的函数调用会被压入一个栈中。当外层函数返回时，被推迟的函数会按照后进先出的顺序调用。

``` go=
package main

import "fmt"

func main() {
	fmt.Println("counting")

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

	fmt.Println("done")
}

/*
counting
done
9
8
7
6
5
4
3
2
1
0
*/
```

### struct、slice 和 映射

#### 指针
Go 拥有指针。指针保存了值的内存地址。

类型 *T 是指向 T 类型值的指针。其零值为 nil。

var p *int
& 操作符会生成一个指向其操作数的指针。

i := 42
p = &i
* 操作符表示指针指向的底层值。

fmt.Println(*p) // 通过指针 p 读取 i
*p = 21         // 通过指针 p 设置 i
这也就是通常所说的“间接引用”或“重定向”。

与 C 不同，Go 没有指针运算。

``` go=
package main

import "fmt"

func main() {
	i, j := 42, 2701

	p := &i         // p取到i的引用，p是i的地址
	fmt.Println(p)  // i的地址
	fmt.Println(*p) // i的值（指针p中的内容）
	*p = 21         // 通过指针设置i的值
	fmt.Println(i)  // 打印i的值（21）

	p = &j         // p重新指向了j，p等于j的地址
	fmt.Println(p) // j的地址
	*p = *p / 37   // 使用p所指向的内容进行运算
	fmt.Println(j) // 打印j的值
	
	var p1 *int     // 空指针
	fmt.Println(p1) //<nil>
}
```

#### 结构体
一个结构体（struct）就是一个字段的集合, 是用户自定义类型。结构体中的字段使用点号来访问。
``` go=
package main

import "fmt"

type Vertex struct {
	X int
	Y int
}

func main() {
	v := Vertex{1, 2}
	v.X = 4
	fmt.Println(v.X)
	fmt.Println(v)
}

/*
4
{4 2}
*/
```

#### 结构体指针
指针适用于结构体。

结构体字段可以通过结构体指针来访问。

如果我们有一个指向结构体的指针 p，那么可以通过 (*p).X 来访问其字段 X。不过这么写太啰嗦了，所以go语言也允许我们使用隐式间接引用，直接写 p.X 就可以。

``` go=
package main

import "fmt"

type Vertex struct {
	X int
	Y int
}

func main() {
	v := Vertex{1, 2}
	p := &v
	(*p).X = 1e9
	fmt.Println(p.X)  // 等价于(*p).X
	fmt.Println(v)
}

/*
1000000000
{1000000000 2}
*/
```


#### 结构体赋值
结构体常量通过直接列出字段的值来新分配一个结构体。

使用 Name: 语法可以仅列出部分字段。（字段名的顺序无关。）

特殊的前缀 & 返回一个指向结构体的指针。

``` go=
package main

import "fmt"

type Vertex struct {
	X, Y int
}

var (
	v1 = Vertex{1, 2}  // has type Vertex
	v2 = Vertex{X: 1}  // X: 1只给X赋了值，Y保持默认值0
	v3 = Vertex{}      // X和Y都保持默认值
	p  = &v1 // p是v1的指针，类型为*Vertex
)

func main() {
	fmt.Println("p: ", p)   // v1的引用
	fmt.Println("*p: ", *p) // v1的值
	fmt.Println(v1, v2, v3)
}

/*
p:  &{1 2}
*p:  {1 2}
{1 2} {1 0} {0 0}
*/
```

#### 数组
类型 [n]T 表示拥有 n 个 T 类型的值的数组。

表达式

var a [10]int
会将变量 a 声明为拥有有 10 个整数的数组。

数组的长度是其类型的一部分，因此数组不能改变大小。这看起来是个限制，不过没关系，Go 提供了更加便利的方式来使用数组。

``` go=
package main

import "fmt"

func main() {
	var a [2]string		// 先声明，后赋值
	a[0] = "Hello"
	a[1] = "World"			
	fmt.Println(a[0], a[1])
	fmt.Println(a)

	primes := [6]int{2, 3, 5, 7, 11, 13}   // 声明 + 赋初值
	fmt.Println(primes)
}

/*
Hello World
[Hello World]
[2 3 5 7 11 13]
*/
```

#### 切片
每个数组的大小都是固定的。而切片则为数组元素提供动态大小的、灵活的视角。在实践中，切片比数组更常用。

类型 []T 表示一个元素类型为 T 的切片。

切片通过两个下标来界定，即一个上界和一个下界，二者以冒号分隔：

a[low : high]
它会选择一个半开区间，包括第一个元素，但排除最后一个元素。

以下表达式创建了一个切片，它包含 a 中下标从 1 到 3 的元素：

a[1:4]

``` go=
package main

import "fmt"

func main() {
	primes := [6]int{2, 3, 5, 7, 11, 13}

var s []int = primes[1:4]  // 实际上取值为下标[1,4)的元素，不包括4
	fmt.Println(s)
}


//[3 5 7]
```

#### 切片是数组的视图
切片并不存储任何数据，它只是描述了底层数组中的一段。

更改切片的元素会修改数组中对应的元素。

与它共享底层数组的切片都会观测到这些修改。

``` go=
package main

import "fmt"

func main() {
	names := [4]string{
		"John",
		"Paul",
		"George",
		"Ringo",
	}
	fmt.Println(names)

	a := names[0:2]
	b := names[1:3]
	fmt.Println(a, b)

	b[0] = "XXX"		// 更改切片b中的元素同步影响切片a和数组names
	fmt.Println(a, b)
	fmt.Println(names)
}

/*
[John Paul George Ringo]
[John Paul] [Paul George]
[John XXX] [XXX George]
[John XXX George Ringo]
*/
```

#### 切片常量
切片常量类似于没有长度的数组常量。

这是一个数组常量：

[3]bool{true, true, false}
下面这样则会创建一个和上面相同的数组，然后构建一个引用了它的切片：

[]bool{true, true, false}

``` go=
package main

import "fmt"

func main() {
	q := []int{2, 3, 5, 7, 11, 13}
	fmt.Println(q)

	r := []bool{true, false, true, true, false, true}
	fmt.Println(r)

	s := []struct {
		i int
		b bool
	}{
		{2, true},
		{3, false},
		{5, true},
		{7, true},
		{11, false},
		{13, true},
	}
	fmt.Println(s)
}

/*
[2 3 5 7 11 13]
[true false true true false true]
[{2 true} {3 false} {5 true} {7 true} {11 false} {13 true}]
*/
```

#### 切片的默认行为
在进行切片时，你可以利用它的默认行为来忽略上下界。

切片下界的默认值为 0，上界则是该切片的长度。

对于数组

var a [10]int
来说，以下切片是等价的：

a[0:10]
a[:10]
a[0:]
a[:]

``` go=
package main

import "fmt"

func main() {
	s := []int{2, 3, 5, 7, 11, 13}

	s = s[1:4]
	fmt.Println(s)

	s = s[:2]
	fmt.Println(s)

	s = s[1:]
	fmt.Println(s)
}

/*
[3 5 7]
[3 5]
[5]
*/
```

#### 切片的长度与容量
切片拥有 长度 和 容量。

切片的长度 = 元素个数。

切片的容量是从它的第一个元素开始数，到其底层数组元素末尾的个数。

切片 s 的长度和容量可通过表达式 len(s) 和 cap(s) 来获取。

你可以通过重新切片来扩展一个切片，给它提供足够的容量。试着修改示例程序中的切片操作，向外扩展它的容量，看看会发生什么。

``` go=
package main

import "fmt"

func main() {
	s := []int{2, 3, 5, 7, 11, 13}
	printSlice(s)

	// Slice the slice to give it zero length.
	s = s[:0]
	printSlice(s)

	// Extend its length.
	// 扩展长度时不能超过底层数组的边界
	//s = s[:7]  报错 panic: runtime error: slice bounds out of range
	s = s[:6]  // 最大允许6
	s = s[:4]
	printSlice(s)

	// Drop its first two values.
	s = s[2:]
	printSlice(s)
}

func printSlice(s []int) {
	fmt.Printf("len=%d cap=%d %v\n", len(s), cap(s), s)   //%d, 十进制表示
}

/*
len=6 cap=6 [2 3 5 7 11 13]
len=0 cap=6 []
len=4 cap=6 [2 3 5 7]
len=2 cap=4 [5 7]
*/
```
#### 用make创建切片
切片可以用内建函数 make 来创建，这也是你创建动态数组的方式。

make 函数会分配一个元素为零值的数组并返回一个引用了它的切片：

> a := make([]int, 5)  // len(a)=5

要指定它的容量，需向 make 传入第三个参数：

> b := make([]int, 0, 5)      // len(b)=0, cap(b)=5
> b = b[:cap(b)] // len(b)=5, cap(b)=5
> b = b[1:]      // len(b)=4, cap(b)=4

``` go=
package main

import "fmt"

func main() {
	a := make([]int, 5)
	printSlice("a", a)    // [0 0 0 0 0] ,长度为5的数组且被初始化

	b := make([]int, 0, 5)     
	printSlice("b", b)    // []，长度为0，容量为5的数字且未被初始化

	c := b[:2]
	printSlice("c", c)

	d := c[2:5]
	printSlice("d", d)
}

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

/*
a len=5 cap=5 [0 0 0 0 0]        //
b len=0 cap=5 []
c len=2 cap=5 [0 0]
d len=3 cap=3 [0 0 0]
*/
```

#### 切片容量扩展

``` go=
package main

import (
	"fmt"
)

func main() {
	//s0 := make([]int)		报错：missing len argument to make([]int)
	s1 := make([]int, 5)		// cap 5, len 5
	s2 := make([]int, 0, 3)	 	// cap 3, len 0	
	printSlice(s1)
	printSlice(s2)
	for i := 0; i < 10; i++ {	
		s2 = append(s2, i)
		printSlice(s2)
	}
}


func printSlice(s []int) {
	fmt.Printf("cap %v, len %v, %p\n", cap(s), len(s), s)
}

 
/*
cap 5, len 5, 0x10458000       // s0
cap 3, len 0, 0x10414020       // s1定义后
cap 3, len 1, 0x10414020
cap 3, len 2, 0x10414020
cap 3, len 3, 0x10414020
cap 8, len 4, 0x10458040       // 容量不够了，扩容：原容量如果是奇数，则扩容容量 = （原容量+1）* 2；原容量如果是偶数则扩容后的容量 = 原容量 * 2
cap 8, len 5, 0x10458040
cap 8, len 6, 0x10458040
cap 8, len 7, 0x10458040
cap 8, len 8, 0x10458040
cap 16, len 9, 0x1043a080     // 容量再度不够用，扩容，容量翻倍
cap 16, len 10, 0x1043a080
*/
```

#### nil 切片
切片的零值是 nil。

nil 切片的长度和容量为 0 且没有底层数组。

``` go=
package main

import "fmt"

func main() {
	var s []int
	fmt.Println(s, len(s), cap(s))
	if s == nil {
		fmt.Println("nil!")
	}
}


/*
[] 0 0
nil!
*/
```


#### 切片的切片(多维切片)

``` go=
package main

import (
	"fmt"
	"strings"
)

func main() {
	// Create a tic-tac-toe board.
	board := [][]string{            // 二维切片
		[]string{"_", "_", "_"},
		[]string{"_", "_", "_"},
		[]string{"_", "_", "_"},
	}

	// The players take turns.
	board[0][0] = "X"
	board[2][2] = "O"
	board[1][2] = "X"
	board[1][0] = "O"
	board[0][2] = "X"

	for i := 0; i < len(board); i++ {
		fmt.Printf("%s\n", strings.Join(board[i], " "))
	}
}


/*
X _ X
O _ X
_ _ O
*/

```

#### 向切片追加元素
为切片追加新的元素是种常用的操作，为此 Go 提供了内建的 append 函数。内建函数的文档对此函数有详细的介绍。

`func append(s []T, vs ...T) []T`

append 的第一个参数 s 是一个元素类型为 T 的切片，其余类型为 T 的值将会追加到该切片的末尾。

append 的结果是一个包含原切片所有元素加上新添加元素的切片。

当 s 的底层数组太小，不足以容纳所有给定的值时，它就会分配一个更大的数组。返回的切片会指向这个新分配的数组。

（要了解关于切片的更多内容，请阅读文章 [Go 切片：用法和本质](https://blog.go-zh.org/go-slices-usage-and-internals)。）

``` go=
package main

import "fmt"

func main() {
	var s []int
	printSlice(s)

	// append works on nil slices.
	s = append(s, 0)
	printSlice(s)

	// The slice grows as needed.
	s = append(s, 1)
	printSlice(s)

	// We can add more than one element at a time.
	s = append(s, 2, 3, 4)
	printSlice(s)
}

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



/*
len=0 cap=0 []
len=1 cap=2 [0]
len=2 cap=2 [0 1]
len=5 cap=8 [0 1 2 3 4]
*/
```

#### map
map将key射到值。定义方式为 

`map[KeyType]ValueType`

map和指针、切片一样，是引用类型

未经初始化前，map的值为 nil，使用map前需要通过make使map初始化

`m = make(map[string]int)`

或这样（两者效果一样）

`m = map[string]int{}`

参考官方博客： [Go maps in action](https://blog.golang.org/go-maps-in-action)

``` go=
package main

import "fmt"

type Vertex struct {
	Lat, Long float64
}

var m map[string]Vertex			//定义map，类似python的字典类型，key为string型，值为自定义struct型

func main() {
	m = make(map[string]Vertex)  // 初始化map
	m["Bell Labs"] = Vertex{
		40.68433, -74.39967,
	}
	fmt.Println(m["Bell Labs"])
	
	user := make(map[int]string)  // 定义 + 初始化
	user[0] = "zhangsan"
	user[1] = "lisi"
	fmt.Println(user)
}

/*
{40.68433 -74.39967}
map[0:zhangsan 1:lisi]
*/

```
#### map赋初值


``` go=

package main

import "fmt"

type Vertex struct {
	Lat, Long float64
}

var m = map[string]Vertex{
// Vertex可省略，"Bell Labs": {40.68433, -74.39967}
        "Bell Labs": Vertex{        
		40.68433, -74.39967,
	},                        
	"Google": Vertex{
		37.42202, -122.08408,
	},
}

func main() {
	
	m1 := map[int]string{}
	m1[0] = "zhangsan"
	m1[1] = "lisi"
	
	m2 := map[int]string{0:"wangwu",1:"shiming"}
	m2[3] = "moumou"
	
	fmt.Println(m)
	fmt.Println(m1)
	fmt.Println(m2)
}


/*
map[Bell Labs:{40.68433 -74.39967} Google:{37.42202 -122.08408}]
map[0:zhangsan 1:lisi]
map[0:wangwu 1:shiming 3:moumou]
*/
```

#### 修改map
在映射 m 中插入或修改元素：
`m[key] = elem`

获取元素：
`elem = m[key]`

删除元素：
`delete(m, key)`

通过双赋值检测某个键是否存在：
`elem, ok = m[key]`

若 key 在 m 中，ok 为 true；否则，ok 为 false。

若 key 不在映射中，那么 elem 是该映射元素类型的零值。

同样的，当从 映射 中读取某个不存在的键时，结果是 映射 的元素类型的零值。

注 ：若 elem 或 ok 还未声明，你可以使用短变量声明：

`elem, ok := m[key]`

``` go=
package main

import "fmt"

func main() {
	m := make(map[string]int)	// 定义map并初始化

	m["Answer"] = 42	// 添加键值对
	fmt.Println("The value:", m["Answer"])

	m["Answer"] = 48	// 修改键值对
	fmt.Println("The value:", m["Answer"])

	delete(m, "Answer")	// 删除键值对
	fmt.Println("The value:", m["Answer"])

	v, ok := m["Answer"] // 验证键Answer是否存在
	fmt.Println("The value:", v, "Present?", ok)
	
	m["coffee"] = 20
	
	v, ok = m["coffee"]  // 验证键coffee是否存在，存在的话v将取到对应的值
	fmt.Println("The value:", v, "Present?", ok)
}

/*
The value: 42
The value: 48
The value: 0
The value: 0 Present? false
The value: 20 Present? true
*/
```


#### 函数值

函数也是值。它们可以像其它值一样传递。

函数值可以用作函数的参数或返回值。


``` go=
package main

import (
	"fmt"
	"math"
)

// fn是一个匿名函数，(fn func(float64, float64) float64)代表匿名函数，输入值为两个float64, 返回值也是float64，最后一个float64代表函数compute的返回值为float64

func compute(fn func(float64, float64) float64) float64 { 
	return fn(3, 4)
}

func main() {
	// 匿名函数也可以给变量赋值
	hypot := func(x, y float64) float64 {	// hypot - 三角形的斜边长
		return math.Sqrt(x*x + y*y)
	}
	// 赋值后的变量类型是一个函数了，值是一个引用
	fmt.Printf("hypot type is: %T，value is %v\n",hypot, hypot)
	
	// 要使用函数需要给它传对应的参数
	fmt.Println(hypot(5, 12))

	// 等价于hypot(3,4)
	fmt.Println(compute(hypot))
	
	// 等价于math.Pow(3,4)，即3^4
	fmt.Println(compute(math.Pow))
}

/*
hypot type is: func(float64, float64) float64，value is 0xd7400
13
5
*/
81
```

#### 函数的闭包
Go 函数可以是一个闭包。闭包是一个函数值，它引用了其函数体之外的变量。该函数可以访问并改变其引用的变量的值，换句话说，该函数被“绑定”在了这些变量上。

例如，函数 adder 返回一个闭包。每个闭包都被绑定在其各自的 sum 变量上。

``` go=
package main

import "fmt"

func adder() func(int) int {	// adder的返回值是一个函数，函数入参int,出参int
	sum := 0					
	return func(x int) int {	// 返回函数，依赖于外部的sum变量
		sum += x				// 每次调用时，sum的值都被记录下来
		return sum
	}
}

func main() {
	pos, neg := adder(), adder()
	for i := 0; i < 10; i++ {
		fmt.Println(
			"i =", i,
			pos(i),
			neg(-2*i),
		)
	}
}

/*
i = 0 0 0
i = 1 1 -2
i = 2 3 -6
i = 3 6 -12
i = 4 10 -20
i = 5 15 -30
i = 6 21 -42
i = 7 28 -56
i = 8 36 -72
i = 9 45 -90
*/
```

#### 闭包打印斐波那契数列
``` go=
package main

import "fmt"

// fibonacci 函数会返回一个返回 int 的函数。
func fibonacci() func() int {
    x1, x2 := 0, 1
    sum := 0
    return func() int {
        sum = x1 + x2
        x1 = x2
        x2 = sum
        return sum
    }
}

func main() {
    f := fibonacci()
    for i := 0; i < 10; i++ {
        if i == 0{
            fmt.Print(0)
        }
        fmt.Print(f(),", ")
    }
    fmt.Println("...")
}

```

### 方法和接口
#### 方法
Go 没有类。不过你可以为结构体类型定义方法。

方法就是一类带特殊的 接收者 参数的函数。

方法接收者在它自己的参数列表内，位于 func 关键字和方法名之间。

在此例中，Abs 方法拥有一个名为 v，类型为 Vertex 的接收者。

``` go=
package main

import (
	"fmt"
	"math"
)

type Vertex struct {
	X, Y float64
}

func (v Vertex) Abs() float64 {			// 经过此定义后，所有Vertex结构体类型实例都能够通过v.Abs()调用Abs方法
	return math.Sqrt(v.X*v.X + v.Y*v.Y)
}

func main() {
	v := Vertex{3, 4}
	fmt.Println(v.Abs())    // 5
}

```

#### 方法即函数
记住：方法只是个带接收者参数的函数。

现在这个 Abs 的写法就是个正常的函数，功能并没有什么变化。

``` go=
package main

import (
	"fmt"
	"math"
)

type Vertex struct {
	X, Y float64
}

func Abs(v Vertex) float64 {
	return math.Sqrt(v.X*v.X + v.Y*v.Y)
}

func main() {
	v := Vertex{3, 4}
	fmt.Println(Abs(v))
}
```

#### 方法（续）
可以为非结构体类型声明方法。

在此例中，我们看到了一个带 Abs 方法的数值类型 MyFloat。

你只能为在同一包内定义的类型的接收者声明方法，而不能为其它包内定义的类型（包括 int 之类的内建类型）的接收者声明方法。

（译注：就是接收者的类型定义和方法声明必须在同一包内；不能为内建类型声明方法。）

``` go=
package main

import (
	"fmt"
	"math"
	"strings"
)

type MyFloat float64
type MyString string

func (f MyFloat) Abs() float64 {	// 求绝对值
	if f < 0 {
		return float64(-f)
	}
	return float64(f)
}

func (s MyString) ToUpperCase() string {	// 转大写
	return strings.ToUpper(string(s))
}

func main() {
	f := MyFloat(-math.Sqrt2) // math.Sqrt2 = 根号2（常量）
	s := MyString("shiming")
	fmt.Println(f.Abs(), s.ToUpperCase())    // 1.4142135623730951 SHIMING
}

```

#### 指针接收者
你可以为指针接收者声明方法。

这意味着对于某类型 T，接收者的类型可以用 *T 的文法。（此外，T 不能是像 *int 这样的指针。）

例如，这里为 *Vertex 定义了 Scale 方法。

指针接收者的方法可以修改接收者指向的值（就像 Scale 在这做的）。由于方法经常需要修改它的接收者，指针接收者比值接收者更常用。

试着移除第 16 行 Scale 函数声明中的 *，观察此程序的行为如何变化。

若使用值接收者，那么 Scale 方法会对原始 Vertex 值的副本进行操作。（对于函数的其它参数也是如此。）Scale 方法必须用指针接受者来更改 main 函数中声明的 Vertex 的值。

``` go=
package main

import (
	"fmt"
	"math"
)

type Vertex struct {
	X, Y float64
}

func (v Vertex) Abs() float64 {			// 值传递
	return math.Sqrt(v.X*v.X + v.Y*v.Y)
}

func (v *Vertex) Scale(f float64) {		// 引用传递（注意：接受者声明中的变量是v不是&v，golang语法糖）
	v.X = v.X * f
	v.Y = v.Y * f
}

func main() {
	v := Vertex{3, 4}
	v.Scale(10)
	fmt.Println(v.X, v.Y, v.Abs())  // 30 40 50
}


```
#### 指针与函数
现在我们要把 Abs 和 Scale 方法重写为函数。

同样，我们先试着移除掉第 16 的 *。你能看出为什么程序的行为改变了吗？要怎样做才能让该示例顺利通过编译？

``` go=

package main

import (
	"fmt"
	"math"
)

type Vertex struct {
	X, Y float64
}

func Abs(v Vertex) float64 {
	return math.Sqrt(v.X*v.X + v.Y*v.Y)
}

func Scale(v *Vertex, f float64) {		// 如果把这行的*拿掉，第23行的&也必须拿掉，变成值传递，并不改变Vertex中元素的值
	v.X = v.X * f
	v.Y = v.Y * f
}

func main() {
	v := Vertex{3, 4}
	Scale(&v, 10)						
	fmt.Println(Abs(v))    // 50
}

```

#### 方法与指针重定向
比较前两个程序，你大概会注意到带指针参数的函数必须接受一个指针：

``` go
var v Vertex
ScaleFunc(v, 5)  // 编译错误！
ScaleFunc(&v, 5) // OK
```
而以指针为接收者的方法被调用时，接收者既能为值又能为指针：

``` go
var v Vertex
v.Scale(5)  // OK
p := &v
p.Scale(10) // OK
```
对于语句 v.Scale(5)，即便 v 是个值而非指针，带指针接收者的方法也能被直接调用。 也就是说，由于 Scale 方法有一个指针接收者，为方便起见，Go 会将语句 v.Scale(5) 解释为 (&v).Scale(5)。


``` go=
package main

import "fmt"

type Vertex struct {
	X, Y float64
}

func (v *Vertex) Scale(f float64) {
	v.X = v.X * f
	v.Y = v.Y * f
}

func ScaleFunc(v *Vertex, f float64) {
	v.X = v.X * f
	v.Y = v.Y * f
}

func main() {
	v := Vertex{3, 4}
	v.Scale(2)
	ScaleFunc(&v, 10)

	p := &Vertex{4, 3}
	p.Scale(3)
	ScaleFunc(p, 8)

	fmt.Println(v, p)        // {60 80} &{96 72}
}
    
```

#### 方法与指针重定向（续）
同样的事情也发生在相反的方向。

接受一个值作为参数的函数必须接受一个指定类型的值：

``` go
var v Vertex
fmt.Println(AbsFunc(v))  // OK
fmt.Println(AbsFunc(&v)) // 编译错误！
```
而以值为接收者的方法被调用时，接收者既能为值又能为指针：

```
var v Vertex
fmt.Println(v.Abs()) // OK
p := &v
fmt.Println(p.Abs()) // OK
```
这种情况下，方法调用 p.Abs() 会被解释为 (*p).Abs()。

``` go=

package main

import (
	"fmt"
	"math"
)

type Vertex struct {
	X, Y float64
}

func (v Vertex) Abs() float64 {
	return math.Sqrt(v.X*v.X + v.Y*v.Y)
}

func AbsFunc(v Vertex) float64 {
	return math.Sqrt(v.X*v.X + v.Y*v.Y)
}

func main() {
	v := Vertex{3, 4}
	fmt.Println(v.Abs())
	fmt.Println(AbsFunc(v))

	p := &Vertex{4, 3}
	fmt.Println(p.Abs())
	fmt.Println(AbsFunc(*p))
}

/*
5
5
5
5
*/
```

#### 选择值或指针作为接收者
使用指针接收者的原因有二：

首先，方法能够修改其接收者指向的值。

其次，这样**可以避免在每次调用方法时复制该值。若值的类型为大型结构体时，这样做会更加高效**。

在本例中，Scale 和 Abs 接收者的类型为 *Vertex，即便 Abs 并不需要修改其接收者。

通常来说，所有给定类型的方法都应该有值或指针接收者，但并不应该二者混用。

``` go=
package main

import (
	"fmt"
	"math"
)

type Vertex struct {
	X, Y float64
}

func (v *Vertex) Scale(f float64) {
	v.X = v.X * f
	v.Y = v.Y * f
}

func (v *Vertex) Abs() float64 {
	return math.Sqrt(v.X*v.X + v.Y*v.Y)
}

func main() {
	v := &Vertex{3, 4}
	fmt.Printf("Before scaling: %+v, Abs: %v\n", v, v.Abs())
	v.Scale(5)
	fmt.Printf("After scaling: %+v, Abs: %v\n", v, v.Abs())
}

```

#### 接口
接口类型 是由一组方法签名定义的集合。

接口类型的变量可以保存任何实现了这些方法的值。

``` go=
package main

import (
	"fmt"
	"math"
)

type Abser interface {		// interface关键字
	Abs() float64			// 里面是方法签名定义，可以有多个方法
}							// 实现了所有方法才算实现了接口

type MyFloat float64

func (f MyFloat) Abs() float64 {	// MyFloat实现了interface
	if f < 0 {
		return float64(-f)
	}
	return float64(f)
}

type Vertex struct {
	X, Y float64
}

func (v *Vertex) Abs() float64 {	// *Vertex实现了interface
	return math.Sqrt(v.X*v.X + v.Y*v.Y)
}

func main() {
	var a Abser
	f := MyFloat(-math.Sqrt2)	// 将 -math.Sqrt2强制转换为MyFloat型赋值给f
	v := Vertex{3, 4}

	a = f  // a MyFloat 实现了 Abser
	a = &v // a *Vertex 实现了 Abser

	// 下面一行，v 是一个 Vertex（而不是 *Vertex）
	// 所以没有实现 Abser。
	//a = v		放开注释将报错

	fmt.Println(a.Abs())    // 5
}
```

#### 接口（续）

``` go=
// _Interfaces_ are named collections of method
// signatures.

package main

import "fmt"
import "math"

// Here's a basic interface for geometric shapes.
type geometry interface {
    area() float64
    perim() float64
}

// For our example we'll implement this interface on
// `rect` and `circle` types.
type rect struct {
    width, height float64
}
type circle struct {
    radius float64
}

// To implement an interface in Go, we just need to
// implement all the methods in the interface. Here we
// implement `geometry` on `rect`s.
func (r rect) area() float64 {
    return r.width * r.height
}
func (r rect) perim() float64 {        // 尝试注释掉这个方法试试（rect类型就没有实现geometry接口）
    return 2*r.width + 2*r.height
}

// The implementation for `circle`s.
func (c circle) area() float64 {
    return math.Pi * c.radius * c.radius
}
func (c circle) perim() float64 {
    return 2 * math.Pi * c.radius
}

// If a variable has an interface type, then we can call
// methods that are in the named interface. Here's a
// generic `measure` function taking advantage of this
// to work on any `geometry`.
func measure(g geometry) {
    fmt.Println(g)
    fmt.Println(g.area())
    fmt.Println(g.perim())
}

func main() {
    r := rect{width: 3, height: 4}
    c := circle{radius: 5}

    // The `circle` and `rect` struct types both
    // implement the `geometry` interface so we can use
    // instances of
    // these structs as arguments to `measure`.
    measure(r)
    measure(c)
}

/*
{3 4}
12
14
{5}
78.53981633974483
31.41592653589793
*/
```

#### 接口值
在内部，接口值可以看做包含值和具体类型的元组：

(value, type)
接口值保存了一个具体底层类型的具体值。

接口值调用方法时会执行其底层类型的同名方法。

``` go=
package main

import (
	"fmt"
	"math"
)

type I interface {
	M()
}

type T struct {
	S string
}

func (t *T) M() {
	fmt.Println(t.S)
}

type F float64

func (f F) M() {
	fmt.Println(f)
}

func main() {
	var i I

	i = &T{"Hello"}
	describe(i)
	i.M()

	i = F(math.Pi)
	describe(i)
	i.M()
}

func describe(i I) {
	fmt.Printf("(%v, %T)\n", i, i)
}

/*
(&{Hello}, *main.T)
Hello
(3.141592653589793, main.F)
3.141592653589793
*/
```

#### 底层值为 nil 的接口值
即便接口内的具体值为 nil，方法仍然会被 nil 接收者调用。

在一些语言中，这会触发一个空指针异常，但在 Go 中通常会写一些方法来优雅地处理它（如本例中的 M 方法）。

*注意：* 保存了 nil 具体值的接口其自身并不为 nil。

``` go=
package main

import "fmt"

type I interface {
	M()
}

type T struct {
	S string
}

func (t *T) M() {
	if t == nil {
		fmt.Println("<nil>")
		return
	}
	fmt.Println(t.S)
}

func main() {
	var i I

	var t *T
	i = t
	describe(i)
	i.M()

	i = &T{"hello"}
	describe(i)
	i.M()
}

func describe(i I) {
	fmt.Printf("(%v, %T)\n", i, i)
}


/*
(<nil>, *main.T)
<nil>
(&{hello}, *main.T)
hello
*/
```

#### nil 接口值
nil 接口值既不保存值也不保存具体类型。

为 nil 接口调用方法会产生运行时错误，因为接口的元组内并未包含能够指明该调用哪个 具体 方法的类型。

``` go=
package main

import "fmt"

type I interface {
	M()
}

func main() {
	var i I
	describe(i)
	i.M()    // 注释这行才不报错
}

func describe(i I) {
	fmt.Printf("(%v, %T)\n", i, i)
}

/*
(<nil>, <nil>)
panic: runtime error: invalid memory address or nil pointer dereference
[signal SIGSEGV: segmentation violati
*/

```

#### 神奇的空接口
指定了零个方法的接口值被称为**空接口：**

空接口或者最小接口 不包含任何方法，它对实现不做任何要求：

`type Any interface {} // any是一个很好的空接口名字`

空接口可保存任何类型的值。（因为每个类型都至少实现了零个方法。）

空接口被用来处理未知类型的值。例如，fmt.Print 可接受类型为 interface{} 的任意数量的参数。

空接口类似面向对象编程概念中的object类。

``` go=
package main

import "fmt"

func main() {
	var i interface{}
	describe(i)

	i = 42
	describe(i)

	i = "hello"
	describe(i)
}

func describe(i interface{}) {
	fmt.Printf("(%v, %T)\n", i, i)
}
```

#### 类型断言
类型断言 提供了访问接口值底层具体值的方式。

t := i.(T)
该语句断言接口值 i 保存了具体类型 T，并将其底层类型为 T 的值赋予变量 t。

若 i 并未保存 T 类型的值，该语句就会触发一个恐慌。

为了 判断 一个接口值是否保存了一个特定的类型，类型断言可返回两个值：其底层值以及一个报告断言是否成功的布尔值。

t, ok := i.(T)
若 i 保存了一个 T，那么 t 将会是其底层值，而 ok 为 true。

否则，ok 将为 false 而 t 将为 T 类型的零值，程序并不会panic。

请注意这种语法和读取一个映射时的相同之处。
``` go=
package main

import "fmt"

func main() {
	var i interface{} = "hello"

	s := i.(string)
	fmt.Println(s)

	s, ok := i.(string)
	fmt.Println(s, ok)

	f, ok := i.(float64)
	fmt.Println(f, ok)

	f = i.(float64) // panic
	fmt.Println(f)
}

/*
hello
hello true
0 false
panic: interface conversion: interface {} is string, not float64
*/

```

#### 类型判断（有意思）
类型选择 是一种按顺序从几个类型断言中选择分支的结构。

类型选择与一般的 switch 语句相似，不过类型选择中的 case 为类型（而非值）， 它们针对给定接口值所存储的值的类型进行比较。

``` go
switch v := i.(type) {
case T:
    // v 的类型为 T
case S:
    // v 的类型为 S
default:
    // 没有匹配，v 与 i 的类型相同
}
```
类型选择中的声明与类型断言 i.(T) 的语法相同，只是具体类型 T 被替换成了关键字 type。

此选择语句判断接口值 i 保存的值类型是 T 还是 S。在 T 或 S 的情况下，变量 v 会分别按 T 或 S 类型保存 i 拥有的值。在默认（即没有匹配）的情况下，变量 v 与 i 的接口类型和值相同。

``` go=
package main

import "fmt"

func do(i interface{}) {
	switch v := i.(type) {
	case int:
		fmt.Printf("Twice %v is %v\n", v, v*2)
	case string:
		fmt.Printf("%q is %v bytes long\n", v, len(v))
	default:
		fmt.Printf("I don't know about type %T!\n", v)
	}
}

func main() {
	do(21)
	do("hello")
	do(true)
}

/*
Twice 21 is 42
"hello" is 5 bytes long
I don't know about type bool!
*/
```

#### Stringer接口
fmt 包中定义的 Stringer 是最普遍的接口之一。

``` go
type Stringer interface {
    String() string
}
```
Stringer 是一个可以用字符串描述自己的类型。fmt 包（还有很多包）都通过此接口来打印值。

``` go=
package main

import "fmt"

type Person struct {
	Name string
	Age  int
}

func (p Person) String() string {	// 实现了Stringer接口
	return fmt.Sprintf("%v (%v years)", p.Name, p.Age)
}

func main() {
	a := Person{"Arthur Dent", 42}
	z := Person{"Zaphod Beeblebrox", 9001}
	fmt.Println(a,",", z) // Arthur Dent (42 years) , Zaphod Beeblebrox (9001 years)
}

```

#### 使用Stringer接口
通过让 IPAddr 类型实现 fmt.Stringer 来打印点号分隔的地址。

例如，IPAddr{1, 2, 3, 4} 应当打印为 "1.2.3.4"。

未实现Stringer接口前：
``` go=
package main

import "fmt"

type IPAddr [4]byte

func main() {
	addrs := map[string]IPAddr{
		"loopback":  {127, 0, 0, 1},
		"googleDNS": {8, 8, 8, 8},
	}
	for n, a := range addrs {
		fmt.Printf("%v: %v\n", n, a)
		fmt.Println(n,":",a)
	}

}

/*
loopback: [127 0 0 1]
loopback : [127 0 0 1]
googleDNS: [8 8 8 8]
googleDNS : [8 8 8 8]
*/


```


实现Stringer接口后：

``` go=
package main

import "fmt"

type IPAddr [4]byte

// Add a "String() string" method to IPAddr，implements Stringer interface
func (p IPAddr) String() string {
	return fmt.Sprintf("%d.%d.%d.%d", p[0], p[1], p[2], p[3])
}

func main() {
	addrs := map[string]IPAddr{
		"loopback":  {127, 0, 0, 1},
		"googleDNS": {8, 8, 8, 8},
	}
	for n, a := range addrs {
		fmt.Printf("%v: %v\n", n, a)
		fmt.Println(n,":",a)
	}

}


/*
loopback: 127.0.0.1
loopback : 127.0.0.1
googleDNS: 8.8.8.8
googleDNS : 8.8.8.8
*/
```

#### 错误
Go 程序使用 error 值来表示错误状态。

与 fmt.Stringer 类似，error 类型是一个内建接口：

``` go
type error interface {    // 与 fmt.Stringer 类似
    Error() string
}
```

通常函数会返回一个 error 值，调用的它的代码应当判断这个错误是否等于 nil 来进行错误处理。

``` go
i, err := strconv.Atoi("42")
if err != nil {
    fmt.Printf("couldn't convert number: %v\n", err)
    return
}
fmt.Println("Converted integer:", i)
```

error 为 nil 时表示成功；非 nil 的 error 表示失败。

``` go=
package main

import (
	"fmt"
	"time"
)

type MyError struct {		// 自定义error结构体
	When time.Time
	What string
}

func (e *MyError) Error() string {	// 自定义error打印格式
	return fmt.Sprintf("at %v, %s",
		e.When, e.What)
}

func run() error {		// return error when run
	return &MyError{
		time.Now(),
		"it didn't work",
	}
}

func main() {
	if err := run(); err != nil {	//err不为空则打印
		fmt.Println(err) //at 2009-11-10 23:00:00 +0000 UTC m=+0.000000001, it didn't work

	}
}

```

#### 错误处理
``` go=
package main

import (
"errors"
"fmt"
"math"
)

func main() {
	result, err := sqrt(-3)
	if err != nil {
		fmt.Println(err)		// invalid input: negative number
	} else {
		fmt.Println(result)		
	}

}

func sqrt(x float64) (float64, error) {
	if x < 0 {
		return 0, errors.New("invalid input: negative number")
	}

	return math.Sqrt(x), nil
}

```

### 并发
两个队列，一个Coffee机器: 并发
两个队列，两个Coffee机器: 并行
![](https://i.imgur.com/us17QJ2.jpg)

### golang init方法
https://blog.csdn.net/benben_2015/article/details/79486077

### 推荐几个学习golang感兴趣的链接

1. go router && http router
    - https://youtu.be/3BoStxKECL0

2. teleport & tp-micro
    - https://go.ctolib.com/article/wiki/90092

3. go学习
    - https://hackmd.io/uZJ5a66KQeOMuPaB0QdIuA

###### tags: `golang`