编译

1	go build xxx.go

清理

1	go clean xxx.go

检测代码的常见错误

Printf类函数调用时，类型匹配错误的参数
定义常用的方法时，方法签名的错误
错误的结构标签
没有指定字段名的结构字面量

go vet

Go代码格式化

go fmt

Go语言的文档

go doc 包名

包

每个Go程序都是由包构成的。

程序是从main包开始运行，下面这个程序通过导入路径’’fmt’’和’’math/rand’’来使用这两个包。

package main
//此处用圆括号组合了导入，可以编写多个导入语句
import (
	"fmt"
	"math/rand"
)

func main() {
	fmt.Println("My favorite number is", rand.Intn(10))
}

导出名

在Go中，如果以一个名字是以大写字母开头，那么他就是已导出的。

函数

函数可以没有参数或接受多个参数

package main

import "fmt"

func add(x int, y int) int {
	return x + y
}

func main() {
	fmt.Println(add(42, 13))
}

当连续两个或多个函数的已命名形参类型相同时，除最后一个类型以外，其他都可以省略

1 2	x int, y int => x, y int

函数返回值

函数可以返回任意数量的返回值

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的返回值可被命名，他们会被视作定义在函数顶部的变量。

package main

import "fmt"

func split(sun int) (x, y int) {
  x = sun * 4 / 9
  y = sum - x
  return 
}

func main() {
  fmt.Println(split(17))
}

变量

var语句用于声明一个变量列表，跟函数的参数列表一样，类型在最后。

1 2	var c, python, java bool var i int

变量的初始化

变量声明可以包含初始值，每个变量对应一个。

如果初始化值已存在，则可以省略类型；变量会从初始值中获取类型。

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)
}

短变量声明

在函数中，简洁赋值语句:=可在类型明确的地方代替var声明。

函数外的每个语句都必须以关键字开始（var ,func等等），因此:=不能在函数外使用。

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)
}

基本类型

bool
string
int int8 int16 int32 int64
uint uint8 uint16 uint32 uint64 uintptr
byte //uint8的别名
rune //int32的别名。 表示一个unicode码点
float32 float64
complex64 complex128

package main

import (
	"fmt"
  "math/cmplx"
)

var (
	ToBe bool = false
  MaxInt uint64 = 1<<64 - 1
  z complex128 = cmplx.Sqrt(-5 + 12i)
  a = 1.00
)

func main() {
  fmt.Printf("Type: Value: %v\n", a)
  fmt.Printf("Type: %T Value: %v\n", ToBe, ToBe)
  fmt.Printf("Type: %T Value: %v\n", MaxInt, MaxInt)
  fmt.Printf("Type: %T Value: %v\n", z, z)
}

零值

没有明确初始值的变量声明会被赋予零值。

数值类型为0；

布尔类型为false；

字符串为""（空字符串）。

package main

import "fmt"

func main() {
  var i int
  var f float64
  var b bool
  var s string
  fmt.Printf("%v %v %v %q\n", i, f, b, s)
}

类型转换

表达式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在不同类型的项之间赋值时需要显示转换。

类型推导

在声明一个变量而不指定其类型时（即使用不带类型的:=语法或var=表达式语法），变量的类型由右值推导得出。

当右值声明了类型时，新变量的类型与其相同：

1 2	var i int j := i //j也是个int

不过当右边包含未指明类型的数值常量时，新变量的类型就可能是 int,float64或complex128了，这取决于常量的精度：

1
2
3

i := 42		//int
f := 3.142	//float64
g := 0.867 + 0.5i	//complex128

常量

常量的声明与变量类似，只不过使用const关键字。

常量可以是字符、字符串、布尔值或数值。

常量不能用:=语法声明。

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

Go 只有一种循环结构：for循环

基本的for循环由三部分组成，他们用分号隔开：

初始化语句：在第一次迭代前执行
条件表达式：在每次迭代前求值
后置语句：在每次迭代的结尾执行

初始化语句和后置语句是可以忽略的。

初始化语句通常为依据短变量声明，该变量声明仅在for语句的作用域中可见。

一旦条件表达式的布尔值为false，循环迭代就会终止。

注意：和C、java、JavaScript之类的语言不同，Go的for语句后面的三个构成部分外没有小括号，大括号{ }则是必须的。

package main

import "fmt"

func main() {
  i := 0
  sum := 0
  for i = 0; i < 10; i++ {
    sum += i
  }
  fmt.Println(sum)
}

for 是Go中的”while”

package main

import "fmt"

func main() {
  sum := 1
  for sum < 1000 {
    sum += sum
  }
  fmt.Println(sum)
}

无限循环

如果省略循环条件，该循环就不会结束，因此无限循环可以写的很紧凑。

package main

func main() {
  for {
  }
}

if

Go的if语句与for循环类似，表达式外无需小括号(),而大括号{}则是必须的。

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))
}

if的简单语句

和for一样，if语句可以在条件表达式前执行一个简单的语句。

该语句声明的变量作用域仅在if之内。

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)
  )
}

