biancheng-go语言概要总结

http://c.biancheng.net/golang/intro/

Go语言总结

1、Go 使用编译器来编译代码。最佳的平衡：快速编译，高效执行，易于开发。因为Go语言没有类和继承的概念，但是它通过接口（interface）的概念来实现多态性。

2、Goroutine 是 Go 最显著的特征，搭配 channel，实现 CSP 模型

3、Go 选择了 tcmalloc，它本就是为并发而设计的高性能内存分配组件

4、指针运算被阻止，否则要做到精确回收都难，Go 标准库虽称不得完全覆盖，但也算极为丰富。

5、指针（pointer）在Go语言中可以被拆分为两个核心概念：

类型指针，允许对这个指针类型的数据进行修改，传递数据可以直接使用指针，而无须拷贝数据，类型指针不能进行偏移和运算。
切片，由指向起始元素的原始指针、元素数量和容量组成。

6、切片（slice）是对数组的一个连续片段的引用，Go语言中的 map 在并发情况下，只读是线程安全的，同时读写是线程不安全的。var scene sync.Map

2 Go语言基本语法
2.1 Go语言变量的声明
2.2 Go语言变量的初始化
2.3 Go语言多个变量同时赋值
2.4 Go语言匿名变量
2.5 Go语言变量的作用域
根据变量定义位置的不同，可以分为以下三个类型：
函数内定义的变量称为局部变量
函数外定义的变量称为全局变量
函数定义中的变量称为形式参数
2.6 Go语言整型（整数类型）
2.7 Go语言浮点类型（小数类型）
2.8 Go语言复数
使用内置的 complex 函数构建复数，并使用 real 和 imag 函数返回复数的实部和虚部：
纯文本复制
var x complex128 = complex(1, 2) // 1+2i
var y complex128 = complex(3, 4) // 3+4i
fmt.Println(x*y) // "(-5+10i)"
fmt.Println(real(x*y)) // "-5"
fmt.Println(imag(x*y)) // "10"
2.9 实例：输出正弦函数（Sin）图像
2.10 Go语言bool类型（布尔类型）
一个布尔类型的值只有两种：true 或 false。if 和 for 语句的条件部分都是布尔类型的值，并且==和<等比较操作也会产生布尔型的值。
2.11 Go语言字符串
2.12 Go语言字符类型（byte和rune）
Go语言的字符有以下两种：
一种是 uint8 类型，或者叫 byte 型，代表了 ASCII 码的一个字符。
另一种是 rune 类型，代表一个 UTF-8 字符，当需要处理中文、日文或者其他复合字符时，则需要用到 rune 类型。rune 类型等价于 int32 类型。
2.13 Go语言数据类型转换
2.14 Go语言指针
指针（pointer）在Go语言中可以被拆分为两个核心概念：
类型指针，允许对这个指针类型的数据进行修改，传递数据可以直接使用指针，而无须拷贝数据，类型指针不能进行偏移和运算。
切片，由指向起始元素的原始指针、元素数量和容量组成。
ptr := &v // v 的类型为 T
其中 v 代表被取地址的变量，变量 v 的地址使用变量 ptr 进行接收，ptr 的类型为*T，称做 T 的指针类型，*代表指针。
取地址操作符&和取值操作符*是一对互补操作符，&取出地址，*根据地址取出地址指向的值。
变量、指针地址、指针变量、取地址、取值的相互关系和特性如下：
对变量进行取地址操作使用&操作符，可以获得这个变量的指针变量。
指针变量的值是指针地址。
对指针变量进行取值操作使用*操作符，可以获得指针变量指向的原变量的值。
2.15 Go语言变量逃逸分析
2.16 Go语言变量的生命周期
2.17 Go语言常量
2.18 Go语言模拟枚举
2.19 Go语言类型别名
2.20 Go语言注释的定义及使用
2.21 Go语言关键字与标识符
2.22 Go语言运算符的优先级

