Go 语言圣经学习笔记

Go 语言主要有四中声明语句:

• var: 变量
• const: 常量
• type: 类型
• func: 函数实体对象

:= 和 = 的区别:

• := 是声明变量并赋值
• = 是个单纯的赋值语句，如果声明变量需要加上 var 关键字

指针: 一个变量保存了变量对应类型值的内存空间。并不是每一个值都会有一个内存地址，但是对于每一个变量都必然有对应的内存地址。 & 表示取地址； * 表示解引用。

new 函数: 创建一个匿名变量、初始化之后，返回它的变量地址（注意和 C 语言的区别）。

Go 语言并不是通过使用 var 还是 new 声明变量的方式决定在堆上还是栈上分配变量，而是看实际的使用场景，如果一个变量的地址在 函数外继续使用了，则会分配在堆上（Go 语言术语称之为“逃逸”）。

Go 中的递增和递减是「语句」而非表达式，并且只支持后置的方式。比如： v++ 是正确的， x = i++ 是错误的。

Go 支持向 Python 一样元组赋值。和 Python 一样， _ 用来丢弃不需要的值。

包中如果一个名字是大写字母开头的，那么该名字是导出的，否则在包外不可见。

使用 package 声明包，使用 import 导入包。

不要将作用域和生命周期混为一谈。声明语句的作用域对应的是一个源代码的文本区域；它是一个编译时的属性。一个变量的生命周期是 指程序运行时变量存在的有效时间段，在此时间区域内它可以被程序的其他部分引用；是一个运行时的概念。

任何在函数外部（也就是包级别作用域）声明的名字可以在同一个包的任何源文件中访问。

int8, int16, int32, int64 和 uint8, uint16, uint32, uint64 。

int 和 uint 是根据 CPU 平台机器字大小的有符号和无符号整数。

Unicode 字符的 rune 类是和 int32 等价的类型，通常用于一个 Unicode 码点。

byte 和 uint8 是等价类型，byte 类型用于强调数值是一个原始的数据而不是一个整数。

最后，还有一种无符号的整数类型 uintptr，没有指定具体的 bit 大小但是足以容纳指针，在底层编程才需要。

float32, float64

math.MaxFloat32 表示 float32 表示的最大值，对应的 mach.MaxFloat64 表示 float64 最大值。

float32 能提供 6 个十进制数的精度，而 float64 则可以提供大约 15 个十进制的进度；通常应该优先使用 float64 类型。 float32 表达的最大值并不是很大，因为只有 23 有效 bit，其它的 bit 用户指数和符号，当整数大于 23 bit 表达的范围时，float32 的表示将出现误差。

complex64, complex128 分别对应 float32 和 float64 两种浮点数精度。

true, false

bool 不会隐式的转换为 0 或者 1 。

一个字符串是一个不可改变的字节序列。索引操作返回第 i 个 字节 的字节值，也就是说第 i 个字节并不是第 i 个字符， 因为对于非 ASCII 字符的 UTF8 编码需要两个或者多个字节。

子串操作 s[i:j] 是基于原始的字符串 [i,j) 左开右闭区间得到的一个新字符串。

字符串值是不可变的（字节序列），重新赋值操作会重新分配字符串值。也不可以修改字符串的值。

直接按照索引来遍历得到的字节，所以遍历字符串需要借助 range 关键字。

for i, r := range "Hello, 世界" {
    fmt.Printf("%d\t%q\t%d\n", i, r, r)
}

统计字符串长度，也需要这样：

n := 0
for range s {
    n++
}

固定长度的特定元素组成的序列，因为数组的长度是固定的，因此 Golang 中很少直接使用数组。

在数组初始化过程中，如果数组的长度位置出现的是 ... 省略号，则表示数组的长度是根据初始化值的个数来计算的。

q := [...]int{1, 2, 3}

数组还可以指定索引初始化，有点像 Python 的 dict，只不过 key 是数组索引，例如：

r := [...]int{99: -1}

将直接初始化 100 个元素的数组，最后一个元素是 -1 。

数组的比较是当数组中的所有元素数值都相等时，则认为数组相等。

变长的特定类型的序列，声明一般用 []T 和数组的区别仅在于没有固定长度。

与数组不同的是，slice 之间不能比较，因此不能用 == 操作符来判断两个 slice 是否全部相等元素。

判断 slice 是否为空，使用 len(s)==0 而不应该用 s==nil 来判断。除了和 nil 相等比较外，一个 nil 值的 slice 的行为 和其它任意 0 长度的 slice 一样。

slice 的底层实现类似 C++ 中的 vector 或者 string 内置了一个容量为 cap 的数组，一个标志当前长度的变量，一个头指针。 每次添加元素时，判断 cap 是否足够，不够则已当前容量二倍的长度扩展，然后将旧数据 copy 到新内存中，变更指针和容量标识等等。

append 对 slice 序列进行扩展，每次添加元素并不能知道 append 是否导致了内存的重新分配，因为也不能确定新的 slice 和 原始的 slice 是否引用的是相同的底层数组空间。因此通常是将 append 返回的结果直接赋值给输入的 slice 变量。