if 和 else

在if的简短语句中声明的变量同样可以在任何对应的else块中使用。

package main

import (
	"fmt"
  "math"
)

func pow(x, n, lim float64) float64 {
  v := math.Pow(x, n)
  if v < lim {
    return v
  } else {
    fmt.Printf("%g >= %g\n", v, lim)
  }
  //从这里开始就不能使用v了
  return lim
}

func main() {
  //在main的fmt.println调用开始前，两次对pow的调用均已执行并返回各自的结果
  fmt.Println(
    pow(3, 2, 10)
    pow(3, 3, 20)
  )
}

循环与函数

用牛顿法实现平方根函数。

package main

import (
	"fmt"
  "math"
)

const cp = 1e-6

func Sqrt(x float64) float64 {
  z := 1.0
  last := 0.0
  for ; math.Abs(last - z) > cp; {
    last = z
    z -= (z*z - x) / (2 * z)
  }
  return z
}

func main() {
  fmt.Println(Sqrt(2))
}

switch

Switch是编写一连串if-else语句的简便方法。它运行第一个值等于条件表达式的case语句。

Go的switch语句类似于C、C++、Java、JavaScript和PHP中的，不过Go只运行选定的case，而非之后所有的case。实际上，Go自动提供了在这些语言中每个case后面所需的break语句。除非以 fallthrough 语句结束，否则分支会自动终止。Go 的另一点重要的不同在于 switch 的 case 无需为常量，且取值不必为整数。

package main

import (
	"fmt"
  "runtime"
)

func main() {
  fmt.Print("Go runs on ")
  switch os := runtime.GOOS; os {
  case "darwin":
    fmt.Println("OS x.")
  case "linux":
    fmt.Println("Linux.")
  default:
    fmt.Printf("%s.\n",os)  
  }
}

switch的求值顺序

switch的case语句从上到下顺序执行，直到匹配成功时停止。

package main

import (
	"fmt"
  "time"
)

func main() {
  fmt.Println("When's Saturday?")
  today := time.Now().Weekday()
  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.")
  }
}

没有条件的switch

没有条件的switch同switch true一样。这种形式能将一长串if-then-else写的更加清晰。

package main

import (
	"fmt"
  "time"
)

func main() {
  t := time.Now()
  switch {
    case t.Hour() < 12:
    	fmt.Println("Good morning!")
    case t.Hour() < 17:
    	fmt.Println("Good afternoon.")
    default:
    	fmt.Println("Good evening.")
  }
}

defer

defer语句会将函数推迟到外层函数返回之后执行。

推迟调用的函数其参数会立即求值，但直到外层函数返回前该函数都不会被调用。

package main

import "fmt"

func main() {
  defer fmt.Println("world")
  dmt.Println("hello")
}

defer 栈

推迟的函数调用会被压入一个栈中，当外层函数返回时，被推迟的函数会按照后进先出的顺序调用。

package main

import "fmt"

func main() {
  fmt.Println("counting")
  
  for i := 0; i < 10; i++ {
    defer fmt.Println(i)
  }
  
  fmt.Println("done")
}

指针

Go拥有指针。指针保存了值的内存地址。

与C不同，Go没有指针运算。

//类型*T是指向T类型值的指针。其零值为nil
var p *int
//&操作符会生成一个指向其操作数的指针
i := 42
p = &i
//*操作符表示指针指向的底层值
fmt.Println(*p) //通过指针p读取i
*p = 21					//通过指针p设置i
//这也就是通常所说的“间接引用”或“重定向”。

结构体

一个结构体就是一组字段。

结构体字段使用点号来访问。

package main

import "fmt"

type Vertex struct {
  x int
  y int
}

func main() {
  v := Vertex{1, 2}
  v.x = 4
  fmt.Println(v.x)
}

结构体指针

结构体字段可以通过结构体指针来访问。

如果有一个指向结构体的指针p，可以通过(*p).x来访问字段x。不过有点麻烦，Go语言支持使用隐式间接引用，直接写p.x就可以。

package main

import "fmt"

type Vertex struct {
  x int
  y int
}

func main() {
  v := Vertex{1, 2}
  p := &v
  p.x = 1e9
  fmt.Println(v)
}

结构体文法

package main

import "fmt"

type Vertex struct {
  x, y int
}

var (
  v1 = Vertex{1, 2} 	//创建一个Vertex类型的结构体
  v2 = Vertex{x: 1}		//y:0被隐式的赋予
  v3 = Vertex{}				//x:0  y:0
  p = &Vertex{1, 2}		//创建一个*Vertex类型的结构体
)

func main() {
  fmt.Println(v1, v2, v3, p)
}

数组

类型[n]T便是拥有n个T类型的值的数组。

表达式，将变量a声明为拥有10个整数的数组。