3 Go语言容器
3.1 Go语言数组
var a [3]int // 定义三个整数的数组
fmt.Println(a[0]) // 打印第一个元素
fmt.Println(a[len(a)-1]) // 打印最后一个元素
// 打印索引和元素
for i, v := range a {
fmt.Printf("%d %d\n", i, v)
}
3.2 Go语言多维数组
3.3 Go语言切片
slice [开始位置 : 结束位置]
语法说明如下：
slice：表示目标切片对象；
开始位置：对应目标切片对象的索引；
结束位置：对应目标切片的结束索引。
var a = [3]int{1, 2, 3}
fmt.Println(a, a[1:2])
使用 make() 函数构造切片
如果需要动态地创建一个切片，可以使用 make() 内建函数，格式如下：
make( []Type, size, cap )
a := make([]int, 2)
b := make([]int, 2, 10)
3.4 使用append()为切片添加元素
3.5 Go语言切片复制
slice1 := []int{1, 2, 3, 4, 5}
slice2 := []int{5, 4, 3}
copy(slice2, slice1) // 只会复制slice1的前3个元素到slice2中
copy(slice1, slice2) // 只会复制slice2的3个元素到slice1的前3个位置
3.6 Go语言从切片中删除元素
a = []int{1, 2, 3}
a = a[1:] // 删除开头1个元素
a = a[N:] // 删除开头N个元素
3.7 Go语言range关键字
// 创建一个整型切片，并赋值
slice := []int{10, 20, 30, 40}
// 迭代每一个元素，并显示其值
for index, value := range slice {
fmt.Printf("Index: %d Value: %d\n", index, value)
}
3.8 Go语言多维切片
3.9 Go语言map（映射）
var mapAssigned map[string]int
mapLit = map[string]int{"one": 1, "two": 2}
3.10 Go语言遍历map
scene := make(map[string]int)
scene["route"] = 66
scene["brazil"] = 4
scene["china"] = 960
for k, v := range scene {
fmt.Println(k, v)
}
3.11 map元素的删除和清空
使用 delete() 函数从 map 中删除键值对
使用 delete() 内建函数从 map 中删除一组键值对，delete() 函数的格式如下：
delete(map, 键)
delete(scene, "brazil")
清空 map 中的所有元素
有意思的是，Go语言中并没有为 map 提供任何清空所有元素的函数、方法，清空 map 的唯一办法就是重新 make 一个新的 map，不用担心垃圾回收的效率，Go语言中的并行垃圾回收效率比写一个清空函数要高效的多。
3.12 Go语言map的多键索引
3.13 Go语言sync.Map
3.14 Go语言list（列表）
l := list.New()
操作内容 列表元素
l.PushBack("canon") canon
l.PushFront(67) 67, canon
element := l.PushBack("fist") 67, canon, fist
l.InsertAfter("high", element) 67, canon, fist, high
l.InsertBefore("noon", element) 67, canon, noon, fist, high
l.Remove(element) 67, canon, noon, high
3.15 Go语言nil：空值/零值

