go指南 - 笔记

标签（空格分隔）： go

---

go指南

一、基础

1.包

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

程序从main包开始运行。

包名与导入路径的最后一个元素一致

2.导入

分组导入：使用圆括号组合导入。推荐分组导入。

3.导出名

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

只能导入已导出的名字；任何未导出的名字在该包外均无法访问。

4.函数

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

类型在变量名之后。

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

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

函数可以返回多值：

func swap(x, y string) (string, string) {
    return y, x
}

func main() {
    a, b := swap("hello", "world")
}

go的返回值可被命名，它们会被视作定义在函数顶部的变量。

没有参数的return语句返回已命名的返回值。

仅用在短函数中，否则影响代码可读性。

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

5.变量

var语句用于声明一个变量列表，类型在表达式后面。

多个连续相同的变量也可以按照函数参数一样的方式只在最后一个指定类型。

变量声明可以包含初始值，每个变量对应一个。如果初始值已存在，则可以省略类型。

var i, j int = 1, 2

只能在函数中使用:=在类型明确的地方代替var声明。

6.基本类型

bool

string

int int8 int16 int32 int64
uint uint8 uint16 uint32 uint64 uintptr

byte // uint8

rune // int32

float32 float64

complex64 complex128

int，uint，uintptr在32位系统上通常为32位宽，64位系统上则为64位宽。

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

• 数值类型为0
• 布尔类型为false
• 字符串为""(空字符串)

表达式t(v)将值v转换为类型t。

i := 3
f := float64(i)

7.常量

使用const关键字。不能使用:=语法。

二、流程控制语句

1.for

go只有一种循环结构：for循环。

基本的for循环由三部分组成，它们用分号隔开：
初始化语句：在每一次迭代前执行；通常为短变量声明，该变量仅在for语句作用域中可见
条件表达式：在每次迭代前求值；一旦表达式的布尔值为false，迭代就会终止
后置语句：在每次迭代的结尾执行

for i := 0; i < 10; i++ {  }

// 初始化语句和后置语句是可选的
// 相当于while循环
j := 1
for j < 10 {  }

// 无限循环
for {  }

go的for语句后面的三个构成部分外没有小括号，大括号{}则是必须的。

2.if

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

if语句可以在条件表达式之前执行一个简单的语句，该语句声明变量的作用域仅在if之内(包括它的else块)。

if y := x * x; y > 100 { }

3.switch

go会自动终止case分支，想要不终止需要fallthrough语句结束。

case可以是表达式。

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

switch的条件可以为true，或者说没有条件；此时相当于if else语句。

4.defer

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

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

defer fmt.println("world")
fmt.println("hello")

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

for i := 0; i < 10; i++ {
    defer fmt.println(i)
}

// 结果： 9 8 7 6 5 4 3 2 1 0

三、struct、slice和映射等

1.指针

go拥有指针。指针保存了值的内存地址。
go没有指针运算。

类型*t是指向t类型值的指针。其零值为nil。

var p *int
fmt.println(p)
// <nil>

&操作符会生成一个指向其操作数的指针。

i := 1
p = &i
fmt.println(p)
// 0x416038

*操作符表示指针指向的底层值。这就是通常所说的“间接引用”或“重定向”。

fmt.println(*p) // 通过指针 p 读取 i
*p = 21         // 通过指针 p 设置 i

2.结构体（struct）

一个结构体（struct）就是一组字段（field）。
结构体字段用点号来访问。

type vertex struct {
    x int
    y int
}

func main() {
    fmt.printin(vertex{1, 2}) // {1 2}
    v.x = 4
    fmt.println(v.x) // 4
}

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

允许隐式间接引用（不写*号）：

v := vertex{1, 2}
p := &v
fmt.println(p.x) // 1

3.数组

类型[n]t表示拥有n个t类型的值的数组。

切片为数组元素提供动态大小的、灵活的视角。切片比数组更常用。

类型[]t表示一个元素类型为t的切片。

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

arr[low: high]

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

primes := [6]int{2, 3, 5, 7, 11, 13}

var s []int = primes[1:4]
fmt.println(s)
// [3 5 7]

切片就像数组的引用

切片并不存储任何数据，它只是描述了底层数组中的一段。
更改切片的元素会修改其底层数组中对应的元素。
与它共享底层数组的切片都会观测到这些修改。

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

[]bool {true, false, true}

上面的代码会创建一个数组，然后构建了这个引用这个数组的一个切片。

下面是一个结构体切片：：

s := []struct {
    i int
    b string
} {
    {1, "a"},
    {2, "b"},
    {3, "c"},
    {4, "d"},
    {5, "e"},
}

fmt.println(s)
// [{1 a} {2 b} {3 c} {4 d} {5 e}]

在进行切片时，可以利用它的默认行为来忽略上下界。
切片下界默认值为0，上界则是该切片的长度。

对于数组：

var a [10]int

// 以下切片是等价的
a[0:10]
a[:10]
a[0:]
a[:]