var a [10]int
//声明一个包含5个元素的整形数组
//用具体值初始化每个元素
a := [5]{1, 2, 3, 4, 5}
//声明一个整形数组
//用具体值初始化每个元素
//容量由初始化值得数量决定
a := [...]int{1, 2, 3, 4, 5}
//声明一个整形数组
//用具体值初始化索引为1和2的元素
//其余元素保持零值
a := [5]int{1: 10, 2: 20}
//声明包含5个元素的指向整数的数组
//用整形指针初始化索引为0和1的数组元素
a := [5]*int{0: new(int), 1: new(int)}
*a[0] = 10
*a[1] = 20


//声明一个包含5个元素的字符串数组
var a1 [5]string
//声明第二个包含5个元素的字符串
//初始化数组
a2 := [5]string{"aaa", "bbb", "ccc", "ddd", "eee"}
//把a2的值赋给a1
a1 = a2 //只有数组长度和元素类型相同的数组才可以相互赋值

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)
}

切片

每个数组的大小都是固定的。而切片则为数组元素提供动态大小的、灵活的视角。

切片通过两个下标来界定，一个上界和一个下界，二者以冒号分隔：

1	a[low : high]

他会选择一个半开区间，包括第一个元素，但排除最后一个元素。

切片并不存储任何数据，他只是描述了底层数组中的一段。

更改切片的元素会修改其底层数组中对应的元素。与他共享底层数组的切片都会观测到这些修改。

package main

import "fmt"

func main() {
  names := [4]string{
    "aa",
    "bb",
    "cc",
    "dd"
  }
  fmt.Println(names)
  
  a := names[0 : 2]
  b := names[1 : 3]
  fmt.Println(a, b)
  
  b[0] = "xx"
  fmt.Println(a, b)
  fmt.Println(names)
}

切片文法

切片文法类似于没有长度的数组文法。

1
2
3

[]bool{true, true, false}
[3]bool{true, true, false}
//上下会创建两个相同的数组，然后构建一个引用了他的切片

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)
}

切片的默认行为

切片下届的默认值为0，上界则是该切片的长度。

对于数组

1	var a [10]int

来说，以下切片是等价的：

a[0 : 10]
a[ : 10]
a[0 : ]
a[ : ]

切片的长度和容量

切片拥有长度和容量。

切片的长度就是它所包含的元素个数。可通过len(s)获取。

切片的容量是从他的第一个元素开始数，到其底层数组元素末尾的个数。可通过cap(s)来获取。

package main

import "fmt"

func main() {
	s := []int{2, 3, 5, 7, 11, 13}
	printSlice(s)

	// 截取切片使其长度为 0
	s = s[:0]
	printSlice(s)

	// 拓展其长度
	s = s[:4]
	printSlice(s)

	// 舍弃前两个值
	s = s[2:]
	printSlice(s)
}

func printSlice(s []int) {
	fmt.Printf("len=%d cap=%d %v\n", len(s), cap(s), s)
}

nil切片

切片的零值是nil。

nil切片的长度和容量为0且没有底层数组。

package main

import "fmt"

func main() {
	s := []int{1}
	fmt.Println(s, len(s), cap(s))
	if s == nil {
		fmt.Println("nil!")
	}
}

用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

package main

import "fmt"

func main() {
  a := make([]int, 5)
  printSlice("a", a)
  
  b := make([]int, 0, 5)
  printSlice("b", b)
  
  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)
}

切片的切片

切片可包含任何类型，甚至包括他的切片。

package main

import (
	"fmt"
  "strings"
)

func main() {
  board := [][]string{
    []string{"_", "_", "_"},
    []string{"_", "_", "_"},
    []string{"_", "_", "_"},
  }
  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.Println("%s\n", strings.Join(board[i], " "))
  }
}

向切片追加元素

为切片追加新的元素是种常用的操作，为此 Go 提供了内建的 append 函数。

1	func append(s []T, vs ...T) []T

append 的第一个参数 s 是一个元素类型为 T 的切片，其余类型为 T 的值将会追加到该切片的末尾。

append 的结果是一个包含原切片所有元素加上新添加元素的切片。

当 s 的底层数组太小，不足以容纳所有给定的值时，它就会分配一个更大的数组。返回的切片会指向这个新分配的数组。

package main

import "fmt"

func main() {
	var s []int
	printSlice(s)

	// 添加一个空切片
	s = append(s, 0)
	printSlice(s)

	// 这个切片会按需增长
	s = append(s, 1)
	printSlice(s)

	// 可以一次性添加多个元素
	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)
}

Range

for 循环的 range 形式可遍历切片或映射。

当使用 for 循环遍历切片时，每次迭代都会返回两个值。第一个值为当前元素的下标，第二个值为该下标所对应元素的一份副本。

package main

import "fmt"

var poe = []int{1, 2, 4, 8, 16, 32, 64, 128}

func main() {
  for i, v := range pow {
    fmt.Printf("%d = %d\n", i, v)
  }
  for i, it := range pow {
    fmt.Printf("%d = %d\n", i, it)
  }
}

可以将下标或值赋予 _ 来忽略它。

1 2	for i, _ := range pow for _, value := range pow

若你只需要索引，忽略第二个变量即可。

1	for i := range pow