4 流程控制
4.1 Go语言分支结构
if condition1 {
// do something
} else if condition2 {
// do something else
}else {
// catch-all or default
}
4.2 Go语言循环结构
sum := 0
for i := 0; i < 10; i++ {
sum += i
}
sum := 0
for {
sum++
if sum > 100 {
break
}
}
4.3 Go语言for range（键值循环）
4.4 Go语言for range（键值循环）
for key, val := range coll {
...
}
4.5 Go语言switch语句
var a = "hello"
switch a {
case "hello":
fmt.Println(1)
case "world":
fmt.Println(2)
default:
fmt.Println(0)

4.6 Go语言goto语句
4.7 Go语言break（跳出循环）
4.8 Go语言continue

5 Go语言函数
5.1 Go语言函数声明
5.4 Go语言函数变量
5.5 Go语言字符串的链式处理
5.6 Go语言匿名函数
5.7 Go语言函数类型实现接口
5.8 Go语言闭包（Closure）
5.9 Go语言可变参数
5.10 Go语言defer（延迟执行语句）
5.11 Go语言递归函数
5.12 Go语言处理运行时错误
5.13 Go语言宕机（panic）
5.14 Go语言宕机恢复（recover）
5.15 Go语言计算函数执行时间

6 Go语言结构体

Go 语言通过用自定义的方式形成新的类型，结构体是类型中带有成员的复合类型。Go 语言使用结构体和结构体成员来描述真实世界的实体和实体对应的各种属性。
Go 语言中的类型可以被实例化，使用new或&构造的类型实例的类型是类型的指针。
结构体成员是由一系列的成员变量构成，这些成员变量也被称为“字段”。字段有以下特性：
字段拥有自己的类型和值。
字段名必须唯一。
字段的类型也可以是结构体，甚至是字段所在结构体的类型。
关于 Go 语言的类（class）
Go 语言中没有“类”的概念，也不支持“类”的继承等面向对象的概念。
Go 语言的结构体与“类”都是复合结构体，但 Go 语言中结构体的内嵌配合接口比面向对象具有更高的扩展性和灵活性。
实例化 var p Point 或 ins := new(T) 取结构体的地址实例化 ins := &T{}

GC 是自动进行的，如果要手动进行 GC，可以使用 runtime.GC() 函数，显式的执行 GC。显式的进行 GC 只在某些特殊的情况下才有用，比如当内存资源不足时调用 runtime.GC() ，这样会立即释放一大片内存，但是会造成程序短时间的性能下降。
finalizer（终止器）是与对象关联的一个函数，通过 runtime.SetFinalizer 来设置，如果某个对象定义了 finalizer，当它被 GC 时候，这个 finalizer 就会被调用，以完成一些特定的任务，例如发信号或者写日志等。
单向链表
单向链表中每个结点包含两部分，分别是数据域和指针域，上一个结点的指针指向下一结点，依次相连，形成链表。
这里介绍三个概念：首元结点、头结点和头指针。
使用 Struct 定义一个单向链表。
纯文本复制
type Node struct {
Data int
Next *node
}
Go语言标准库的 bufio 包中，实现了对数据 I/O 接口的缓冲功能。这些功能封装于接口 io.ReadWriter、io.Reader 和 io.Writer 中，并对应创建了 ReadWriter、Reader 或 Writer 对象，在提供缓冲的同时实现了一些文本基本 I/O 操作功能。

7 Go语言接口

Go语言不是一种 “传统” 的面向对象编程语言：它里面没有类和继承的概念。但是Go语言里有非常灵活的接口概念，通过它可以实现很多面向对象的特性。
type 接口类型名 interface{
方法名1( 参数列表1 ) 返回值列表1
方法名2( 参数列表2 ) 返回值列表2
…
}
实现关系在Go语言中是隐式的。两个类型之间的实现关系不需要在代码中显式地表示出来。Go语言中没有类似于 implements 的关键字。 Go编译器将自动在需要的时候检查两个类型之间的实现关系。

8 Go语言常用内置包简介

标准的Go语言代码库中包含了大量的包，并且在安装 Go 的时候多数会自动安装到系统中。我们可以在 $GOROOT/src/pkg 目录中查看这些包。下面简单介绍一些我们开发中常用的包。

1) fmt

fmt 包实现了格式化的标准输入输出，这与C语言中的 printf 和 scanf 类似。其中的 fmt.Printf() 和 fmt.Println() 是开发者使用最为频繁的函数。

格式化短语派生于C语言，一些短语（%- 序列）是这样使用：

• %v：默认格式的值。当打印结构时，加号（%+v）会增加字段名；
• %#v：Go样式的值表达；
• %T：带有类型的 Go 样式的值表达。

2) io

这个包提供了原始的 I/O 操作界面。它主要的任务是对 os 包这样的原始的 I/O 进行封装，增加一些其他相关，使其具有抽象功能用在公共的接口上。

3) bufio

bufio 包通过对 io 包的封装，提供了数据缓冲功能，能够一定程度减少大块数据读写带来的开销。

