概述

连续三节的内容如下：

• 第一节覆盖了基本语法及数据结构
• 第二节讨论了方法与接口
• 第三节则简单介绍了 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