实现pic

实现 Pic。它应当返回一个长度为 dy 的切片，其中每个元素是一个长度为 dx，元素类型为 uint8 的切片。当你运行此程序时，它会将每个整数解释为灰度值（好吧，其实是蓝度值）并显示它所对应的图像。

package main

import "golang.org/x/tour/pic"

func Pic(dx, dy int) [][]uint8 {
  a := make([][]uint, dy)
  for x := range a {
    b := make([]uint8, dx)
    for y := range b {
      b[y] = uint8(x * y - 1)
    }
    a[x] = b
  }
  return a
}

func main() {
  pic.Show(Pic)
}

映射

映射将键映射到值。

映射的零值为 nil 。nil 映射既没有键，也不能添加键。

make 函数会返回给定类型的映射，并将其初始化备用。

package main

import "fmt"

type Vertex struct {
  lat, long float64
}

var m map[string]Vertex

func main() {
  m = make(map[string]Vertex)
  m["hello world"] = Vertex{
    1.020, -324.4,
  }
  fmt.Println(m["hello world"])
}

映射的文法

映射的文法与结构体相似，不过必须有键名。

package main

import "fmt"

type Vertex struct {
	Lat, Long float64
}

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},
}
*/
func main() {
	fmt.Println(m)
}

修改映射

在映射 m 中插入或修改元素：

1	m[key] = elem

获取元素：

1	elem = m[key]

删除元素：

1	delete(m, key)

通过双赋值检测某个键是否存在：

1	elem, ok = m[key]

若 key 在 m 中，ok 为 true ；否则，ok 为 false。

若 key 不在映射中，那么 elem 是该映射元素类型的零值。

同样的，当从映射中读取某个不存在的键时，结果是映射的元素类型的零值。

注：若 elem 或 ok 还未声明，你可以使用短变量声明：

实现WordCount

实现 WordCount。它应当返回一个映射，其中包含字符串 s 中每个“单词”的个数。函数 wc.Test 会对此函数执行一系列测试用例，并输出成功还是失败。

package main

import (
	"golang.org/x/tour/wc"
	"strings"
)

func WordCount(s string) map[string]int {
	vis := make(map[string]int)
	c := strings.Fields(s)
	for _, i := range c {
		vis[i] ++
	}
	return vis
}

func main() {
	wc.Test(WordCount)
}

函数值

函数也是值。他们可以像其他值一样传递。

函数值可以用作函数的参数或返回值。

package main

import (
	"fmt"
  "math"
)

func compute(fn func(float64, float64) float64) float64 {
  return fn(3, 4)
}

func main() {
  hypot := func(x, y float64) float64 {
    return math.Sqrt(x * x + y * y)
  }
  fmt.Println(hypot(5, 12))
  
  fmt.Println(compute(hypot))
  fmt.Println(compute(math.Pow))
}

函数的闭包

Go函数可以是一个闭包。闭包是一个函数值，他引用了其函数体之外的变量。该函数可以访问并赋予其引用的变量的值，换句话说，该函数被这些变量绑定在一起。

package main

import "fmt"

func adder() func(int) int {
  sum := 0
  return func(x int) int {
    sun += x
    return sum
  }
}

func main() {
  pos, neg := adder(), adder()
  for i := 0; i < 10; i++ {
    fmt.Println(
      pos(i),
      neg(-2 * i),
    )
  }
}

斐波那契闭包

实现一个 fibonacci 函数，它返回一个函数（闭包），该闭包返回一个斐波纳契数列 (0, 1, 1, 2, 3, 5, ...)。

package main

import "fmt"

func fibonacci() func() int {
  x, y := 0, 1
  return func() int {
    ans := x
    x, y = y, x + y
    return ans
  }
}

func main() {
  f := fibonacci()
  for i := 0; i < 10; i++ {
    fmt.Println(f())
  }
}

方法

Go没有类。不过可以为结构体类型定义方法。

方法就是一类带特殊的 接收者 参数的函数。

方法接收者在它自己的参数列表内，位于 func 关键字和方法名之间。

在此例中，Abs 方法拥有一个名为 v，类型为 Vertex 的接收者。

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 main() {
  v := Vertex{3, 4}
  fmt.Println(v.Abs())
}

方法即函数

方法只是个带接收者参数的函数。

现在这个 Abs 的写法就是个正常的函数，功能并没有什么变化。

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 之类的内建类型）的接收者声明方法。

package main

import (
	"fmt"
	"math"
)

type MyFloat float64

func (f MyFloat) Abs() float64 {
	if f < 0 {
		return float64(-f)
	}
	return float64(f)
}

func main() {
	f := MyFloat(-math.Sqrt2)
	fmt.Println(f.Abs())
}

指针接收者

你可以为指针接收者声明方法。

这意味着对于某类型 T，接收者的类型可以用 *T 的文法。（此外，T 不能是像 *int 这样的指针。）

例如，这里为 *Vertex 定义了 Scale 方法。