在 bufio 各个组件内部都维护了一个缓冲区，数据读写操作都直接通过缓存区进行。当发起一次读写操作时，会首先尝试从缓冲区获取数据，只有当缓冲区没有数据时，才会从数据源获取数据更新缓冲。

4) sort

sort 包提供了用于对切片和用户定义的集合进行排序的功能。

5) strconv

strconv 包提供了将字符串转换成基本数据类型，或者从基本数据类型转换为字符串的功能。

6) os

os 包提供了不依赖平台的操作系统函数接口，设计像 Unix 风格，但错误处理是 go 风格，当 os 包使用时，如果失败后返回错误类型而不是错误数量。

7) sync

sync 包实现多线程中锁机制以及其他同步互斥机制。

8) flag

flag 包提供命令行参数的规则定义和传入参数解析的功能。绝大部分的命令行程序都需要用到这个包。

9) encoding/json

JSON 目前广泛用做网络程序中的通信格式。encoding/json 包提供了对 JSON 的基本支持，比如从一个对象序列化为 JSON 字符串，或者从 JSON 字符串反序列化出一个具体的对象等。

10) html/template

主要实现了 web 开发中生成 html 的 template 的一些函数。

11) net/http

net/http 包提供 HTTP 相关服务，主要包括 http 请求、响应和 URL 的解析，以及基本的 http 客户端和扩展的 http 服务。

通过 net/http 包，只需要数行代码，即可实现一个爬虫或者一个 Web 服务器，这在传统语言中是无法想象的。

12) reflect

reflect 包实现了运行时反射，允许程序通过抽象类型操作对象。通常用于处理静态类型 interface{} 的值，并且通过 Typeof 解析出其动态类型信息，通常会返回一个有接口类型 Type 的对象。

13) os/exec

os/exec 包提供了执行自定义 linux 命令的相关实现。

14) strings

strings 包主要是处理字符串的一些函数集合，包括合并、查找、分割、比较、后缀检查、索引、大小写处理等等。

strings 包与 bytes 包的函数接口功能基本一致。

15) bytes

bytes 包提供了对字节切片进行读写操作的一系列函数。字节切片处理的函数比较多，分为基本处理函数、比较函数、后缀检查函数、索引函数、分割函数、大小写处理函数和子切片处理函数等。

16) log

log 包主要用于在程序中输出日志。

log 包中提供了三类日志输出接口，Print、Fatal 和 Panic。

• Print 是普通输出；
• Fatal 是在执行完 Print 后，执行 os.Exit(1)；
• Panic 是在执行完 Print 后调用 panic() 方法。

9 Go语言并发