slice 中存放三个字段：序列指针、当前长度、总容量。除了底层元素之外，其它都是直接访问的。

哈希表，声明格式为： map[K]V ，K, V 分别对应 key 和 value 的类型。K 对应的 key 必须是支持 == 比较运算符的数据类型， 用来判断是否重复。

不建议使用 float 作为 map 的 Key 类型，因为 NaN 所表示的浮点数可能和任何浮点数都不相等。

可以像 Python 创建 dict 一样创建 Golang 中的 Map：

ages := map[string]int{
    "alice":   31,
    "charlie": 34,
}

使用内置的 delete 函数删除元素。但是和 Python 不同的是 Go 可以直接使用不存在的元素。当 key 不存在时返回一个该类型的默认值。 也正因为 key 不存在时 map 也可以正确的返回值，所以使用时一般需要对返回值进行判断:

m := map[string]int
m["cc"]  // 如果 cc 不存在将返回 0
_, ok := m["cc"] // 如果 cc 不存在，ok = false

map 的元素并不是一个变量，不能对 map 的元素进行取址操作。因为 map 可能随着元素数量的增长而分配更大的内存空间，从而使导致之前的地址无效。

遍历 map 使用 range ，将得到对应的键/值对。

for name, age := range ages {
    fmt.Printf("%s\t%d\n", name, age)
}

结构体是一种聚合的数据类型，是由零个或者多个任意类型的值聚合成的实体。每个值称为结构体的成员。结构体的成员通过点操作符来访问。

Go 中的指针也通过点操作符来访问（WTF?）…

如果结构体的成员名字是以大写字母开头的，那么该成员就是导出的；这是 Go 语言导出规则决定的。一个结构体可能同时包含导出和未导出的成员。

一个结构体类型不能包含自身，但是可以包含自身类型的指针（就像 C++ 中的类成员不能包含类自身一样，但是可以包含自身类型的指针， 很好理解，因为包含自身的情况下如何初始化？）。

结构体初始化有两种形式：一种按照变量声明的顺序初始化，另外一种像 Python 字典一样初始化。

结构体初始化时，不能在外部包初始化未导出的成员。结构体传参都是值传递，所以结构体一般都是指针传参。

将 Go 语言中结构体转换成 JSON 的过程叫做编组（marshaling）。将 JSON 数据解码为 Go 语言的数据结构称之为 unmarshaling。

类似 Python，模板化生成字符串。

func name(parameter-list) (result-list) {
    body
}

与 C++ 等语言不同的是，Go 的函数返回值可以设置名称，比如：

func sub(x, y int) (z int)   { z = x - y; return}

而且函数的标识符由“参数列表”和“返回值”列表的变量类型决定，如果两个函数的标识符相同，则认为类型相同。

Go 语言没有函数默认参数值。

实参类型通过值的方式传递，但是，如果实参包含引用类型，比如指针、slice、map、function、channel 等类型，实参可能由于函数的间接引用被修改。

Go 内置了 error 接口，用来表示函数运行中的错误， nil 表示运行成功， non-nil 表示失败。对于 non-nil 的 error 类型， 可以调用 error 的 Error 函数或者输出函数获得字符串类型的错误信息。

类似函数指针，函数可以赋值给其它变量，传递给其它函数，从函数函数中返回。

Go 使用闭包（closures）技术实现函数值。

• 如果函数中有多个 defer，执行顺序为先进后出，和栈一样；
• defer 表达式中变量的值在 defer 表达式被定义时就已经明确，所以要注意在 defer 表达式声明时变量的值；

Panic 和 Recover 是互相协作的一对机制，panic 会引发程序崩溃，而 recover 可以使程序从 panic 中恢复。

比较适合在 Web 服务器中使用，当一个请求崩溃时，不应该让整个服务器崩溃，而是收集崩溃信息并且上报。

在函数声明时，在其名字之前放上一个变量，即是一个方法。这个附加的参数会将函数附加到这种类型上，即相当于为这种类型定义了一个独占的方法。

package geometry

import "math"

type Point struct{ X, Y float64 }

// 传统函数
func Distance(p, q Point) float64 {
    return math.Hypot(q.X-p.X, q.Y-p.Y)
}

// 方法
func (p Point) Distance(q Point) float64 {
    return math.Hypot(q.X-p.X, q.Y-p.Y)
}

有点像 this 或者 self 只不过名字是任意的。

当调用函数时，需要更新一个变量或者函数的其中一个参数太大希望能够避免进行默认的拷贝，这种情况下需要使用指针。

Go 会自动判断方法的接收器是指针类型，还是非指针类型，都可以通过指针/非指针类型进行调用，编译器会自动做类型转换。

至于选择指针还是非指针类型，取决于应用场景，非指针变量会引发一次拷贝。

Go 语言只有一种控制可见性的手段：大写首字母的标识符会从定义它们的包中被导出，小写字母的则不会。

这种限制包内成员的方式同样适用于 struct 或者一个类型的方法。因而如果我们想要封装一个对象，我们必须将其定义为一个 struct。

