golang接口与错误处理

接口

package main

import "fmt"

type Speacker interface {
	Say(string)
}

func speack(speacker Speacker) {
	speacker.Say("this is interface")
}

type Person struct {
	name string
}

func (p *Person) Say(message string) {
	fmt.Println(p.name, ":", message)
}

func main() {
	james := new(Person)
	james.name = "James"

	speack(james)
}

• 接口把所有具有共性的方法定义在一起
• 任何其他类型只要实现了这些方法就是实现了这个接口
• 空接口可以传入任意类型的数据：interface{}

系统常用接口

//string接口
type Stringer interface {
	String() string
}

//排序的接口
type Interface interface {
	Len() int
	Less(i, j int) bool
	Swap(i, j int)
}

//读接口
type Reader interface {
	Read(p []byte) (n int, err error)
}

//写接口
type Writer interface {
	Writer(p []byte) (n int, err error)
}

错误处理：

package main

import (
	"errors"
	"fmt"
)

type Divide struct {
	dividee int
	divider int
}

//实现error interface
func (d *Divide) Error() string {
	strFormat := `
	Cannot proceed , the divider is zero
	dividee:%d
	divider:0
`
	return fmt.Sprintf(strFormat, d.dividee)
}

func computeDiv(d *Divide) (result int, err error) {
	if d.divider == 0 {
		err = d
	} else {
		result = d.dividee / d.divider
	}
	return
}

func main() {

	err := errors.New("this is a new err object")
	fmt.Println(err)

	de := Divide{100, 0}
	if result, err := computeDiv(&de); err != nil {
		fmt.Println(err.Error())
	} else {
		fmt.Println(result)
	}

}

• 实现error interface

defer语句

• defer的内容在当前函数结束之后执行，（如果有return，则在return之前执行）
• 多个defer函数式一个栈的形式，先进后出
• 主要用于释放资源，关闭连接；比如网络连接，数据库连接

panic/recover（类似于java的try catch）

package main

import "fmt"

func tryPanic() {

	fmt.Println("first")
	panic("call a panic")
}

//装饰器
func protect(g func()) {
	defer func() {
		if e := recover(); e != nil {
			fmt.Printf("catch panic in recover %\n", e)
		}
	}()
	g()
}

func main() {
	protect(tryPanic)

}

• panic停止当前函数的执行，一直向上返回，执行每一层的defer
• 如果没有遇见recover则退出程序
• recover只能再defer中使用，获取panic的值