指针接收者的方法可以修改接收者指向的值（就像 Scale 在这做的）。由于方法经常需要修改它的接收者，指针接收者比值接收者更常用。

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.x = v.x * f
  v.y = v.y * f
}

func main() {
  v := Vertex{3, 4}
  v.Scale(10)
  fmt.Println(v.Abs())
}

指针和函数

把 Abs 和 Scale 方法重写为函数

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) {
	v.X = v.X * f
	v.Y = v.Y * f
}

func main() {
	v := Vertex{3, 4}
	Scale(&v, 10)
	fmt.Println(Abs(v))
}

方法与指针重定向

比较前两个程序，带指针参数的函数必须接受一个指针：

1
2
3

var v Vertex
ScaleFunc(v, 5)  // 编译错误！
ScaleFunc(&v, 5) // OK

而以指针为接收者的方法被调用时，接收者既能为值又能为指针：

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)。

同样的事情也发生在相反的方向。

接受一个值作为参数的函数必须接受一个指定类型的值：

1
2
3

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()。

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))
}

选择值或指针作为接受者

使用指针接收者的原因有二：

首先，方法能够修改其接收者指向的值。

其次，这样可以避免在每次调用方法时复制该值。若值的类型为大型结构体时，这样做会更加高效。

在本例中，Scale 和 Abs 接收者的类型为 *Vertex，即便 Abs 并不需要修改其接收者。

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())
}

接口

接口类型 是由一组方法签名定义的集合。

接口类型的变量可以保存任何实现了这些方法的值。

package main

import (
	"fmt"
  "math"
)

type Abser interface {
  Abs() float64
}

func main() {
  var a Abser
  f := MyFloat(-math.Sqrt2)
  v := Vertex{3,4}
  
  a = f //a MyFloat 实现了 Abser
  a = &v //a *Vertex 实现了 Abser
  
  //下面一行，v 是一个Vertex（而不是*Vertex）
  //所以没有实现Abser。
  //a = v
  
  fmt.Println(a.Abs())
}

type MyFloat float64

func (f MyFloat) Abs() float64 {
  if f < 0 {
    return float64(-f)
  }
  return float64(f)
}

type Vertex struct {
  x, y float64
}

func (v *Vertex) Abs() float64 {
  return math.Sqrt(v.x*v.x + v.y*v.y)
}

接口与隐式实现

类型通过实现一个借口的所有方法累实现该接口。既然无需专门显示声明，也就没有“implements”关键字。

隐式接口从接口的实现中解耦了定义，这样接口的实现可以出现在任何包中，无需提前准备。

因此，也就无需在每一个实现上增加新的借口名称，这样同时也鼓励了明确的借口定义。

package main

import "fmt"

type I interface {
  M()
}

type T struct {
  S string
}

//此方法表示类型T实现了借口I，但我们无需显式声明此事。
func (t T) M() {
  fmt.Println(t.S)
}

func main() {
  var i I = T{"hello"}
  i.M()
}

接口值

接口也是值。他们可以像其他值一样传递。

接口值可以用作函数的参数或返回值。

在内部，接口值可以看做包含值和具体类型的元组：

1	(value, type)

接口值保存了一个具体底层类型的具体值。

接口值调用方法时会执行其底层类型的同名方法。

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()
}

func describe(i I) {
  fmt.Println("(%v, %T)\n", i, i)
}

底层值为 nil 的接口值

即便接口内的具体值为 nil，方法仍然会被 nil 接收者调用。

在一些语言中，这会触发一个空指针异常，但在 Go 中通常会写一些方法来优雅地处理它（如本例中的 M 方法）。

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 接口值

nil 接口值既不保存值也不保存具体类型。

为 nil 接口调用方法会产生运行时错误，因为接口的元组内并未包含能够指明该调用哪个具体方法的类型。

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)
}

空接口

指定了零个方法的接口值被称为空接口：

1	interface{}

空接口可保存任何类型的值。（因为每个类型都至少实现了零个方法。）

空接口被用来处理未知类型的值。例如，fmt.Print 可接受类型为 interface{} 的任意数量的参数。

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)
}

类型断言

类型断言 提供了访问接口值底层具体值的方式。

1	t := i.(T)

该语句断言接口值 i 保存了具体类型 T，并将其底层类型为 T 的值赋予变量 t。

若 i 并未保存 T 类型的值，该语句就会触发一个恐慌。

为了判断一个接口值是否保存了一个特定的类型，类型断言可返回两个值：其底层值以及一个报告断言是否成功的布尔值。

1	t, ok := i.(T)

若 i 保存了一个 T，那么 t 将会是其底层值，而 ok 为 true。

否则，ok 将为 false 而 t 将为 T 类型的零值，程序并不会产生恐慌。

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)
}

类型选择

类型选择 是一种按顺序从几个类型断言中选择分支的结构。

类型选择与一般的 switch 语句相似，不过类型选择中的 case 为类型（而非值），它们针对给定接口值所存储的值的类型进行比较。

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 的接口类型和值相同。

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)
}

Stringer