接口类型和具体的类型不同在于接口类型只表示他能干什么，而具体的类型表示他是什么。

Go 中的接口不像 Java 中的接口需要显式实现，也不像 C++ 中的虚基类必须要一个派生类来实现，反而有点像 Python 的鸭子类型。

它仅仅是一个约定。如下：

type Writer interface {
    Write(p []byte) (n int, err error)
}

定义了接口 Writer ，它包含一个方法 Write ，凡是实现了 Write(p []byte) (n int, err error) 的方法，便认为满足了约定：

type ByteCounter int

func (c *ByteCounter) Write(p []byte) (int, error) {
    *c += ByteCounter(len(p)) // convert int to ByteCounter
    return len(p), nil
}

接口和实现并没有显式的做关联。

在 Go 语言中，每一个并发的执行单元叫作一个 goroutine。

当一个程序启动时，其主函数即在一个单独的 goroutine 中运行，我们叫他 main goroutine。新的 goroutine 用 go 语句来创建。

channels 是 goroutine 之间的通信机制：一个 goroutine 通过它给另一个 goroutine 发送值信息。每个 channel 都有一个特殊的类型。

ch := make(chan int) // ch has type 'chan int'

一个 channel 有发送和接受两个主要操作。发送和接受两个操作都是用 <- 运算符，WTF? 还不如两个方法来的实在：

ch <- x  // a send statement
x = <-ch // a receive expression in an assignment statement
<-ch     // a receive statement; result is discarded

channel 还支持 close 操作，用来关闭 channel，随后基于该 channel 的任何发送操作都将导致 panic 异常。

channel 可以带缓存。

竞争条件是指程序在多个 goroutine 交叉执行操作时，没有给出正确的结果。

数据竞争会在两个以上的 goroutine 并发访问同一个变量且至少其中一个为写操作时发生。

Go 提供了互斥量 Mutex，并且为之提供了 Lock() 和 UnLock() 用来加锁和解锁。

读写互斥锁（Mutex）在读的时候也会「加锁」，但是对于读频次远大于写频次的情况下，这样性能会比较差，因为大家都是在读， 不修改值，没有必要强制限制。所以需要共享锁。

很多情况下，我们需要「多读单写」锁，Go 提供了 sync.RWMutex ，调用 RLock 和 RUnlock 方法来获取和释放一个读取或者共享锁。

如果初始化成本比较大的话，那么将初始化延迟到需要的时候再做就是一个比较好的选择。 因为在程序启动时做初始化会增加程序启动时间并且因为执行的时候可能也不需要这些变量，所以实际上有一些浪费。

但是延迟初始化不是并发安全的。 sync 包提供了专门的方案来解决一次性初始化的问题： sync.Once

var loadIconsOnce sync.Once
var icons map[string]image.Image
// Concurrency-safe.
func Icon(name string) image.Image {
    loadIconsOnce.Do(loadIcons)
    return icons[name]
}

只要在 go build，go run 或者 go test 命令后面加上 -race 的 flag，就会使编译器创建一个你的应用的"修改"版或者一个附带了 能够记录所有运行期对共享变量访问工具的 test，并且会记录下每一个读或者写共享变量的 goroutine 的身份信息。

当导入的两个包有着相同的名字，比如 math/rand 和 crypto/rand 包，那么导入声明必须要至少为一个同包指定一个新的包名以避 免冲突，这称之为导入包的重命名：

import (
    "crypto/rand"
    mrand "math/rand" // alternative name mrand avoids conflict
)

重命名除了可以解决名字冲突之外，还可以为一个笨重的包名重命名。

如果只是导入包而不使用将会导致的一个编译错误，但是有时候我们想利用导入包而产生的副作用：它会计算包级别变量的初始化表达式 和之行导入包的 init 初始化函数。Go 提供了匿名导入方法。

import _ "image/png" // register PNG decoder

包名一般采用单数的形式。

Go 语言工具箱集合了一系列的功能命令集。可以看作是一个包管理器，用来做包的查询、计算的包依赖关系、从远程版本控制系统和下 载它们等任务。它也是一个构建系统，计算文件的依赖关系，然后调用编译器、汇编器和连接器构建程序。

Go is a tool for managing Go source code.

Usage:

    go command [arguments]

The commands are:

    build       compile packages and dependencies
    clean       remove object files
    doc         show documentation for package or symbol
    env         print Go environment information
    bug         start a bug report
    fix         run go tool fix on packages
    fmt         run gofmt on package sources
    generate    generate Go files by processing source
    get         download and install packages and dependencies
    install     compile and install packages and dependencies
    list        list packages
    run         compile and run Go program
    test        test packages
    tool        run specified go tool
    version     print Go version
    vet         run go tool vet on packages

Use "go help [command]" for more information about a command.

Additional help topics:

    c           calling between Go and C
    buildmode   description of build modes
    filetype    file types
    gopath      GOPATH environment variable
    environment environment variables
    importpath  import path syntax
    packages    description of package lists
    testflag    description of testing flags
    testfunc    description of testing functions

Use "go help [topic]" for more information about that topic.