切片拥有长度和容量。
切片的长度就是它所包含的元素的个数。
切片的容量是从它的第一个元素开始数，到其底层数组元素末尾的个数。
切片的零值是nil，长度和容量为0且没有底层数组。

切片s的长度可以通过表达式len(s)，容量通过cap(s)来获取。
可以通过重新切片来扩展一个切片，给它足够的容量。

s := []int{2, 3, 5, 7, 11, 13}
// len=6 cap=6 [2 3 5 7 11 13]

// 截取切片使其长度为 0
s = s[:0]
// len=0 cap=6 []

// 拓展其长度
s = s[:4]
// len=4 cap=6 [2 3 5 7]

// 舍弃前两个值
s = s[2:]
// len=2 cap=4 [5 7]

make([]t, length, cap)函数会分配一个元素为零值的数组并返回一个引用了它的切片。

a := make([]int, 5)
// len(a) = 5
// a = [0 0 0 0 0]

append(arr []t, val1<t>, val2<t>, val3<t>...) []t函数可以为切片追加新元素。

var s []int

s = append(s, 1, 2)
// s = [1 2]

for循环的range形式可遍历切片或映射。
每次迭代返回 第一个值为当前元素的下标，第二个值为该元素对应元素的一份副本。
可用_来代替i或者v来忽略其值。

pow := []int{1, 2, 4, 8, 16, 32, 64, 128}
for i, v := range pow {
    fmt.printf("2**%d = %d\n", i, v)
}
// 2**0 = 1
// 2**1 = 2
// 2**2 = 4
// 2**3 = 8
// 2**4 = 16
// 2**5 = 32
// 2**6 = 64
// 2**7 = 128

4.映射

映射将键映射到值。
映射的零值为nil。nil映射既没有键，也不能添加键。
make^[1]函数会返回给定类型的映射，并将其初始化备用。
映射的文法与结构体相似，不过必须有键名^[2]。
若*类型只是一个类型名，可以在文法中省略^[3]它。

type user struct {
    id int
    name string
}

func main() {
    // 1. make 函数构建
    u := make(map[string]user)
    u["第一名"] = user{ 1, "john lee", }
    u["第二名"] = user{ 2, "bob zhang", }
    fmt.println(u)
    // map[第一名:{1 john lee} 第二名:{2 bob zhang}]
    
    // 2. 直接赋值
    u2 := map[string]user {
        "特等奖": user{ 3, "lily wong" },
    }
    fmt.println(u2)
    // map[特等奖:{3 lily wong}]
    
    // 3. 省略类型
    u3 := map[string]user {
        "特困生": { 4, "sam liu" },
    }
    fmt.println(u3)
    // map[特困生:{4 sam liu}]
}

映射中插入或修改元素：

m[key] = elem

获取元素：

elem = m[key]

删除元素：

delete(m, key)

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

// 若 key 在 m 中，ok 为 true，否则为 false。
// 若 key 不在映射 m 中，那么 elem 是该映射元素类型的零值。
elem, ok = m[key]

5.函数

go函数可以是一个闭包。
闭包是一个函数值，它引用了其函数体之外的变量。
该函数可以访问并赋予其引用的变量的值。

// 斐波纳契数列
func fibonacci() func(int) []int {
    arr := []int{}
    return func(i int) []int {
        if i <= 1 {
            arr = append(arr, i)
        } else {
            arr = append(arr, arr[i - 1] + arr[i - 2])
        }
        return arr
    }
}

func main() {
    f := fibonacci()
    var result []int
    for i := 0; i < 10; i++ {
        result = f(i)
    }
    fmt.println(result)
    // [0 1 1 2 3 5 8 13 21 34]
}

四、方法和接口

1.方法

go没有类。

可以为结构体类型定义方法。
方法就是一类带特殊接收者参数的函数。
方法即函数。
方法接收者在它自己的参数列表内，位于func关键字和方法名之间。

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())
    // result: 5
}

也可以为非结构体类型声明方法。

接收者的类型定义和方法必须在同一包内，不能为内建类型声明方法。

type myfloat float64

func (f myfloat) abs() float64 {
    if f < 0 {
        return float64(-f)
    }
    return float64(f)
}

func main() {
    f := myfloat(-math.sqrt(2))
    fmt.println(f.abs())
    // result: 1.4142135623730951
}

可以为指针接收者声明方法。
对于某类型t，接收者的类型可以用*t的文法。但是t不能是*int这样的指针。
方法必须使用指针接收者来更改声明的原始值^[4]。

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

• 方法能够修改其接收者指向的值
• 这样可以避免在每次调用方法时复制该值。若值为大型结构体时，这样做更加高效。

type vertex strcut {
    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())
    // result: 50
    // [4]: 如果我们把 scale 方法的 * 去掉
    // 结果又变成了 5
}

带指针参数的函数必须接受一个指针（带指针类型参数的函数，其参数必须是指针）。

var v vertex
scalefunc(v, 5)  // 编译错误！
scalefunc(&v, 5) // ok

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

var v vertex
v.scale(5) // ok
p := &v
p.scale(10) // ok