fmt 包中定义的 Stringer 是最普遍的接口之一。

1
2
3

type Stringer interface {
    String() string
}

Stringer 是一个可以用字符串描述自己的类型。fmt 包（还有很多包）都通过此接口来打印值。

package main

import "fmt"

type Person struct {
	Name string
	Age  int
}

func (p Person) String() string {
	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)
}

练习：Stringer

通过让 IPAddr 类型实现 fmt.Stringer 来打印点号分隔的地址。

例如，IPAddr{1, 2, 3, 4} 应当打印为 "1.2.3.4"。

package main

import "fmt"
import "strconv"

type IPAddr [4]byte

// TODO: 给 IPAddr 添加一个 "String() string" 方法
func (x IPAddr) String() string {
	last := len(x) - 1
	var s string
	for k, v := range x {
		s += strconv.Itoa(int(v))
		if k != last {
			s += "."
		}
	}
	return s
}
func main() {
	hosts := map[string]IPAddr{
		"loopback":  {127, 0, 0, 1},
		"googleDNS": {8, 8, 8, 8},
	}
	for name, ip := range hosts {
		fmt.Printf("%v: %v\n", name, ip)
	}
}

错误

Go 程序使用 error 值来表示错误状态。

与 fmt.Stringer 类似，error 类型是一个内建接口：

1
2
3

type error interface {
    Error() string
}

（与 fmt.Stringer 类似，fmt 包在打印值时也会满足 error。）

通常函数会返回一个 error 值，调用的它的代码应当判断这个错误是否等于 nil 来进行错误处理。

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 表示失败。

package main

import (
	"fmt"
  "time"
)

type MyError struct {
  When time.Time
  What string
}

func (e *MyError) Error() string {
  return fmt.Sprintf("at %v, %s", e.When, e.What)
}

func run() error {
  return &MyError {
    time.Now(), "it didn't work",
  }
}

func main() {
  if err := run(); err != nil {
    fmt.Println(err)
  }
}

练习：错误

从之前的练习中复制 Sqrt 函数，修改它使其返回 error 值。

Sqrt 接受到一个负数时，应当返回一个非 nil 的错误值。复数同样也不被支持。

创建一个新的类型

1	type ErrNegativeSqrt float64

并为其实现

1	func (e ErrNegativeSqrt) Error() string

方法使其拥有 error 值，通过 ErrNegativeSqrt(-2).Error() 调用该方法应返回 "cannot Sqrt negative number: -2"。

package main

import (
	"fmt"
	"math"
)
type ErrNegationSqrt float64

func (e ErrNegationSqrt) Error() string {
	return fmt.Sprintf("Cannot Sqrt negation number: %v",float64(e))
}

func Sqrt(x float64) (float64, error) {
	if x < 0 {
		return 0, ErrNegationSqrt(x)
	}
	return math.Sqrt(x), nil
}

func main() {
	fmt.Println(Sqrt(2))
	fmt.Println(Sqrt(-2))
}

Reader

io 包指定了 io.Reader 接口，它表示从数据流的末尾进行读取。

Go 标准库包含了该接口的许多实现，包括文件、网络连接、压缩和加密等等。

io.Reader 接口有一个 Read 方法：

1	func (T) Read(b []byte) (n int, err error)

Read 用数据填充给定的字节切片并返回填充的字节数和错误值。在遇到数据流的结尾时，它会返回一个 io.EOF 错误。

package main

import (
	"fmt"
	"io"
	"strings"
)

func main() {
	r := strings.NewReader("Hello, Reader!")

	b := make([]byte, 8)
	for {
		n, err := r.Read(b)
		fmt.Printf("n = %v err = %v b = %v\n", n, err, b)
		fmt.Printf("b[:n] = %q\n", b[:n])
		if err == io.EOF {
			break
		}
	}
}

练习：Reader

实现一个 Reader 类型，它产生一个 ASCII 字符 'A' 的无限流。

package main

import "golang.org/x/tour/reader"

type MyReader struct{}

// TODO: 给 MyReader 添加一个 Read([]byte) (int, error) 方法
func (r MyReader) Read(b []byte) (int, error){
	b[0] = 'A'
	return 1, nil
}

func main() {
	reader.Validate(MyReader{})
}

练习：rot13Reader

有种常见的模式是一个 io.Reader 包装另一个 io.Reader，然后通过某种方式修改其数据流。

例如，gzip.NewReader 函数接受一个 io.Reader（已压缩的数据流）并返回一个同样实现了 io.Reader 的 *gzip.Reader（解压后的数据流）。

编写一个实现了 io.Reader 并从另一个 io.Reader 中读取数据的 rot13Reader，通过应用 rot13 代换密码对数据流进行修改。

package main

import (
	"io"
	"os"
	"strings"
)

type rot13Reader struct {
	r io.Reader
}

func rot13(b byte) byte {
	switch {
	case 'A' <= b && b <= 'M':
		b += 13
	case 'M' < b && b <= 'Z':
		b -= 13
	case 'a' <= b && b <= 'm':
		b += 13
	case 'm' < b && b <= 'z':
		b -= 13
	}
	return b
}

