go初学者笔记（4）

• 类型转换

 type(var)
 
 int("1")

• 接口

type interface_name interface {
   method1 [return_type]
   ...
   methodn [return_type]
}


type struct_name struct {
   ...
}


func (struct_var struct_name) methodn() [return_type] {
   ...
}

• 异常处理

// 内置接口
type error interface {
    Error() string
}

errors.New("this is an error message.")

defer包含它的函数返回时才调用，类似于java中的finally

func f() (r int) {
    x := 5
    defer func() {
        x = x + 5
    }()
    return x
}
等同于：
func f() (r int) {
    x := 5
    r = t
    func() {
        t = t + 5
    }
    return
}
=> 返回值r=5

func f() (r int) {
    defer func(r int) {
        r = r + 5
    }(r)
    return 1
}
等同于：
func f() (r int) {
    r = 1
    func(r int) { //注意：这里是形参
        r = r + 5
    }(r)
    return
}
=>返回值r=1

func f() (r int) {
	i := 2
    defer func(i int) {
        fmt.Println("b:", i)
    }(i)
    return i++
}
等同于：
func f() (r int) {
    i = 2
    r = i++
    func(r int) { //注意：这里是形参
        r = r + 5
    }(2)
    return
}
=>返回值r=7

出现panic，则停止后续代码，从下往上依次执行defer(如前所述，函数返回前执行defer)，如果某个defer内有recover，则recover捕捉到error，继续往上执行后续的defer，因为error被recover捕捉，对该函数的外部调用者来说，该函数无异常抛出，外部调用者继续往下执行。若内部没有recover住，则外部调用者相当于在该函数处发生panic。
recover作用于goroutine内部，goroutine外部无法recover goroutine内部的panic，所以goroutine内部的panic如果没有被recover，则将导致整个程序崩溃

func G() {
    defer func() {
        fmt.Println("外部defer")
    }()
    F()
    fmt.Println("外部继续执行")
}

func F() {
	defer func() {
		fmt.Println("捕获异常后继续往上执行defer")
	}
    defer func() {
        if err := recover(); err != nil {
            fmt.Println("捕获异常:", err)
        }
        fmt.Println("捕获异常依次往上执行defer内容")
    }()
    panic("err")
}
=>
捕获异常:err
捕获异常依次往上执行defer内容
捕获异常后继续往上执行defer
外部继续执行
外部defer

func main() {
    defer func() {
        if err := recover(); err != nil { //err是个接口类型，不能用err.Error()
            fmt.Println("捕获异常:", fmt.Errorf("%v", err).Error())
        }
    }()
    panic("a")
}

• 并发

goroutine 是轻量级线程，与kotlin中的coroutine类似

go 函数名( 参数列表 )

go f(a,b)

goroutine之间可以用channel来传递数据

ch := make(chan int, size)  // [opt]size

ch <- v    // 把 v 发送到ch
v := <-ch  // 从 ch 接收

定义ch时，不带size,则是同步地传递数据，发和收完成各自才能继续执行
定义size,则是异步传递数据，除非size满了，或是ch空了，才会导致一方阻塞
发送端可以通过close(ch)来防止接收端因为没有数据而阻塞，close不会导致已经发送到ch的数据丢失
channel可用来防止goroutine因主函数的结束而半途中止