# 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机器: 并行
### 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`
Sign in with Wallet
Connect another wallet