func (mr rot13Reader) Read(b []byte) (int, error) {
	n, e := mr.r.Read(b)
	for i := 0; i < n; i++ {
		b[i] = rot13(b[i])
	}
	return n, e
}

func main() {
	s := strings.NewReader("Lbh penpxrq gur pbqr!")
	r := rot13Reader{s}
	io.Copy(os.Stdout, &r)
}

图像

image 包定义了 Image 接口：

package image

type Image interface {
    ColorModel() color.Model
    Bounds() Rectangle
    At(x, y int) color.Color
}

注意: Bounds 方法的返回值 Rectangle 实际上是一个 image.Rectangle，它在 image 包中声明。

color.Color 和 color.Model 类型也是接口，但是通常因为直接使用预定义的实现 image.RGBA 和 image.RGBAModel 而被忽视了。这些接口和类型由 image/color 包定义。

package main

import (
	"fmt"
	"image"
)

func main() {
	m := image.NewRGBA(image.Rect(0, 0, 100, 100))
	fmt.Println(m.Bounds())
	fmt.Println(m.At(0, 0).RGBA())
}

练习：图像

还记得之前编写的图片生成器吗？我们再来编写另外一个，不过这次它将会返回一个 image.Image 的实现而非一个数据切片。

定义你自己的 Image 类型，实现必要的方法并调用 pic.ShowImage。

Bounds 应当返回一个 image.Rectangle ，例如 image.Rect(0, 0, w, h)。

ColorModel 应当返回 color.RGBAModel。

At 应当返回一个颜色。上一个图片生成器的值 v 对应于此次的 color.RGBA{v, v, 255, 255}。

package main

import (
	"golang.org/x/tour/pic"
	"image"
	"image/color"
)
// 1  新建构造体

type Image struct{}

// 2 实现官方image的三个方法

func (i Image) ColorModel() color.Model {
	return color.RGBAModel
}

func (i Image) Bounds() image.Rectangle {
	// 这里的200（宽 高）我写死了 仅仅是展示作用  正确做法是从 i 中获取  
	return image.Rect(0, 0, 200, 200)
}

func (i Image) At(x, y int) color.Color {

	return color.RGBA{uint8(x), uint8(y), uint8(255), uint8(255)}
}

func main() {
// 可以自己设置宽高,传递进去
	m := Image{}
	// 3 调用
	pic.ShowImage(m)
}

Go程

Go程（goroutine）是由Go运行时管理的轻量级线程。

1	go f(x, y, z)

会启动一个新的 Go 程并执行

1	f(x, y, z)

f, x, y 和 z 的求值发生在当前的 Go 程中，而 f 的执行发生在新的 Go 程中。

Go 程在相同的地址空间中运行，因此在访问共享的内存时必须进行同步。

package main

import (
	"fmt"
	"time"
)

func say(s string) {
	for i := 0; i < 5; i++ {
		time.Sleep(100 * time.Millisecond)
		fmt.Println(s)
	}
}

func main() {
	go say("world")
	say("hello")
}

信道

信道是带有类型的管道，你可以通过它用信道操作符 <- 来发送或者接收值。

1 2	ch <- v // 将 v 发送至信道 ch。 v := <-ch // 从 ch 接收值并赋予 v。

（“箭头”就是数据流的方向。）

和映射与切片一样，信道在使用前必须创建：

1	ch := make(chan int)

默认情况下，发送和接收操作在另一端准备好之前都会阻塞。这使得 Go 程可以在没有显式的锁或竞态变量的情况下进行同步。

package main

import "fmt"

func sun(s []int, c chan int) {
  sum := 0
  for _, v :range s {
    sum += v
  }
  c <- sum //将和送入c
}

func main() {
  s := []int{1, 2, 3, 4, 5, 6}
  
  c := make(chan int)
  go sum(s[:len(s)/2], c)
  
  go sum(s[len(s)/2:], c)
  
  x := <-c
  y := <-c
  ////x, y := <-c, <-c // 从 c 中接收
  fmt.Println(x, y, x + y)
}

带缓冲的信道

信道可以是带缓冲的。将缓冲长度作为第二个参数提供给 make 来初始化一个带缓冲的信道：

1	ch := make(chan int, 100)

仅当信道的缓冲区填满后，向其发送数据时才会阻塞。当缓冲区为空时，接受方会阻塞。

package main

import "fmt"

func main() {
	ch := make(chan int, 2)
	ch <- 1
	ch <- 2
	fmt.Println(<-ch)
	fmt.Println(<-ch)
}

range 和 close

发送者可通过 close 关闭一个信道来表示没有需要发送的值了。接收者可以通过为接收表达式分配第二个参数来测试信道是否被关闭：若没有值可以接收且信道已被关闭，那么在执行完

1	v, ok := <-ch

之后 ok 会被设置为 false。

循环 for i := range c 会不断从信道接收值，直到它被关闭。

