概述
连续三节的内容如下：
- 第一节覆盖了基本语法及数据结构
- 第二节讨论了方法与接口
- 第三节则简单介绍了 Go 的并发原语。
导入包 import
大写开头，导出
如果一个名字以大写字母开头，那么它就是已导出的。例如，Pizza 就是个已导出名，Pi 也同样，它导出自 math 包。
import 分组
import "fmt"
import "math"
不过使用分组导入语句是更好的形式。
import (
"fmt"
"math"
)
函数参数缩写
func add(x int, y int) int {
return x + y
}
可缩写为
func add(x, y int) int {
return x + y
}
有意义的返回值
Go 的返回值可被命名，它们会被视作定义在函数顶部的变量。
var 语句用于声明一个变量
var c, python, java bool
短变量声明
在函数中，简洁赋值语句 := 可在类型明确的地方代替 var 声明。:= 结构不能在函数外使用。
Go 的基本类型有
bool
string
int int8 int16 int32 int64
uint uint8 uint16 uint32 uint64 uintptr
byte // uint8 的别名
rune // int32 的别名
// 表示一个 Unicode 码点
float32 float64
complex64 complex128
类型转换
表达式 T(v) 将值 v 转换为类型 T。
i := 42
f := float64(i)
u := uint(f)
var i int = 42
var f float64 = float64(i)
类型推导
在声明一个变量而不指定其类型时（即使用不带类型的 := 语法或 var = 表达式语法），变量的类型由右值推导得出。
常量
常量的声明与变量类似，只不过是使用 const 关键字。
for 是 Go 中的 “while”
func main() {
sum := 1
for sum < 1000 {
sum += sum
}
fmt.Println(sum)
}
defer
defer 语句会将函数推迟到外层函数返回之后执行。
推迟调用的函数其参数会立即求值，但直到外层函数返回前该函数都不会被调用。
推迟的函数调用会被压入一个栈中。当外层函数返回时，被推迟的函数会按照后进先出的顺序调用。
Go 拥有指针。指针保存了值的内存地址。
类型 *T 是指向 T 类型值的指针。其零值为 nil。
var p *int
& 操作符会生成一个指向其操作数的指针。
i := 42
p = &i
结构体
一个结构体（struct）就是一组字段（field）
数组
数组的长度是其类型的一部分，因此数组不能改变大小
var a [10]int
切片
类型 []T 表示一个元素类型为 T 的切片。
切片通过两个下标来界定，即一个上界和一个下界，二者以冒号分隔：
a[low : high]
a[1:4] 它包含 a 中下标从 1 到 3 的元素：
切片就像数组的引用
切片并不存储任何数据，它只是描述了底层数组中的一段。
更改切片的元素会修改其底层数组中对应的元素。
切片文法类似于没有长度的数组文法。
这是一个数组文法：
[3]bool{true, true, false}
切片下界的默认值为 0，上界则是该切片的长度。
以下切片是等价的：
a[0:10]
a[:10]
a[0:]
a[:]
切片的长度与容量
切片拥有 长度 和 容量。
切片的长度就是它所包含的元素个数。
切片的容量是从它的第一个元素开始数，到其底层数组元素末尾的个数。
切片 s 的长度和容量可通过表达式 len(s) 和 cap(s) 来获取。
nil 切片的零值是 nil
用 make 创建切片,创建动态数组的方式。
make 函数会分配一个元素为零值的数组并返回一个引用了它的切片：
a := make([]int, 5) // len(a)=5
切片的切片,即是二维数组
board := [][]string{
[]string{"_", "_", "_"},
[]string{"_", "_", "_"},
[]string{"_", "_", "_"},
}
Range
for 循环的 range 形式可遍历切片或映射。
当使用 for 循环遍历切片时，每次迭代都会返回两个值。第一个值为当前元素的下标，第二个值为该下标所对应元素的一份副本。
for i, v := range pow {
fmt.Printf("2**%d = %d\n", i, v)
}
可以将下标或值赋予 _ 来忽略它。
for i, _ := range pow
for _, value := range pow
若你只需要索引，忽略第二个变量即可。
for i := range pow
映射 ( map )
其实就是 map 键值对的数据结构实现
映射将键映射到值。
映射的零值为 nil 。nil 映射既没有键，也不能添加键。
make 函数会返回给定类型的映射，并将其初始化备用
var m map[string]Vertex
m = make(map[string]Vertex)
m["Bell Labs"] = xxxxxxx
映射的文法
映射的文法与结构体相似，不过必须有键名。
var m = map[string]Vertex{
"Bell Labs": Vertex{
40.68433, -74.39967,
},
"Google": Vertex{
37.42202, -122.08408,
},
}
若顶级类型只是一个类型名，你可以在文法的元素中省略它。
var m = map[string]Vertex{
"Bell Labs": {40.68433, -74.39967},
"Google": {37.42202, -122.08408},
}
修改映射
在映射 m 中插入或修改元素：
m[key] = elem
获取元素：
elem = m[key]
删除元素：
delete(m, key)
通过双赋值检测某个键是否存在：
elem, ok = m[key]
若 key 在 m 中，ok 为 true ；否则，ok 为 false。
若 key 不在映射中，那么 elem 是该映射元素类型的零值。
函数值
函数也是值。它们可以像其它值一样传递。
函数值可以用作函数的参数或返回值。
PS: 其实就是函数可以当参数传递
函数的闭包
Go 函数可以是一个闭包。闭包是一个函数值，它引用了其函数体之外的变量。该函数可以访问并赋予其引用的变量的值，换句话说，该函数被这些变量“绑定”在一起。
func adder() func(int) int {
sum := 0
return func(x int) int {
sum += x
return sum
}
}
函数的命名返回值
命名返回参数
可以像python那样返回多个结果，只是非tuple
对于不想要的返回值，可以扔垃圾桶_
如果用命名返回参数，return语句可以为空。return 不为空，返回值顺序是return的顺序而非在函数头声明的顺序
package main
func change(a, b int) (x, y int) {
x = a + 100
y = b + 100
return //101, 102
//return x, y //同上
//return y, x //102, 101
}
# 更多学习资料
[http://docscn.studygolang.com/doc/](http://docscn.studygolang.com/doc/)
https://go-zh.org/#
https://tour.go-zh.org/list
END