进程/线程
进程是程序在操作系统中的一次执行过程，系统进行资源分配和调度的一个独立单位。
线程是进程的一个执行实体，是 CPU 调度和分派的基本单位，它是比进程更小的能独立运行的基本单位。
一个进程可以创建和撤销多个线程，同一个进程中的多个线程之间可以并发执行。
并发/并行
多线程程序在单核心的 cpu 上运行，称为并发；多线程程序在多核心的 cpu 上运行，称为并行。
并发与并行并不相同，并发主要由切换时间片来实现“同时”运行，并行则是直接利用多核实现多线程的运行，Go程序可以设置使用核心数，以发挥多核计算机的能力。
协程/线程
协程：独立的栈空间，共享堆空间，调度由用户自己控制，本质上有点类似于用户级线程，这些用户级线程的调度也是自己实现的。
线程：一个线程上可以跑多个协程，协程是轻量级的线程。
goroutine： 是一种非常轻量级的实现，可在单个进程里执行成千上万的并发任务，它是Go语言并发设计的核心。
goroutine 是 Go语言中的轻量级线程实现，由 Go 运行时（runtime）管理。Go 程序会智能地将 goroutine 中的任务合理地分配给每个 CPU。
说到底 goroutine 其实就是线程，但是它比线程更小，十几个 goroutine 可能体现在底层就是五六个线程，而且Go语言内部也实现了 goroutine 之间的内存共享。
channel
channel 是Go语言在语言级别提供的 goroutine 间的通信方式。我们可以使用 channel 在两个或多个 goroutine 之间传递消息。
channel 是进程内的通信方式，因此通过 channel 传递对象的过程和调用函数时的参数传递行为比较一致，比如也可以传递指针等。如果需要跨进程通信，我们建议用分布式系统的方法来解决，比如使用 Socket 或者 HTTP 等通信协议。Go语言对于网络方面也有非常完善的支持。
sync.WaitGroup wg.Add(2) defer wg.Done() wg.Wait() mutex sync.Mutex mutex.Lock() mutex.Unlock()
因为 10 个 goroutine 是并发执行的，所以我们还引入了锁，也就是代码中的 lock 变量。每次对 n 的操作，都要先将锁锁住，操作完成后，再将锁打开。
代码中的 runtime.Gosched() 是让当前 goroutine 暂停的意思，退回执行队列，让其他等待的 goroutine 运行，目的是为了使资源竞争的结果更明显。
goroutine和coroutine的区别
Lua、Python 语言都支持 coroutine 特性。coroutine 与 goroutine 在名字上类似，都可以将函数或者语句在独立的环境中运行，但是它们之间有两点不同：
goroutine 可能发生并行执行；但 coroutine 始终顺序执行。
goroutines 意味着并行（或者可以以并行的方式部署），coroutines 一般来说不是这样的，goroutines 通过通道来通信；coroutines 通过让出和恢复操作来通信，goroutines 比 coroutines 更强大，也很容易从 coroutines 的逻辑复用到 goroutines。
狭义地说，goroutine 可能发生在多线程环境下，goroutine 无法控制自己获取高优先度支持；coroutine 始终发生在单线程，coroutine 程序需要主动交出控制权，宿主才能获得控制权并将控制权交给其他 coroutine。
goroutine 间使用 channel 通信，coroutine 使用 yield 和 resume 操作。
Go语言通道（chan）
一个 channels 是一个通信机制，它可以让一个 goroutine 通过它给另一个 goroutine 发送值信息。每个 channel 都有一个特殊的类型，也就是 channels 可发送数据的类型。一个可以发送 int 类型数据的 channel 一般写为 chan int。
通道像一个传送带或者队列，总是遵循先入先出（First In First Out）的规则，保证收发数据的顺序。
通道实例 := make(chan 数据类型)
数据类型：通道内传输的元素类型。
通道实例：通过make创建的通道句柄。
1) 阻塞接收数据
阻塞模式接收数据时，将接收变量作为<-操作符的左值，格式如下：
data := <-ch
执行该语句时将会阻塞，直到接收到数据并赋值给 data 变量。
2) 非阻塞接收数据
使用非阻塞方式从通道接收数据时，语句不会发生阻塞，格式如下：
data, ok := <-ch
data：表示接收到的数据。未接收到数据时，data 为通道类型的零值。
ok：表示是否接收到数据。
单向 channel 变量的声明非常简单，只能写入数据的通道类型为chan<-，只能读取数据的通道类型为<-chan，格式如下：
var 通道实例 chan<- 元素类型 // 只能写入数据的通道
var 通道实例 <-chan 元素类型 // 只能读取数据的通道
创建带缓冲通道
如何创建带缓冲的通道呢？参见如下代码：
通道实例 := make(chan 通道类型, 缓冲大小)
Go语言互斥锁（sync.Mutex）和读写互斥锁（sync.RWMutex）
Mutex 是最简单的一种锁类型，同时也比较暴力，当一个 goroutine 获得了 Mutex 后，其他 goroutine 就只能乖乖等到这个 goroutine 释放该 Mutex。
RWMutex 相对友好些，是经典的单写多读模型。在读锁占用的情况下，会阻止写，但不阻止读，也就是多个 goroutine 可同时获取读锁（调用 RLock() 方法；而写锁（调用 Lock() 方法）会阻止任何其他 goroutine（无论读和写）进来，整个锁相当于由该 goroutine 独占。从 RWMutex 的实现看，RWMutex 类型其实组合了 Mutex：
Go语言等待组（sync.WaitGroup）
(wg * WaitGroup) Add(delta int) 等待组的计数器 +1
(wg * WaitGroup) Done() 等待组的计数器 -1
(wg * WaitGroup) Wait() 当等待组计数器不等于 0 时阻塞直到变 0
死锁：是因为错误的使用了锁，导致异常；
活锁：是饥饿的一种特殊情况，逻辑上感觉对，程序也一直在正常的跑，但就是效率低，逻辑上进行不下去；
饥饿：与锁使用的粒度有关，通过计数取样，可以判断进程的工作效率。