注意： 只有发送者才能关闭信道，而接收者不能。向一个已经关闭的信道发送数据会引发程序恐慌（panic）。

还要注意： 信道与文件不同，通常情况下无需关闭它们。只有在必须告诉接收者不再有需要发送的值时才有必要关闭，例如终止一个 range 循环。

package main

import (
	"fmt"
)

func fibonacci(n int, c chan int) {
	x, y := 0, 1
	for i := 0; i < n; i++ {
		c <- x
		x, y = y, x+y
	}
	close(c)
}

func main() {
	c := make(chan int, 10)
	go fibonacci(cap(c), c)
	for i := range c {
		fmt.Println(i)
	}
}

select语句

select 语句使一个 Go 程可以等待多个通信操作。

select 会阻塞到某个分支可以继续执行为止，这时就会执行该分支。当多个分支都准备好时会随机选择一个执行。

package main

import "fmt"

func fibonacci(c, quit chan int) {
	x, y := 0, 1
	for {
		select {
		case c <- x:
			x, y = y, x+y
		case <- quit:
			fmt.Println("quit")
			return
		}
	}
}

func main() {
	c := make(chan int)
	quit := make(chan int)
	go func() {
		for i := 0; i < 10; i++ {
			fmt.Println(<-c)
		}
		quit <- 0
	}()
	fibonacci(c, quit)
}

默认选择

当 select 中的其它分支都没有准备好时，default 分支就会执行。

为了在尝试发送或者接收时不发生阻塞，可使用 default 分支：

select {
case i := <-c:
    // 使用 i
default:
    // 从 c 中接收会阻塞时执行
}

package main

import (
	"fmt"
	"time"
)

func main() {
	tick := time.Tick(100 * time.Millisecond)
	boom := time.After(500 * time.Millisecond)
	for {
		select {
		case <-tick:
			fmt.Println("tick.")
		case <-boom:
			fmt.Println("BOOM!")
			return
		default:
			fmt.Println("    .")
			time.Sleep(50 * time.Millisecond)
		}
	}
}

练习：等价二叉查找树

1. 实现 Walk 函数。

2. 测试 Walk 函数。

函数 tree.New(k) 用于构造一个随机结构的已排序二叉查找树，它保存了值 k, 2k, 3k, …, 10k。

创建一个新的信道 ch 并且对其进行步进：

1	go Walk(tree.New(1), ch)

然后从信道中读取并打印 10 个值。应当是数字 1, 2, 3, ..., 10。

3. 用 Walk 实现 Same 函数来检测 t1 和 t2 是否存储了相同的值。

4. 测试 Same 函数。

Same(tree.New(1), tree.New(1)) 应当返回 true，而 Same(tree.New(1), tree.New(2)) 应当返回 false。

package main

import (
	"fmt"
	"golang.org/x/tour/tree"
)


// Walk 步进 tree t 将所有的值从 tree 发送到 channel ch。
func Walk(t *tree.Tree, ch chan int) {
	sendValue(t, ch)
	close(ch)
}

func sendValue(t *tree.Tree, ch chan int) {
	if t != nil {
		sendValue(t.Left, ch)
		ch <- t.Value
		sendValue(t.Right, ch)
	}
}

// Same 检测树 t1 和 t2 是否含有相同的值。
func Same(t1, t2 *tree.Tree) bool {
	ch1 := make(chan int)
	ch2 := make(chan int)
	go Walk(t1, ch1)
	go Walk(t2, ch2)
	for i := range ch1 {
		if i != <- ch2 {
			return false
		}
	}
	return true
}

func main() {
	var ch = make(chan int)
	go Walk(tree.New(1),ch)
	for v := range ch {
		fmt.Println(v)
	}
	fmt.Println(Same(tree.New(1), tree.New(1)))
	fmt.Println(Same(tree.New(1), tree.New(2)))
}

sync.Mutex

Go 标准库中提供了 sync.Mutex 互斥锁类型及其两个方法：

Lock
Unlock

我们可以通过在代码前调用 Lock 方法，在代码后调用 Unlock 方法来保证一段代码的互斥执行。

package main

import (
	"fmt"
	"sync"
	"time"
)

// SafeCounter 的并发使用是安全的。
type SafeCounter struct {
	v   map[string]int
	mux sync.Mutex
}

// Inc 增加给定 key 的计数器的值。
func (c *SafeCounter) Inc(key string) {
	c.mux.Lock()
	// Lock 之后同一时刻只有一个 goroutine 能访问 c.v
	c.v[key]++
	c.mux.Unlock()
}

// Value 返回给定 key 的计数器的当前值。
func (c *SafeCounter) Value(key string) int {
	c.mux.Lock()
	// Lock 之后同一时刻只有一个 goroutine 能访问 c.v
	defer c.mux.Unlock()
	return c.v[key]
}

func main() {
	c := SafeCounter{v: make(map[string]int)}
	for i := 0; i < 1000; i++ {
		go c.Inc("somekey")
	}

	time.Sleep(time.Second)
	fmt.Println(c.Value("somekey"))
}