同理，接受一个值作为参数的函数必须接受一个指定类型的值。

var v vertex
absfunc(v) // ok
absfunc(&v) // 编译错误！

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

var v vertex
v.abs() // ok
p := &v
p.abs() // ok

type vertex struct {
    x, y float64
}

func (v vertex) abs() float64 {
    reutrn 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())     // 5
    fmt.println(absfunc(v))  // 5
    
    p := &vertex{4, 3}
    fmt.println(p.abs())     // 5
    fmt.println(absfunc(*p)) // 5
}

2.接口

type i interface {
    [funcs]()
}

接口类型interface是由一组方法签名定义的集合。
接口类型的变量可以保存任何实现了这些方法的值。

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() // result: hello
}

接口也是值。
接口可以像其它值一样传递。
接口值也可以用作函数的参数或返回值。

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

(value, type)

接口值保存了一个具体底层类型的具体值。
接口值调用方法时会执行其底层类型的同名方法。

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 describe(i i) {
    fmt.printf("(%v, %t)\n", i, i)
}

func main() {
    var i i
    
    i = &t{"hello"}
    describe(i) // (&{hello}, *main.t)
    i.m()       // hello
    
    i = f(math.pi)
    describe(i) // (3.141592653589793, main.f)
    i.m()       // 3.141592653589793
}

底层值为nil的接口值。
即便接口内的具体值为nil，方法仍然会被nil接收者调用。
保存了nil具体值的接口其自身并不为nil。

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 describe(i i) {
    fmt.printf("(%v, %t)\n", i, i)
}

func main() {
    var i i
    
    // nil接口值既不保存值也不保存具体类型。
    // 为nil接口调用方法会产生运行时错误，因为接口的元组内并未包含能够指明该调用哪个具体方法的类型。
    describe(i) // (<nil>, <nil>)
    i.m()       // 编译错误！
    
    var t *t
    i = t
    describe(i) // (<nil>, *main.t)
    i.m()       // <nil>
    
    i = &t{"hello"}
    describe(i) // (&{hello}, *main.t)
    i.m()       // hello
}

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

interface {}

空接口可以保存任何类型的值（因为每个类型都至少实现了零个方法）。
空接口被用来处理未知类型的值。
例如fmt.print可接受类型为interface {}的任意数量的参数。

3.类型断言

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

t := i.(t)

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

t, ok := i.(t)

如果i保存了一个t，那么t将会是其底层值，而ok为true；否则ok将为false，而t为类型t的零值。

4.类型选择

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

与switch语句相似，case为类型。

switch v := i.(type) {
    case t:
    // v的类型为t
    case s:
    // v的类型为s
    default:
    // 没有匹配 v与i的类型相同
}

5.stringer

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

fmt.sprintf()

package main

import "fmt"

type ipaddr [4]byte

// todo: 给 ipaddr 添加一个 "string() string" 方法
func (ip ipaddr) string() string {
    return fmt.sprintf("%v.%v.%v.%v", ip[0], ip[1], ip[2], ip[3])
}

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

6.错误

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

error类型是一个内建接口：

type error interface {
    error() string
}

error为nil时表示成功，否则是失败。

7. reader

io包指定了io.reader接口，它表示从数据流的末尾进行读取。
在遇到数据流的结尾时，它会返回一个io.eof错误。

func (t) read(b []byte) (n int, err error)

8. 图像

image包定义了image接口。

package image

type image interface {
    colormodel() color.model
    bounds() rectangle
    at(x, y int) color.color
}

package main

import (
    "golang.org/x/tour/pic"
    "image"
    "image/color"
)

type image struct{}

func (i image) colormodel() color.model {
    return color.rgbamodel
}

func (i image) bounds() image.rectangle {
    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{}
    pic.showimage(m)
}

五、并发

1.go程

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

go f()

2.信道

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

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

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

ch := make(chan int)

package main

import "fmt"

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

func main() {
    s := []int{7, 2, 8, -9, 4, 0}
    
    c := make(chan int)
    go sum(s[:len(s) / 2], c)
    go sum(s[len(s) / 2:], c)
    x, y := <-c , <-c // 从c中接收
    
    fmt.println(x, y)
    // -5
    // 17
}

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

ch := make(chan int, 100)

3.range和close

发送者可通过close关闭一个信道来表示没有需要发送的值了。

接收者可以通过为接收表达式分配第二个参数来测试信道是否被关闭；若没有值可以接收且信道已被关闭，那么在执行完

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

4.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)
    // 0 1 1 2 3 5 8 13 21 34 quit
}

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

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

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

package main

import (
    "fmt"
    "time"
)

func main() {
    tick := time.tick(1000 * time.millisecond)
    boom := time.after(5000 * time.millisecond)
    for {
        select {
            case <-tick:
                fmt.println("tick")
            case <-boom:
                fmt.println("boom!")
                return
            default:
                fmt.println("     .")
                time.sleep(500 * time.millisecond)
        }
    }
}

---

the end. last updated by jehorn, 3:30 pm, tuesday, march 26, 2019 (gmt+8)