10 reflect 包

Go语言中的反射是由 reflect 包提供支持的，它定义了两个重要的类型 Type 和 Value 任意接口值在反射中都可以理解为由 reflect.Type 和 reflect.Value 两部分组成，并且 reflect 包提供了 reflect.TypeOf 和 reflect.ValueOf 两个函数来获取任意对象的 Value 和 Type。

任意值通过 reflect.TypeOf() 获得反射对象信息后，如果它的类型是结构体，可以通过反射值对象（reflect.Type）的 NumField() 和 Field() 方法获得结构体成员的详细信息。与成员获取相关的 reflect.Type 的方法如下表所示。

Go语言程序中对指针获取反射对象时，可以通过 reflect.Elem() 方法获取这个指针指向的元素类型。这个获取过程被称为取元素，等效于对指针类型变量做了一个*操作

11 Go语言文件处理
11.1 Go语言自定义数据文件
11.2 Go语言JSON文件的读写操作
11.3 Go语言XML文件的读写操作
11.4 Go语言使用Gob传输数据
11.5 Go语言纯文本文件的读写操作
11.6 Go语言二进制文件的读写操作
11.7 Go语言自定义二进制文件的读写操作
11.8 Go语言zip归档文件的读写操作
11.9 Go语言tar归档文件的读写操作
11.10 Go语言使用buffer读取文件
buffer 是缓冲器的意思，Go语言要实现缓冲读取需要使用到 bufio 包。bufio 包本身包装了 io.Reader 和 io.Writer 对象，同时创建了另外的 Reader 和 Writer 对象，因此对于文本 I/O 来说，bufio 包提供了一定的便利性。
buffer 缓冲器的实现原理就是，将文件读取进缓冲（内存）之中，再次读取的时候就可以避免文件系统的 I/O 从而提高速度。同理在进行写操作时，先把文件写入缓冲（内存），然后由缓冲写入文件系统。
11.13 Go语言文件的写入、追加、读取、复制操作
下面列举了一些常用的 flag 文件处理参数：
O_RDONLY：只读模式打开文件；
O_WRONLY：只写模式打开文件；
O_RDWR：读写模式打开文件；
O_APPEND：写操作时将数据附加到文件尾部（追加）；
O_CREATE：如果不存在将创建一个新文件；
O_EXCL：和 O_CREATE 配合使用，文件必须不存在，否则返回一个错误；
O_SYNC：当进行一系列写操作时，每次都要等待上次的 I/O 操作完成再进行；
O_TRUNC：如果可能，在打开时清空文件。
11.14 Go语言文件锁操作
flock 是对于整个文件的建议性锁。也就是说，如果一个进程在一个文件（inode）上放了锁，其它进程是可以知道的（建议性锁不强求进程遵守）。最棒的一点是，它的第一个参数是文件描述符，在此文件描述符关闭时，锁会自动释放。而当进程终止时，所有的文件描述符均会被关闭。所以很多时候就不用考虑类似原子锁解锁的事情。

12 Go语言编译与工具
12.1 go build命令
12.2 go clean命令
12.3 go run命令
12.4 go fmt命令
12.5 go install命令
12.6 go get命令
12.7 go generate命令
12.8 go test命令
12.9 go pprof命令