Golang进阶之路(四),标准错误和异常

感谢参考原文-http://bjbsair.com/2020-04-01/tech-info/18320.html

标准错误

Go语言内置的error接口,自定义的类型,只要实现该接口方法即可称为标准错误类型,来看看源码:

// The error built-in interface type is the conventional interface for  
// representing an error condition, with the nil value representing no error.  
type error interface {  
  Error() string  
}

自定义一个错误类型,实现error接口的Error()方法:

type MyError struct {  
  s string  
}  
func (myError MyError) Error() string {  
  return "MyError"  
}  
func main() {  
  var e MyError = MyError{"err"}  
  fmt.Println(e)  // 输出:MyError  
  err, ok := interface{}(e).(error)  
  fmt.Println(ok)  // 输出:true  
  fmt.Println(err)  // 输出:MyError  
}

从上面例子来看,err, ok := interface{}(e).(error)中的类型转换结果为true,说明自定义的类型就是error的子类型,也就证实了只要某个类型实现了Error()方法,那这个类型就是error类型。

errors包

Go语言的errors包有个内置的错误类型叫errorString,来看一下源码:

package errors  
  
  
// New returns an error that formats as the given text.  
// Each call to New returns a distinct error value even if the text is identical.  
func New(text string) error {  
  return &errorString{text}  
}  
  
  
// errorString is a trivial implementation of error.  
type errorString struct {  
  s string  
}  
  
  
func (e *errorString) Error() string {  
  return e.s  
}

从上面的源码看到,errorString类型实现了error接口的Error()方法,因此errorString类型就是error的子类型。

我们知道,当某个包下面的变量和方法名以小写开头时,这个变量或者方法只能在这个包下面才能访问。因此,我们自己写的代码没办法直接创建errorString的实例,我们可以使用errors里的New方法方便的创建error类型。

var e = errors.New("MyError")  
fmt.Println(e)  // 输出:MyError  
err, ok := interface{}(e).(error)  
fmt.Println(ok)  // 输出:true  
fmt.Println(err)  // 输出:MyError

和最上面的例子一样,err, ok := interface{}(e).(error)中的类型转换结果为true,说明errorString就是error的子类型。

创建标准错误

func f1(arg int) (int, error) {  
    if arg == 42 {  
        return -1, errors.New("can't work with 42")  // 使用错误提示创建标准错误  
    }  
    return arg + 3, nil  
}  
  
  
type argError struct {  
    arg  int  
    prob string  
}  
  
  
func (e *argError) Error() string {  // 自定义错误类型需要实现Error函数  
    return fmt.Sprintf("%d - %s", e.arg, e.prob)  
}  
func f2(arg int) (int, error) {  
    if arg == 42 {  
        return -1, &argError{arg, "can't work with it"}  
    }  
    return arg + 3, nil  
}  
func main() {  
    for _, i := range []int{7, 42} {  
        if r, e := f1(i); e != nil {  
            fmt.Println("f1 failed:", e)  // f1 failed: can't work with 42  
        } else {  
            fmt.Println("f1 worked:", r)  
        }  
    }  
    for _, i := range []int{7, 42} {  
        if r, e := f2(i); e != nil {  
            fmt.Println("f2 failed:", e)  
        } else {  
            fmt.Println("f2 worked:", r)  
        }  
    }  
    _, e := f2(42)  
    if ae, ok := e.(*argError); ok {  
        fmt.Println(ae.arg)  
        fmt.Println(ae.prob)  
    }  
}  

格式化消息的标准错误类型

fmt包中有个Errorf方法,我们可以通过它创建一个具有格式化字符串的标准错误类型,来看一下fmt.Errorf的源码:

func Errorf(format string, a ...interface{}) error {  
  p := newPrinter()  
  p.wrapErrs = true  
  p.doPrintf(format, a)  
  s := string(p.buf)  
  var err error  
  if p.wrappedErr == nil {  
    err = errors.New(s)  
  } else {  
    err = &wrapError{s, p.wrappedErr}  
  }  
  p.free()  
  return err  
}

可以看到,fmt.Errorf里面使用errors.New来创建error类型的实例,然后把格式化后字符串放入这个实例里面。典型使用案例:

const name, id = "bimmler", 17  
err := fmt.Errorf("user %q (id %d) not found", name, id)  // user="bimmler" (id=17) not found  
if err != nil {  
  fmt.Print(err)  
}

这样,err不仅包含了格式化的错误消息,而且还是error类型,比我们先用fmt.Printf再用errors.New的写法会更简洁。

天杀错误判断和处理逻辑

刚从其他语言转到Go语言时,会非常不习惯Go语言的错误处理逻辑。在Java和Python里面,我们可以使用throw来抛出异常,在另一个地方使用try...catch来捕获异常。而Go语言鼓励大家把错误放到返回值里面,但是呢,又提供了panic和recover来抛出和捕获异常。一般来说,我们把返回值里面返回的叫做错误(因为他们都是error类型),把抛出和捕获的叫做异常。

既然把错误放到返回值里,那我们就每次都需要判断返回里的错误是否为空,才能知道是不是正常返回了。判断和处理错误需要用到if,如果一段代码里面调用了很多函数,我们就能看到一连串的if,这种写法感觉简直就是疯了!

result1, err := err1()  
if err != nil {  
  fmt.Println(result1)  
}  
result2, err := err2()  
if err != nil {  
  fmt.Println(result2)  
}  
result3, err := err3()  
if err != nil {  
  fmt.Println(result3)  
}  
result4, err := err4()  
if err != nil {  
  fmt.Println(result4)  
}

不过这个没法避免,老老实实习惯一下吧!

panic/recover/defer

对于异常,Go语言可以使用panic来抛出一个恐慌性异常,一般来说,当程序遇到了比较大的问题,没有办法再执行下去,我们就用panic来抛出异常。来看一下panic源码:

func panic(v interface{})

panic接收一个interface{}类型的对象,我们上篇文章说过了,任何类型都是interface{}类型的子类型,因此,panic可以抛出任何对象。使用案例:

func main() {  
  panic("hello")  
}

输出:

panic: hello  
  
goroutine 1 [running]:  
main.main()  
    E:/goworkspace/blog/src/main/main.go:4 +0x40  

同时,我们可以使用recover来捕获那些被panic抛出对象:

func pa() string {  
  panic("me")  
}  
func main() {  
  p := pa()  
fmt.Println(p)  
if r := recover(); r != nil {  
   fmt.Println(r)  
  }  
}

输出:

panic: me  
  
goroutine 1 [running]:  
main.pa(...)  
    E:/goworkspace/blog/src/main/main.go:6  
main.main()  
    E:/goworkspace/blog/src/main/main.go:9 +0x40

怎么好像recover没起作用?这当然了,recover需要与defer一起使用,而且,recover的使用要放在panic抛出之前。下面的例子才对:

func pa() string {  
  panic("me")  
}  
func main() {  
  defer func() {  
    if r := recover(); r != nil {  
      fmt.Println(r)  // 输出:me  
    }  
  }()  
  p := pa()  // 此行panic抛出me字符串  
  fmt.Println(p)  // 此行不会执行  
}

defer的用法

defer关键字表示,当前这个函数在退出之前,执行一下defer后面的逻辑。相当于我们委托一些操作给Go语言,在函数退出之前执行,有点像Java和Python里面的finally作用了。

这样,我们就可以把一些一定要执行的操作,放在defer中了,比如,我们关闭某个已经打开的资源:

fsrc, err := os.Open("source.txt")  
if err != nil {  
  fmt.Println("open source file failed")  
  return  
}  
defer fsrc.Close()  // 第一个defer  
fdes, err := os.Open("target.txt")  
if err != nil {  
  fmt.Println("open target file failed")  
  return  
}  
defer fdes.Close()  // 第二个defer  
fmt.Println("do something here")

如果一个函数里面有多个defer,那么在函数推出之前,会先执行最后一个defer,然后再执行倒数第二个、倒数第三个...,就像后进先出栈的操作。

我们下一篇聊聊通道和goroutine。

喜欢的点个关注!感谢参考原文-http://bjbsair.com/2020-04-01/tech-info/18320.html

标准错误

Go语言内置的error接口,自定义的类型,只要实现该接口方法即可称为标准错误类型,来看看源码:

// The error built-in interface type is the conventional interface for  
// representing an error condition, with the nil value representing no error.  
type error interface {  
  Error() string  
}

自定义一个错误类型,实现error接口的Error()方法:

type MyError struct {  
  s string  
}  
func (myError MyError) Error() string {  
  return "MyError"  
}  
func main() {  
  var e MyError = MyError{"err"}  
  fmt.Println(e)  // 输出:MyError  
  err, ok := interface{}(e).(error)  
  fmt.Println(ok)  // 输出:true  
  fmt.Println(err)  // 输出:MyError  
}

从上面例子来看,err, ok := interface{}(e).(error)中的类型转换结果为true,说明自定义的类型就是error的子类型,也就证实了只要某个类型实现了Error()方法,那这个类型就是error类型。

errors包

Go语言的errors包有个内置的错误类型叫errorString,来看一下源码:

package errors  
  
  
// New returns an error that formats as the given text.  
// Each call to New returns a distinct error value even if the text is identical.  
func New(text string) error {  
  return &errorString{text}  
}  
  
  
// errorString is a trivial implementation of error.  
type errorString struct {  
  s string  
}  
  
  
func (e *errorString) Error() string {  
  return e.s  
}

从上面的源码看到,errorString类型实现了error接口的Error()方法,因此errorString类型就是error的子类型。

我们知道,当某个包下面的变量和方法名以小写开头时,这个变量或者方法只能在这个包下面才能访问。因此,我们自己写的代码没办法直接创建errorString的实例,我们可以使用errors里的New方法方便的创建error类型。

var e = errors.New("MyError")  
fmt.Println(e)  // 输出:MyError  
err, ok := interface{}(e).(error)  
fmt.Println(ok)  // 输出:true  
fmt.Println(err)  // 输出:MyError

和最上面的例子一样,err, ok := interface{}(e).(error)中的类型转换结果为true,说明errorString就是error的子类型。

创建标准错误

func f1(arg int) (int, error) {  
    if arg == 42 {  
        return -1, errors.New("can't work with 42")  // 使用错误提示创建标准错误  
    }  
    return arg + 3, nil  
}  
  
  
type argError struct {  
    arg  int  
    prob string  
}  
  
  
func (e *argError) Error() string {  // 自定义错误类型需要实现Error函数  
    return fmt.Sprintf("%d - %s", e.arg, e.prob)  
}  
func f2(arg int) (int, error) {  
    if arg == 42 {  
        return -1, &argError{arg, "can't work with it"}  
    }  
    return arg + 3, nil  
}  
func main() {  
    for _, i := range []int{7, 42} {  
        if r, e := f1(i); e != nil {  
            fmt.Println("f1 failed:", e)  // f1 failed: can't work with 42  
        } else {  
            fmt.Println("f1 worked:", r)  
        }  
    }  
    for _, i := range []int{7, 42} {  
        if r, e := f2(i); e != nil {  
            fmt.Println("f2 failed:", e)  
        } else {  
            fmt.Println("f2 worked:", r)  
        }  
    }  
    _, e := f2(42)  
    if ae, ok := e.(*argError); ok {  
        fmt.Println(ae.arg)  
        fmt.Println(ae.prob)  
    }  
}  

格式化消息的标准错误类型

fmt包中有个Errorf方法,我们可以通过它创建一个具有格式化字符串的标准错误类型,来看一下fmt.Errorf的源码:

func Errorf(format string, a ...interface{}) error {  
  p := newPrinter()  
  p.wrapErrs = true  
  p.doPrintf(format, a)  
  s := string(p.buf)  
  var err error  
  if p.wrappedErr == nil {  
    err = errors.New(s)  
  } else {  
    err = &wrapError{s, p.wrappedErr}  
  }  
  p.free()  
  return err  
}

可以看到,fmt.Errorf里面使用errors.New来创建error类型的实例,然后把格式化后字符串放入这个实例里面。典型使用案例:

const name, id = "bimmler", 17  
err := fmt.Errorf("user %q (id %d) not found", name, id)  // user="bimmler" (id=17) not found  
if err != nil {  
  fmt.Print(err)  
}

这样,err不仅包含了格式化的错误消息,而且还是error类型,比我们先用fmt.Printf再用errors.New的写法会更简洁。

天杀错误判断和处理逻辑

刚从其他语言转到Go语言时,会非常不习惯Go语言的错误处理逻辑。在Java和Python里面,我们可以使用throw来抛出异常,在另一个地方使用try...catch来捕获异常。而Go语言鼓励大家把错误放到返回值里面,但是呢,又提供了panic和recover来抛出和捕获异常。一般来说,我们把返回值里面返回的叫做错误(因为他们都是error类型),把抛出和捕获的叫做异常。

既然把错误放到返回值里,那我们就每次都需要判断返回里的错误是否为空,才能知道是不是正常返回了。判断和处理错误需要用到if,如果一段代码里面调用了很多函数,我们就能看到一连串的if,这种写法感觉简直就是疯了!

result1, err := err1()  
if err != nil {  
  fmt.Println(result1)  
}  
result2, err := err2()  
if err != nil {  
  fmt.Println(result2)  
}  
result3, err := err3()  
if err != nil {  
  fmt.Println(result3)  
}  
result4, err := err4()  
if err != nil {  
  fmt.Println(result4)  
}

不过这个没法避免,老老实实习惯一下吧!

panic/recover/defer

对于异常,Go语言可以使用panic来抛出一个恐慌性异常,一般来说,当程序遇到了比较大的问题,没有办法再执行下去,我们就用panic来抛出异常。来看一下panic源码:

func panic(v interface{})

panic接收一个interface{}类型的对象,我们上篇文章说过了,任何类型都是interface{}类型的子类型,因此,panic可以抛出任何对象。使用案例:

func main() {  
  panic("hello")  
}

输出:

panic: hello  
  
goroutine 1 [running]:  
main.main()  
    E:/goworkspace/blog/src/main/main.go:4 +0x40  

同时,我们可以使用recover来捕获那些被panic抛出对象:

func pa() string {  
  panic("me")  
}  
func main() {  
  p := pa()  
fmt.Println(p)  
if r := recover(); r != nil {  
   fmt.Println(r)  
  }  
}

输出:

panic: me  
  
goroutine 1 [running]:  
main.pa(...)  
    E:/goworkspace/blog/src/main/main.go:6  
main.main()  
    E:/goworkspace/blog/src/main/main.go:9 +0x40

怎么好像recover没起作用?这当然了,recover需要与defer一起使用,而且,recover的使用要放在panic抛出之前。下面的例子才对:

func pa() string {  
  panic("me")  
}  
func main() {  
  defer func() {  
    if r := recover(); r != nil {  
      fmt.Println(r)  // 输出:me  
    }  
  }()  
  p := pa()  // 此行panic抛出me字符串  
  fmt.Println(p)  // 此行不会执行  
}

defer的用法

defer关键字表示,当前这个函数在退出之前,执行一下defer后面的逻辑。相当于我们委托一些操作给Go语言,在函数退出之前执行,有点像Java和Python里面的finally作用了。

这样,我们就可以把一些一定要执行的操作,放在defer中了,比如,我们关闭某个已经打开的资源:

fsrc, err := os.Open("source.txt")  
if err != nil {  
  fmt.Println("open source file failed")  
  return  
}  
defer fsrc.Close()  // 第一个defer  
fdes, err := os.Open("target.txt")  
if err != nil {  
  fmt.Println("open target file failed")  
  return  
}  
defer fdes.Close()  // 第二个defer  
fmt.Println("do something here")

如果一个函数里面有多个defer,那么在函数推出之前,会先执行最后一个defer,然后再执行倒数第二个、倒数第三个...,就像后进先出栈的操作。

我们下一篇聊聊通道和goroutine。

喜欢的点个关注!感谢参考原文-http://bjbsair.com/2020-04-01/tech-info/18320.html

标准错误

Go语言内置的error接口,自定义的类型,只要实现该接口方法即可称为标准错误类型,来看看源码:

// The error built-in interface type is the conventional interface for  
// representing an error condition, with the nil value representing no error.  
type error interface {  
  Error() string  
}

自定义一个错误类型,实现error接口的Error()方法:

type MyError struct {  
  s string  
}  
func (myError MyError) Error() string {  
  return "MyError"  
}  
func main() {  
  var e MyError = MyError{"err"}  
  fmt.Println(e)  // 输出:MyError  
  err, ok := interface{}(e).(error)  
  fmt.Println(ok)  // 输出:true  
  fmt.Println(err)  // 输出:MyError  
}

从上面例子来看,err, ok := interface{}(e).(error)中的类型转换结果为true,说明自定义的类型就是error的子类型,也就证实了只要某个类型实现了Error()方法,那这个类型就是error类型。

errors包

Go语言的errors包有个内置的错误类型叫errorString,来看一下源码:

package errors  
  
  
// New returns an error that formats as the given text.  
// Each call to New returns a distinct error value even if the text is identical.  
func New(text string) error {  
  return &errorString{text}  
}  
  
  
// errorString is a trivial implementation of error.  
type errorString struct {  
  s string  
}  
  
  
func (e *errorString) Error() string {  
  return e.s  
}

从上面的源码看到,errorString类型实现了error接口的Error()方法,因此errorString类型就是error的子类型。

我们知道,当某个包下面的变量和方法名以小写开头时,这个变量或者方法只能在这个包下面才能访问。因此,我们自己写的代码没办法直接创建errorString的实例,我们可以使用errors里的New方法方便的创建error类型。

var e = errors.New("MyError")  
fmt.Println(e)  // 输出:MyError  
err, ok := interface{}(e).(error)  
fmt.Println(ok)  // 输出:true  
fmt.Println(err)  // 输出:MyError

和最上面的例子一样,err, ok := interface{}(e).(error)中的类型转换结果为true,说明errorString就是error的子类型。

创建标准错误

func f1(arg int) (int, error) {  
    if arg == 42 {  
        return -1, errors.New("can't work with 42")  // 使用错误提示创建标准错误  
    }  
    return arg + 3, nil  
}  
  
  
type argError struct {  
    arg  int  
    prob string  
}  
  
  
func (e *argError) Error() string {  // 自定义错误类型需要实现Error函数  
    return fmt.Sprintf("%d - %s", e.arg, e.prob)  
}  
func f2(arg int) (int, error) {  
    if arg == 42 {  
        return -1, &argError{arg, "can't work with it"}  
    }  
    return arg + 3, nil  
}  
func main() {  
    for _, i := range []int{7, 42} {  
        if r, e := f1(i); e != nil {  
            fmt.Println("f1 failed:", e)  // f1 failed: can't work with 42  
        } else {  
            fmt.Println("f1 worked:", r)  
        }  
    }  
    for _, i := range []int{7, 42} {  
        if r, e := f2(i); e != nil {  
            fmt.Println("f2 failed:", e)  
        } else {  
            fmt.Println("f2 worked:", r)  
        }  
    }  
    _, e := f2(42)  
    if ae, ok := e.(*argError); ok {  
        fmt.Println(ae.arg)  
        fmt.Println(ae.prob)  
    }  
}  

格式化消息的标准错误类型

fmt包中有个Errorf方法,我们可以通过它创建一个具有格式化字符串的标准错误类型,来看一下fmt.Errorf的源码:

func Errorf(format string, a ...interface{}) error {  
  p := newPrinter()  
  p.wrapErrs = true  
  p.doPrintf(format, a)  
  s := string(p.buf)  
  var err error  
  if p.wrappedErr == nil {  
    err = errors.New(s)  
  } else {  
    err = &wrapError{s, p.wrappedErr}  
  }  
  p.free()  
  return err  
}

可以看到,fmt.Errorf里面使用errors.New来创建error类型的实例,然后把格式化后字符串放入这个实例里面。典型使用案例:

const name, id = "bimmler", 17  
err := fmt.Errorf("user %q (id %d) not found", name, id)  // user="bimmler" (id=17) not found  
if err != nil {  
  fmt.Print(err)  
}

这样,err不仅包含了格式化的错误消息,而且还是error类型,比我们先用fmt.Printf再用errors.New的写法会更简洁。

天杀错误判断和处理逻辑

刚从其他语言转到Go语言时,会非常不习惯Go语言的错误处理逻辑。在Java和Python里面,我们可以使用throw来抛出异常,在另一个地方使用try...catch来捕获异常。而Go语言鼓励大家把错误放到返回值里面,但是呢,又提供了panic和recover来抛出和捕获异常。一般来说,我们把返回值里面返回的叫做错误(因为他们都是error类型),把抛出和捕获的叫做异常。

既然把错误放到返回值里,那我们就每次都需要判断返回里的错误是否为空,才能知道是不是正常返回了。判断和处理错误需要用到if,如果一段代码里面调用了很多函数,我们就能看到一连串的if,这种写法感觉简直就是疯了!

result1, err := err1()  
if err != nil {  
  fmt.Println(result1)  
}  
result2, err := err2()  
if err != nil {  
  fmt.Println(result2)  
}  
result3, err := err3()  
if err != nil {  
  fmt.Println(result3)  
}  
result4, err := err4()  
if err != nil {  
  fmt.Println(result4)  
}

不过这个没法避免,老老实实习惯一下吧!

panic/recover/defer

对于异常,Go语言可以使用panic来抛出一个恐慌性异常,一般来说,当程序遇到了比较大的问题,没有办法再执行下去,我们就用panic来抛出异常。来看一下panic源码:

func panic(v interface{})

panic接收一个interface{}类型的对象,我们上篇文章说过了,任何类型都是interface{}类型的子类型,因此,panic可以抛出任何对象。使用案例:

func main() {  
  panic("hello")  
}

输出:

panic: hello  
  
goroutine 1 [running]:  
main.main()  
    E:/goworkspace/blog/src/main/main.go:4 +0x40  

同时,我们可以使用recover来捕获那些被panic抛出对象:

func pa() string {  
  panic("me")  
}  
func main() {  
  p := pa()  
fmt.Println(p)  
if r := recover(); r != nil {  
   fmt.Println(r)  
  }  
}

输出:

panic: me  
  
goroutine 1 [running]:  
main.pa(...)  
    E:/goworkspace/blog/src/main/main.go:6  
main.main()  
    E:/goworkspace/blog/src/main/main.go:9 +0x40

怎么好像recover没起作用?这当然了,recover需要与defer一起使用,而且,recover的使用要放在panic抛出之前。下面的例子才对:

func pa() string {  
  panic("me")  
}  
func main() {  
  defer func() {  
    if r := recover(); r != nil {  
      fmt.Println(r)  // 输出:me  
    }  
  }()  
  p := pa()  // 此行panic抛出me字符串  
  fmt.Println(p)  // 此行不会执行  
}

defer的用法

defer关键字表示,当前这个函数在退出之前,执行一下defer后面的逻辑。相当于我们委托一些操作给Go语言,在函数退出之前执行,有点像Java和Python里面的finally作用了。

这样,我们就可以把一些一定要执行的操作,放在defer中了,比如,我们关闭某个已经打开的资源:

fsrc, err := os.Open("source.txt")  
if err != nil {  
  fmt.Println("open source file failed")  
  return  
}  
defer fsrc.Close()  // 第一个defer  
fdes, err := os.Open("target.txt")  
if err != nil {  
  fmt.Println("open target file failed")  
  return  
}  
defer fdes.Close()  // 第二个defer  
fmt.Println("do something here")

如果一个函数里面有多个defer,那么在函数推出之前,会先执行最后一个defer,然后再执行倒数第二个、倒数第三个...,就像后进先出栈的操作。

我们下一篇聊聊通道和goroutine。

喜欢的点个关注!感谢参考原文-http://bjbsair.com/2020-04-01/tech-info/18320.html

标准错误

Go语言内置的error接口,自定义的类型,只要实现该接口方法即可称为标准错误类型,来看看源码:

// The error built-in interface type is the conventional interface for  
// representing an error condition, with the nil value representing no error.  
type error interface {  
  Error() string  
}

自定义一个错误类型,实现error接口的Error()方法:

type MyError struct {  
  s string  
}  
func (myError MyError) Error() string {  
  return "MyError"  
}  
func main() {  
  var e MyError = MyError{"err"}  
  fmt.Println(e)  // 输出:MyError  
  err, ok := interface{}(e).(error)  
  fmt.Println(ok)  // 输出:true  
  fmt.Println(err)  // 输出:MyError  
}

从上面例子来看,err, ok := interface{}(e).(error)中的类型转换结果为true,说明自定义的类型就是error的子类型,也就证实了只要某个类型实现了Error()方法,那这个类型就是error类型。

errors包

Go语言的errors包有个内置的错误类型叫errorString,来看一下源码:

package errors  
  
  
// New returns an error that formats as the given text.  
// Each call to New returns a distinct error value even if the text is identical.  
func New(text string) error {  
  return &errorString{text}  
}  
  
  
// errorString is a trivial implementation of error.  
type errorString struct {  
  s string  
}  
  
  
func (e *errorString) Error() string {  
  return e.s  
}

从上面的源码看到,errorString类型实现了error接口的Error()方法,因此errorString类型就是error的子类型。

我们知道,当某个包下面的变量和方法名以小写开头时,这个变量或者方法只能在这个包下面才能访问。因此,我们自己写的代码没办法直接创建errorString的实例,我们可以使用errors里的New方法方便的创建error类型。

var e = errors.New("MyError")  
fmt.Println(e)  // 输出:MyError  
err, ok := interface{}(e).(error)  
fmt.Println(ok)  // 输出:true  
fmt.Println(err)  // 输出:MyError

和最上面的例子一样,err, ok := interface{}(e).(error)中的类型转换结果为true,说明errorString就是error的子类型。

创建标准错误

func f1(arg int) (int, error) {  
    if arg == 42 {  
        return -1, errors.New("can't work with 42")  // 使用错误提示创建标准错误  
    }  
    return arg + 3, nil  
}  
  
  
type argError struct {  
    arg  int  
    prob string  
}  
  
  
func (e *argError) Error() string {  // 自定义错误类型需要实现Error函数  
    return fmt.Sprintf("%d - %s", e.arg, e.prob)  
}  
func f2(arg int) (int, error) {  
    if arg == 42 {  
        return -1, &argError{arg, "can't work with it"}  
    }  
    return arg + 3, nil  
}  
func main() {  
    for _, i := range []int{7, 42} {  
        if r, e := f1(i); e != nil {  
            fmt.Println("f1 failed:", e)  // f1 failed: can't work with 42  
        } else {  
            fmt.Println("f1 worked:", r)  
        }  
    }  
    for _, i := range []int{7, 42} {  
        if r, e := f2(i); e != nil {  
            fmt.Println("f2 failed:", e)  
        } else {  
            fmt.Println("f2 worked:", r)  
        }  
    }  
    _, e := f2(42)  
    if ae, ok := e.(*argError); ok {  
        fmt.Println(ae.arg)  
        fmt.Println(ae.prob)  
    }  
}  

格式化消息的标准错误类型

fmt包中有个Errorf方法,我们可以通过它创建一个具有格式化字符串的标准错误类型,来看一下fmt.Errorf的源码:

func Errorf(format string, a ...interface{}) error {  
  p := newPrinter()  
  p.wrapErrs = true  
  p.doPrintf(format, a)  
  s := string(p.buf)  
  var err error  
  if p.wrappedErr == nil {  
    err = errors.New(s)  
  } else {  
    err = &wrapError{s, p.wrappedErr}  
  }  
  p.free()  
  return err  
}

可以看到,fmt.Errorf里面使用errors.New来创建error类型的实例,然后把格式化后字符串放入这个实例里面。典型使用案例:

const name, id = "bimmler", 17  
err := fmt.Errorf("user %q (id %d) not found", name, id)  // user="bimmler" (id=17) not found  
if err != nil {  
  fmt.Print(err)  
}

这样,err不仅包含了格式化的错误消息,而且还是error类型,比我们先用fmt.Printf再用errors.New的写法会更简洁。

天杀错误判断和处理逻辑

刚从其他语言转到Go语言时,会非常不习惯Go语言的错误处理逻辑。在Java和Python里面,我们可以使用throw来抛出异常,在另一个地方使用try...catch来捕获异常。而Go语言鼓励大家把错误放到返回值里面,但是呢,又提供了panic和recover来抛出和捕获异常。一般来说,我们把返回值里面返回的叫做错误(因为他们都是error类型),把抛出和捕获的叫做异常。

既然把错误放到返回值里,那我们就每次都需要判断返回里的错误是否为空,才能知道是不是正常返回了。判断和处理错误需要用到if,如果一段代码里面调用了很多函数,我们就能看到一连串的if,这种写法感觉简直就是疯了!

result1, err := err1()  
if err != nil {  
  fmt.Println(result1)  
}  
result2, err := err2()  
if err != nil {  
  fmt.Println(result2)  
}  
result3, err := err3()  
if err != nil {  
  fmt.Println(result3)  
}  
result4, err := err4()  
if err != nil {  
  fmt.Println(result4)  
}

不过这个没法避免,老老实实习惯一下吧!

panic/recover/defer

对于异常,Go语言可以使用panic来抛出一个恐慌性异常,一般来说,当程序遇到了比较大的问题,没有办法再执行下去,我们就用panic来抛出异常。来看一下panic源码:

func panic(v interface{})

panic接收一个interface{}类型的对象,我们上篇文章说过了,任何类型都是interface{}类型的子类型,因此,panic可以抛出任何对象。使用案例:

func main() {  
  panic("hello")  
}

输出:

panic: hello  
  
goroutine 1 [running]:  
main.main()  
    E:/goworkspace/blog/src/main/main.go:4 +0x40  

同时,我们可以使用recover来捕获那些被panic抛出对象:

func pa() string {  
  panic("me")  
}  
func main() {  
  p := pa()  
fmt.Println(p)  
if r := recover(); r != nil {  
   fmt.Println(r)  
  }  
}

输出:

panic: me  
  
goroutine 1 [running]:  
main.pa(...)  
    E:/goworkspace/blog/src/main/main.go:6  
main.main()  
    E:/goworkspace/blog/src/main/main.go:9 +0x40

怎么好像recover没起作用?这当然了,recover需要与defer一起使用,而且,recover的使用要放在panic抛出之前。下面的例子才对:

func pa() string {  
  panic("me")  
}  
func main() {  
  defer func() {  
    if r := recover(); r != nil {  
      fmt.Println(r)  // 输出:me  
    }  
  }()  
  p := pa()  // 此行panic抛出me字符串  
  fmt.Println(p)  // 此行不会执行  
}

defer的用法

defer关键字表示,当前这个函数在退出之前,执行一下defer后面的逻辑。相当于我们委托一些操作给Go语言,在函数退出之前执行,有点像Java和Python里面的finally作用了。

这样,我们就可以把一些一定要执行的操作,放在defer中了,比如,我们关闭某个已经打开的资源:

fsrc, err := os.Open("source.txt")  
if err != nil {  
  fmt.Println("open source file failed")  
  return  
}  
defer fsrc.Close()  // 第一个defer  
fdes, err := os.Open("target.txt")  
if err != nil {  
  fmt.Println("open target file failed")  
  return  
}  
defer fdes.Close()  // 第二个defer  
fmt.Println("do something here")

如果一个函数里面有多个defer,那么在函数推出之前,会先执行最后一个defer,然后再执行倒数第二个、倒数第三个...,就像后进先出栈的操作。

我们下一篇聊聊通道和goroutine。

喜欢的点个关注!感谢参考原文-http://bjbsair.com/2020-04-01/tech-info/18320.html

标准错误

Go语言内置的error接口,自定义的类型,只要实现该接口方法即可称为标准错误类型,来看看源码:

// The error built-in interface type is the conventional interface for  
// representing an error condition, with the nil value representing no error.  
type error interface {  
  Error() string  
}

自定义一个错误类型,实现error接口的Error()方法:

type MyError struct {  
  s string  
}  
func (myError MyError) Error() string {  
  return "MyError"  
}  
func main() {  
  var e MyError = MyError{"err"}  
  fmt.Println(e)  // 输出:MyError  
  err, ok := interface{}(e).(error)  
  fmt.Println(ok)  // 输出:true  
  fmt.Println(err)  // 输出:MyError  
}

从上面例子来看,err, ok := interface{}(e).(error)中的类型转换结果为true,说明自定义的类型就是error的子类型,也就证实了只要某个类型实现了Error()方法,那这个类型就是error类型。

errors包

Go语言的errors包有个内置的错误类型叫errorString,来看一下源码:

package errors  
  
  
// New returns an error that formats as the given text.  
// Each call to New returns a distinct error value even if the text is identical.  
func New(text string) error {  
  return &errorString{text}  
}  
  
  
// errorString is a trivial implementation of error.  
type errorString struct {  
  s string  
}  
  
  
func (e *errorString) Error() string {  
  return e.s  
}

从上面的源码看到,errorString类型实现了error接口的Error()方法,因此errorString类型就是error的子类型。

我们知道,当某个包下面的变量和方法名以小写开头时,这个变量或者方法只能在这个包下面才能访问。因此,我们自己写的代码没办法直接创建errorString的实例,我们可以使用errors里的New方法方便的创建error类型。

var e = errors.New("MyError")  
fmt.Println(e)  // 输出:MyError  
err, ok := interface{}(e).(error)  
fmt.Println(ok)  // 输出:true  
fmt.Println(err)  // 输出:MyError

和最上面的例子一样,err, ok := interface{}(e).(error)中的类型转换结果为true,说明errorString就是error的子类型。

创建标准错误

func f1(arg int) (int, error) {  
    if arg == 42 {  
        return -1, errors.New("can't work with 42")  // 使用错误提示创建标准错误  
    }  
    return arg + 3, nil  
}  
  
  
type argError struct {  
    arg  int  
    prob string  
}  
  
  
func (e *argError) Error() string {  // 自定义错误类型需要实现Error函数  
    return fmt.Sprintf("%d - %s", e.arg, e.prob)  
}  
func f2(arg int) (int, error) {  
    if arg == 42 {  
        return -1, &argError{arg, "can't work with it"}  
    }  
    return arg + 3, nil  
}  
func main() {  
    for _, i := range []int{7, 42} {  
        if r, e := f1(i); e != nil {  
            fmt.Println("f1 failed:", e)  // f1 failed: can't work with 42  
        } else {  
            fmt.Println("f1 worked:", r)  
        }  
    }  
    for _, i := range []int{7, 42} {  
        if r, e := f2(i); e != nil {  
            fmt.Println("f2 failed:", e)  
        } else {  
            fmt.Println("f2 worked:", r)  
        }  
    }  
    _, e := f2(42)  
    if ae, ok := e.(*argError); ok {  
        fmt.Println(ae.arg)  
        fmt.Println(ae.prob)  
    }  
}  

格式化消息的标准错误类型

fmt包中有个Errorf方法,我们可以通过它创建一个具有格式化字符串的标准错误类型,来看一下fmt.Errorf的源码:

func Errorf(format string, a ...interface{}) error {  
  p := newPrinter()  
  p.wrapErrs = true  
  p.doPrintf(format, a)  
  s := string(p.buf)  
  var err error  
  if p.wrappedErr == nil {  
    err = errors.New(s)  
  } else {  
    err = &wrapError{s, p.wrappedErr}  
  }  
  p.free()  
  return err  
}

可以看到,fmt.Errorf里面使用errors.New来创建error类型的实例,然后把格式化后字符串放入这个实例里面。典型使用案例:

const name, id = "bimmler", 17  
err := fmt.Errorf("user %q (id %d) not found", name, id)  // user="bimmler" (id=17) not found  
if err != nil {  
  fmt.Print(err)  
}

这样,err不仅包含了格式化的错误消息,而且还是error类型,比我们先用fmt.Printf再用errors.New的写法会更简洁。

天杀错误判断和处理逻辑

刚从其他语言转到Go语言时,会非常不习惯Go语言的错误处理逻辑。在Java和Python里面,我们可以使用throw来抛出异常,在另一个地方使用try...catch来捕获异常。而Go语言鼓励大家把错误放到返回值里面,但是呢,又提供了panic和recover来抛出和捕获异常。一般来说,我们把返回值里面返回的叫做错误(因为他们都是error类型),把抛出和捕获的叫做异常。

既然把错误放到返回值里,那我们就每次都需要判断返回里的错误是否为空,才能知道是不是正常返回了。判断和处理错误需要用到if,如果一段代码里面调用了很多函数,我们就能看到一连串的if,这种写法感觉简直就是疯了!

result1, err := err1()  
if err != nil {  
  fmt.Println(result1)  
}  
result2, err := err2()  
if err != nil {  
  fmt.Println(result2)  
}  
result3, err := err3()  
if err != nil {  
  fmt.Println(result3)  
}  
result4, err := err4()  
if err != nil {  
  fmt.Println(result4)  
}

不过这个没法避免,老老实实习惯一下吧!

panic/recover/defer

对于异常,Go语言可以使用panic来抛出一个恐慌性异常,一般来说,当程序遇到了比较大的问题,没有办法再执行下去,我们就用panic来抛出异常。来看一下panic源码:

func panic(v interface{})

panic接收一个interface{}类型的对象,我们上篇文章说过了,任何类型都是interface{}类型的子类型,因此,panic可以抛出任何对象。使用案例:

func main() {  
  panic("hello")  
}

输出:

panic: hello  
  
goroutine 1 [running]:  
main.main()  
    E:/goworkspace/blog/src/main/main.go:4 +0x40  

同时,我们可以使用recover来捕获那些被panic抛出对象:

func pa() string {  
  panic("me")  
}  
func main() {  
  p := pa()  
fmt.Println(p)  
if r := recover(); r != nil {  
   fmt.Println(r)  
  }  
}

输出:

panic: me  
  
goroutine 1 [running]:  
main.pa(...)  
    E:/goworkspace/blog/src/main/main.go:6  
main.main()  
    E:/goworkspace/blog/src/main/main.go:9 +0x40

怎么好像recover没起作用?这当然了,recover需要与defer一起使用,而且,recover的使用要放在panic抛出之前。下面的例子才对:

func pa() string {  
  panic("me")  
}  
func main() {  
  defer func() {  
    if r := recover(); r != nil {  
      fmt.Println(r)  // 输出:me  
    }  
  }()  
  p := pa()  // 此行panic抛出me字符串  
  fmt.Println(p)  // 此行不会执行  
}

defer的用法

defer关键字表示,当前这个函数在退出之前,执行一下defer后面的逻辑。相当于我们委托一些操作给Go语言,在函数退出之前执行,有点像Java和Python里面的finally作用了。

这样,我们就可以把一些一定要执行的操作,放在defer中了,比如,我们关闭某个已经打开的资源:

fsrc, err := os.Open("source.txt")  
if err != nil {  
  fmt.Println("open source file failed")  
  return  
}  
defer fsrc.Close()  // 第一个defer  
fdes, err := os.Open("target.txt")  
if err != nil {  
  fmt.Println("open target file failed")  
  return  
}  
defer fdes.Close()  // 第二个defer  
fmt.Println("do something here")

如果一个函数里面有多个defer,那么在函数推出之前,会先执行最后一个defer,然后再执行倒数第二个、倒数第三个...,就像后进先出栈的操作。

我们下一篇聊聊通道和goroutine。

喜欢的点个关注!感谢参考原文-http://bjbsair.com/2020-04-01/tech-info/18320.html

标准错误

Go语言内置的error接口,自定义的类型,只要实现该接口方法即可称为标准错误类型,来看看源码:

// The error built-in interface type is the conventional interface for  
// representing an error condition, with the nil value representing no error.  
type error interface {  
  Error() string  
}

自定义一个错误类型,实现error接口的Error()方法:

type MyError struct {  
  s string  
}  
func (myError MyError) Error() string {  
  return "MyError"  
}  
func main() {  
  var e MyError = MyError{"err"}  
  fmt.Println(e)  // 输出:MyError  
  err, ok := interface{}(e).(error)  
  fmt.Println(ok)  // 输出:true  
  fmt.Println(err)  // 输出:MyError  
}

从上面例子来看,err, ok := interface{}(e).(error)中的类型转换结果为true,说明自定义的类型就是error的子类型,也就证实了只要某个类型实现了Error()方法,那这个类型就是error类型。

errors包

Go语言的errors包有个内置的错误类型叫errorString,来看一下源码:

package errors  
  
  
// New returns an error that formats as the given text.  
// Each call to New returns a distinct error value even if the text is identical.  
func New(text string) error {  
  return &errorString{text}  
}  
  
  
// errorString is a trivial implementation of error.  
type errorString struct {  
  s string  
}  
  
  
func (e *errorString) Error() string {  
  return e.s  
}

从上面的源码看到,errorString类型实现了error接口的Error()方法,因此errorString类型就是error的子类型。

我们知道,当某个包下面的变量和方法名以小写开头时,这个变量或者方法只能在这个包下面才能访问。因此,我们自己写的代码没办法直接创建errorString的实例,我们可以使用errors里的New方法方便的创建error类型。

var e = errors.New("MyError")  
fmt.Println(e)  // 输出:MyError  
err, ok := interface{}(e).(error)  
fmt.Println(ok)  // 输出:true  
fmt.Println(err)  // 输出:MyError

和最上面的例子一样,err, ok := interface{}(e).(error)中的类型转换结果为true,说明errorString就是error的子类型。

创建标准错误

func f1(arg int) (int, error) {  
    if arg == 42 {  
        return -1, errors.New("can't work with 42")  // 使用错误提示创建标准错误  
    }  
    return arg + 3, nil  
}  
  
  
type argError struct {  
    arg  int  
    prob string  
}  
  
  
func (e *argError) Error() string {  // 自定义错误类型需要实现Error函数  
    return fmt.Sprintf("%d - %s", e.arg, e.prob)  
}  
func f2(arg int) (int, error) {  
    if arg == 42 {  
        return -1, &argError{arg, "can't work with it"}  
    }  
    return arg + 3, nil  
}  
func main() {  
    for _, i := range []int{7, 42} {  
        if r, e := f1(i); e != nil {  
            fmt.Println("f1 failed:", e)  // f1 failed: can't work with 42  
        } else {  
            fmt.Println("f1 worked:", r)  
        }  
    }  
    for _, i := range []int{7, 42} {  
        if r, e := f2(i); e != nil {  
            fmt.Println("f2 failed:", e)  
        } else {  
            fmt.Println("f2 worked:", r)  
        }  
    }  
    _, e := f2(42)  
    if ae, ok := e.(*argError); ok {  
        fmt.Println(ae.arg)  
        fmt.Println(ae.prob)  
    }  
}  

格式化消息的标准错误类型

fmt包中有个Errorf方法,我们可以通过它创建一个具有格式化字符串的标准错误类型,来看一下fmt.Errorf的源码:

func Errorf(format string, a ...interface{}) error {  
  p := newPrinter()  
  p.wrapErrs = true  
  p.doPrintf(format, a)  
  s := string(p.buf)  
  var err error  
  if p.wrappedErr == nil {  
    err = errors.New(s)  
  } else {  
    err = &wrapError{s, p.wrappedErr}  
  }  
  p.free()  
  return err  
}

可以看到,fmt.Errorf里面使用errors.New来创建error类型的实例,然后把格式化后字符串放入这个实例里面。典型使用案例:

const name, id = "bimmler", 17  
err := fmt.Errorf("user %q (id %d) not found", name, id)  // user="bimmler" (id=17) not found  
if err != nil {  
  fmt.Print(err)  
}

这样,err不仅包含了格式化的错误消息,而且还是error类型,比我们先用fmt.Printf再用errors.New的写法会更简洁。

天杀错误判断和处理逻辑

刚从其他语言转到Go语言时,会非常不习惯Go语言的错误处理逻辑。在Java和Python里面,我们可以使用throw来抛出异常,在另一个地方使用try...catch来捕获异常。而Go语言鼓励大家把错误放到返回值里面,但是呢,又提供了panic和recover来抛出和捕获异常。一般来说,我们把返回值里面返回的叫做错误(因为他们都是error类型),把抛出和捕获的叫做异常。

既然把错误放到返回值里,那我们就每次都需要判断返回里的错误是否为空,才能知道是不是正常返回了。判断和处理错误需要用到if,如果一段代码里面调用了很多函数,我们就能看到一连串的if,这种写法感觉简直就是疯了!

result1, err := err1()  
if err != nil {  
  fmt.Println(result1)  
}  
result2, err := err2()  
if err != nil {  
  fmt.Println(result2)  
}  
result3, err := err3()  
if err != nil {  
  fmt.Println(result3)  
}  
result4, err := err4()  
if err != nil {  
  fmt.Println(result4)  
}

不过这个没法避免,老老实实习惯一下吧!

panic/recover/defer

对于异常,Go语言可以使用panic来抛出一个恐慌性异常,一般来说,当程序遇到了比较大的问题,没有办法再执行下去,我们就用panic来抛出异常。来看一下panic源码:

func panic(v interface{})

panic接收一个interface{}类型的对象,我们上篇文章说过了,任何类型都是interface{}类型的子类型,因此,panic可以抛出任何对象。使用案例:

func main() {  
  panic("hello")  
}

输出:

panic: hello  
  
goroutine 1 [running]:  
main.main()  
    E:/goworkspace/blog/src/main/main.go:4 +0x40  

同时,我们可以使用recover来捕获那些被panic抛出对象:

func pa() string {  
  panic("me")  
}  
func main() {  
  p := pa()  
fmt.Println(p)  
if r := recover(); r != nil {  
   fmt.Println(r)  
  }  
}

输出:

panic: me  
  
goroutine 1 [running]:  
main.pa(...)  
    E:/goworkspace/blog/src/main/main.go:6  
main.main()  
    E:/goworkspace/blog/src/main/main.go:9 +0x40

怎么好像recover没起作用?这当然了,recover需要与defer一起使用,而且,recover的使用要放在panic抛出之前。下面的例子才对:

func pa() string {  
  panic("me")  
}  
func main() {  
  defer func() {  
    if r := recover(); r != nil {  
      fmt.Println(r)  // 输出:me  
    }  
  }()  
  p := pa()  // 此行panic抛出me字符串  
  fmt.Println(p)  // 此行不会执行  
}

defer的用法

defer关键字表示,当前这个函数在退出之前,执行一下defer后面的逻辑。相当于我们委托一些操作给Go语言,在函数退出之前执行,有点像Java和Python里面的finally作用了。

这样,我们就可以把一些一定要执行的操作,放在defer中了,比如,我们关闭某个已经打开的资源:

fsrc, err := os.Open("source.txt")  
if err != nil {  
  fmt.Println("open source file failed")  
  return  
}  
defer fsrc.Close()  // 第一个defer  
fdes, err := os.Open("target.txt")  
if err != nil {  
  fmt.Println("open target file failed")  
  return  
}  
defer fdes.Close()  // 第二个defer  
fmt.Println("do something here")

如果一个函数里面有多个defer,那么在函数推出之前,会先执行最后一个defer,然后再执行倒数第二个、倒数第三个...,就像后进先出栈的操作。

我们下一篇聊聊通道和goroutine。

喜欢的点个关注!感谢参考原文-http://bjbsair.com/2020-04-01/tech-info/18320.html

标准错误

Go语言内置的error接口,自定义的类型,只要实现该接口方法即可称为标准错误类型,来看看源码:

// The error built-in interface type is the conventional interface for  
// representing an error condition, with the nil value representing no error.  
type error interface {  
  Error() string  
}

自定义一个错误类型,实现error接口的Error()方法:

type MyError struct {  
  s string  
}  
func (myError MyError) Error() string {  
  return "MyError"  
}  
func main() {  
  var e MyError = MyError{"err"}  
  fmt.Println(e)  // 输出:MyError  
  err, ok := interface{}(e).(error)  
  fmt.Println(ok)  // 输出:true  
  fmt.Println(err)  // 输出:MyError  
}

从上面例子来看,err, ok := interface{}(e).(error)中的类型转换结果为true,说明自定义的类型就是error的子类型,也就证实了只要某个类型实现了Error()方法,那这个类型就是error类型。

errors包

Go语言的errors包有个内置的错误类型叫errorString,来看一下源码:

package errors  
  
  
// New returns an error that formats as the given text.  
// Each call to New returns a distinct error value even if the text is identical.  
func New(text string) error {  
  return &errorString{text}  
}  
  
  
// errorString is a trivial implementation of error.  
type errorString struct {  
  s string  
}  
  
  
func (e *errorString) Error() string {  
  return e.s  
}

从上面的源码看到,errorString类型实现了error接口的Error()方法,因此errorString类型就是error的子类型。

我们知道,当某个包下面的变量和方法名以小写开头时,这个变量或者方法只能在这个包下面才能访问。因此,我们自己写的代码没办法直接创建errorString的实例,我们可以使用errors里的New方法方便的创建error类型。

var e = errors.New("MyError")  
fmt.Println(e)  // 输出:MyError  
err, ok := interface{}(e).(error)  
fmt.Println(ok)  // 输出:true  
fmt.Println(err)  // 输出:MyError

和最上面的例子一样,err, ok := interface{}(e).(error)中的类型转换结果为true,说明errorString就是error的子类型。

创建标准错误

func f1(arg int) (int, error) {  
    if arg == 42 {  
        return -1, errors.New("can't work with 42")  // 使用错误提示创建标准错误  
    }  
    return arg + 3, nil  
}  
  
  
type argError struct {  
    arg  int  
    prob string  
}  
  
  
func (e *argError) Error() string {  // 自定义错误类型需要实现Error函数  
    return fmt.Sprintf("%d - %s", e.arg, e.prob)  
}  
func f2(arg int) (int, error) {  
    if arg == 42 {  
        return -1, &argError{arg, "can't work with it"}  
    }  
    return arg + 3, nil  
}  
func main() {  
    for _, i := range []int{7, 42} {  
        if r, e := f1(i); e != nil {  
            fmt.Println("f1 failed:", e)  // f1 failed: can't work with 42  
        } else {  
            fmt.Println("f1 worked:", r)  
        }  
    }  
    for _, i := range []int{7, 42} {  
        if r, e := f2(i); e != nil {  
            fmt.Println("f2 failed:", e)  
        } else {  
            fmt.Println("f2 worked:", r)  
        }  
    }  
    _, e := f2(42)  
    if ae, ok := e.(*argError); ok {  
        fmt.Println(ae.arg)  
        fmt.Println(ae.prob)  
    }  
}  

格式化消息的标准错误类型

fmt包中有个Errorf方法,我们可以通过它创建一个具有格式化字符串的标准错误类型,来看一下fmt.Errorf的源码:

func Errorf(format string, a ...interface{}) error {  
  p := newPrinter()  
  p.wrapErrs = true  
  p.doPrintf(format, a)  
  s := string(p.buf)  
  var err error  
  if p.wrappedErr == nil {  
    err = errors.New(s)  
  } else {  
    err = &wrapError{s, p.wrappedErr}  
  }  
  p.free()  
  return err  
}

可以看到,fmt.Errorf里面使用errors.New来创建error类型的实例,然后把格式化后字符串放入这个实例里面。典型使用案例:

const name, id = "bimmler", 17  
err := fmt.Errorf("user %q (id %d) not found", name, id)  // user="bimmler" (id=17) not found  
if err != nil {  
  fmt.Print(err)  
}

这样,err不仅包含了格式化的错误消息,而且还是error类型,比我们先用fmt.Printf再用errors.New的写法会更简洁。

天杀错误判断和处理逻辑

刚从其他语言转到Go语言时,会非常不习惯Go语言的错误处理逻辑。在Java和Python里面,我们可以使用throw来抛出异常,在另一个地方使用try...catch来捕获异常。而Go语言鼓励大家把错误放到返回值里面,但是呢,又提供了panic和recover来抛出和捕获异常。一般来说,我们把返回值里面返回的叫做错误(因为他们都是error类型),把抛出和捕获的叫做异常。

既然把错误放到返回值里,那我们就每次都需要判断返回里的错误是否为空,才能知道是不是正常返回了。判断和处理错误需要用到if,如果一段代码里面调用了很多函数,我们就能看到一连串的if,这种写法感觉简直就是疯了!

result1, err := err1()  
if err != nil {  
  fmt.Println(result1)  
}  
result2, err := err2()  
if err != nil {  
  fmt.Println(result2)  
}  
result3, err := err3()  
if err != nil {  
  fmt.Println(result3)  
}  
result4, err := err4()  
if err != nil {  
  fmt.Println(result4)  
}

不过这个没法避免,老老实实习惯一下吧!

panic/recover/defer

对于异常,Go语言可以使用panic来抛出一个恐慌性异常,一般来说,当程序遇到了比较大的问题,没有办法再执行下去,我们就用panic来抛出异常。来看一下panic源码:

func panic(v interface{})

panic接收一个interface{}类型的对象,我们上篇文章说过了,任何类型都是interface{}类型的子类型,因此,panic可以抛出任何对象。使用案例:

func main() {  
  panic("hello")  
}

输出:

panic: hello  
  
goroutine 1 [running]:  
main.main()  
    E:/goworkspace/blog/src/main/main.go:4 +0x40  

同时,我们可以使用recover来捕获那些被panic抛出对象:

func pa() string {  
  panic("me")  
}  
func main() {  
  p := pa()  
fmt.Println(p)  
if r := recover(); r != nil {  
   fmt.Println(r)  
  }  
}

输出:

panic: me  
  
goroutine 1 [running]:  
main.pa(...)  
    E:/goworkspace/blog/src/main/main.go:6  
main.main()  
    E:/goworkspace/blog/src/main/main.go:9 +0x40

怎么好像recover没起作用?这当然了,recover需要与defer一起使用,而且,recover的使用要放在panic抛出之前。下面的例子才对:

func pa() string {  
  panic("me")  
}  
func main() {  
  defer func() {  
    if r := recover(); r != nil {  
      fmt.Println(r)  // 输出:me  
    }  
  }()  
  p := pa()  // 此行panic抛出me字符串  
  fmt.Println(p)  // 此行不会执行  
}

defer的用法

defer关键字表示,当前这个函数在退出之前,执行一下defer后面的逻辑。相当于我们委托一些操作给Go语言,在函数退出之前执行,有点像Java和Python里面的finally作用了。

这样,我们就可以把一些一定要执行的操作,放在defer中了,比如,我们关闭某个已经打开的资源:

fsrc, err := os.Open("source.txt")  
if err != nil {  
  fmt.Println("open source file failed")  
  return  
}  
defer fsrc.Close()  // 第一个defer  
fdes, err := os.Open("target.txt")  
if err != nil {  
  fmt.Println("open target file failed")  
  return  
}  
defer fdes.Close()  // 第二个defer  
fmt.Println("do something here")

如果一个函数里面有多个defer,那么在函数推出之前,会先执行最后一个defer,然后再执行倒数第二个、倒数第三个...,就像后进先出栈的操作。

我们下一篇聊聊通道和goroutine。

喜欢的点个关注!感谢参考原文-http://bjbsair.com/2020-04-01/tech-info/18320.html

标准错误

Go语言内置的error接口,自定义的类型,只要实现该接口方法即可称为标准错误类型,来看看源码:

// The error built-in interface type is the conventional interface for  
// representing an error condition, with the nil value representing no error.  
type error interface {  
  Error() string  
}

自定义一个错误类型,实现error接口的Error()方法:

type MyError struct {  
  s string  
}  
func (myError MyError) Error() string {  
  return "MyError"  
}  
func main() {  
  var e MyError = MyError{"err"}  
  fmt.Println(e)  // 输出:MyError  
  err, ok := interface{}(e).(error)  
  fmt.Println(ok)  // 输出:true  
  fmt.Println(err)  // 输出:MyError  
}

从上面例子来看,err, ok := interface{}(e).(error)中的类型转换结果为true,说明自定义的类型就是error的子类型,也就证实了只要某个类型实现了Error()方法,那这个类型就是error类型。

errors包

Go语言的errors包有个内置的错误类型叫errorString,来看一下源码:

package errors  
  
  
// New returns an error that formats as the given text.  
// Each call to New returns a distinct error value even if the text is identical.  
func New(text string) error {  
  return &errorString{text}  
}  
  
  
// errorString is a trivial implementation of error.  
type errorString struct {  
  s string  
}  
  
  
func (e *errorString) Error() string {  
  return e.s  
}

从上面的源码看到,errorString类型实现了error接口的Error()方法,因此errorString类型就是error的子类型。

我们知道,当某个包下面的变量和方法名以小写开头时,这个变量或者方法只能在这个包下面才能访问。因此,我们自己写的代码没办法直接创建errorString的实例,我们可以使用errors里的New方法方便的创建error类型。

var e = errors.New("MyError")  
fmt.Println(e)  // 输出:MyError  
err, ok := interface{}(e).(error)  
fmt.Println(ok)  // 输出:true  
fmt.Println(err)  // 输出:MyError

和最上面的例子一样,err, ok := interface{}(e).(error)中的类型转换结果为true,说明errorString就是error的子类型。

创建标准错误

func f1(arg int) (int, error) {  
    if arg == 42 {  
        return -1, errors.New("can't work with 42")  // 使用错误提示创建标准错误  
    }  
    return arg + 3, nil  
}  
  
  
type argError struct {  
    arg  int  
    prob string  
}  
  
  
func (e *argError) Error() string {  // 自定义错误类型需要实现Error函数  
    return fmt.Sprintf("%d - %s", e.arg, e.prob)  
}  
func f2(arg int) (int, error) {  
    if arg == 42 {  
        return -1, &argError{arg, "can't work with it"}  
    }  
    return arg + 3, nil  
}  
func main() {  
    for _, i := range []int{7, 42} {  
        if r, e := f1(i); e != nil {  
            fmt.Println("f1 failed:", e)  // f1 failed: can't work with 42  
        } else {  
            fmt.Println("f1 worked:", r)  
        }  
    }  
    for _, i := range []int{7, 42} {  
        if r, e := f2(i); e != nil {  
            fmt.Println("f2 failed:", e)  
        } else {  
            fmt.Println("f2 worked:", r)  
        }  
    }  
    _, e := f2(42)  
    if ae, ok := e.(*argError); ok {  
        fmt.Println(ae.arg)  
        fmt.Println(ae.prob)  
    }  
}  

格式化消息的标准错误类型

fmt包中有个Errorf方法,我们可以通过它创建一个具有格式化字符串的标准错误类型,来看一下fmt.Errorf的源码:

func Errorf(format string, a ...interface{}) error {  
  p := newPrinter()  
  p.wrapErrs = true  
  p.doPrintf(format, a)  
  s := string(p.buf)  
  var err error  
  if p.wrappedErr == nil {  
    err = errors.New(s)  
  } else {  
    err = &wrapError{s, p.wrappedErr}  
  }  
  p.free()  
  return err  
}

可以看到,fmt.Errorf里面使用errors.New来创建error类型的实例,然后把格式化后字符串放入这个实例里面。典型使用案例:

const name, id = "bimmler", 17  
err := fmt.Errorf("user %q (id %d) not found", name, id)  // user="bimmler" (id=17) not found  
if err != nil {  
  fmt.Print(err)  
}

这样,err不仅包含了格式化的错误消息,而且还是error类型,比我们先用fmt.Printf再用errors.New的写法会更简洁。

天杀错误判断和处理逻辑

刚从其他语言转到Go语言时,会非常不习惯Go语言的错误处理逻辑。在Java和Python里面,我们可以使用throw来抛出异常,在另一个地方使用try...catch来捕获异常。而Go语言鼓励大家把错误放到返回值里面,但是呢,又提供了panic和recover来抛出和捕获异常。一般来说,我们把返回值里面返回的叫做错误(因为他们都是error类型),把抛出和捕获的叫做异常。

既然把错误放到返回值里,那我们就每次都需要判断返回里的错误是否为空,才能知道是不是正常返回了。判断和处理错误需要用到if,如果一段代码里面调用了很多函数,我们就能看到一连串的if,这种写法感觉简直就是疯了!

result1, err := err1()  
if err != nil {  
  fmt.Println(result1)  
}  
result2, err := err2()  
if err != nil {  
  fmt.Println(result2)  
}  
result3, err := err3()  
if err != nil {  
  fmt.Println(result3)  
}  
result4, err := err4()  
if err != nil {  
  fmt.Println(result4)  
}

不过这个没法避免,老老实实习惯一下吧!

panic/recover/defer

对于异常,Go语言可以使用panic来抛出一个恐慌性异常,一般来说,当程序遇到了比较大的问题,没有办法再执行下去,我们就用panic来抛出异常。来看一下panic源码:

func panic(v interface{})

panic接收一个interface{}类型的对象,我们上篇文章说过了,任何类型都是interface{}类型的子类型,因此,panic可以抛出任何对象。使用案例:

func main() {  
  panic("hello")  
}

输出:

panic: hello  
  
goroutine 1 [running]:  
main.main()  
    E:/goworkspace/blog/src/main/main.go:4 +0x40  

同时,我们可以使用recover来捕获那些被panic抛出对象:

func pa() string {  
  panic("me")  
}  
func main() {  
  p := pa()  
fmt.Println(p)  
if r := recover(); r != nil {  
   fmt.Println(r)  
  }  
}

输出:

panic: me  
  
goroutine 1 [running]:  
main.pa(...)  
    E:/goworkspace/blog/src/main/main.go:6  
main.main()  
    E:/goworkspace/blog/src/main/main.go:9 +0x40

怎么好像recover没起作用?这当然了,recover需要与defer一起使用,而且,recover的使用要放在panic抛出之前。下面的例子才对:

func pa() string {  
  panic("me")  
}  
func main() {  
  defer func() {  
    if r := recover(); r != nil {  
      fmt.Println(r)  // 输出:me  
    }  
  }()  
  p := pa()  // 此行panic抛出me字符串  
  fmt.Println(p)  // 此行不会执行  
}

defer的用法

defer关键字表示,当前这个函数在退出之前,执行一下defer后面的逻辑。相当于我们委托一些操作给Go语言,在函数退出之前执行,有点像Java和Python里面的finally作用了。

这样,我们就可以把一些一定要执行的操作,放在defer中了,比如,我们关闭某个已经打开的资源:

fsrc, err := os.Open("source.txt")  
if err != nil {  
  fmt.Println("open source file failed")  
  return  
}  
defer fsrc.Close()  // 第一个defer  
fdes, err := os.Open("target.txt")  
if err != nil {  
  fmt.Println("open target file failed")  
  return  
}  
defer fdes.Close()  // 第二个defer  
fmt.Println("do something here")

如果一个函数里面有多个defer,那么在函数推出之前,会先执行最后一个defer,然后再执行倒数第二个、倒数第三个...,就像后进先出栈的操作。

我们下一篇聊聊通道和goroutine。

喜欢的点个关注!感谢参考原文-http://bjbsair.com/2020-04-01/tech-info/18320.html

标准错误

Go语言内置的error接口,自定义的类型,只要实现该接口方法即可称为标准错误类型,来看看源码:

// The error built-in interface type is the conventional interface for  
// representing an error condition, with the nil value representing no error.  
type error interface {  
  Error() string  
}

自定义一个错误类型,实现error接口的Error()方法:

type MyError struct {  
  s string  
}  
func (myError MyError) Error() string {  
  return "MyError"  
}  
func main() {  
  var e MyError = MyError{"err"}  
  fmt.Println(e)  // 输出:MyError  
  err, ok := interface{}(e).(error)  
  fmt.Println(ok)  // 输出:true  
  fmt.Println(err)  // 输出:MyError  
}

从上面例子来看,err, ok := interface{}(e).(error)中的类型转换结果为true,说明自定义的类型就是error的子类型,也就证实了只要某个类型实现了Error()方法,那这个类型就是error类型。

errors包

Go语言的errors包有个内置的错误类型叫errorString,来看一下源码:

package errors  
  
  
// New returns an error that formats as the given text.  
// Each call to New returns a distinct error value even if the text is identical.  
func New(text string) error {  
  return &errorString{text}  
}  
  
  
// errorString is a trivial implementation of error.  
type errorString struct {  
  s string  
}  
  
  
func (e *errorString) Error() string {  
  return e.s  
}

从上面的源码看到,errorString类型实现了error接口的Error()方法,因此errorString类型就是error的子类型。

我们知道,当某个包下面的变量和方法名以小写开头时,这个变量或者方法只能在这个包下面才能访问。因此,我们自己写的代码没办法直接创建errorString的实例,我们可以使用errors里的New方法方便的创建error类型。

var e = errors.New("MyError")  
fmt.Println(e)  // 输出:MyError  
err, ok := interface{}(e).(error)  
fmt.Println(ok)  // 输出:true  
fmt.Println(err)  // 输出:MyError

和最上面的例子一样,err, ok := interface{}(e).(error)中的类型转换结果为true,说明errorString就是error的子类型。

创建标准错误

func f1(arg int) (int, error) {  
    if arg == 42 {  
        return -1, errors.New("can't work with 42")  // 使用错误提示创建标准错误  
    }  
    return arg + 3, nil  
}  
  
  
type argError struct {  
    arg  int  
    prob string  
}  
  
  
func (e *argError) Error() string {  // 自定义错误类型需要实现Error函数  
    return fmt.Sprintf("%d - %s", e.arg, e.prob)  
}  
func f2(arg int) (int, error) {  
    if arg == 42 {  
        return -1, &argError{arg, "can't work with it"}  
    }  
    return arg + 3, nil  
}  
func main() {  
    for _, i := range []int{7, 42} {  
        if r, e := f1(i); e != nil {  
            fmt.Println("f1 failed:", e)  // f1 failed: can't work with 42  
        } else {  
            fmt.Println("f1 worked:", r)  
        }  
    }  
    for _, i := range []int{7, 42} {  
        if r, e := f2(i); e != nil {  
            fmt.Println("f2 failed:", e)  
        } else {  
            fmt.Println("f2 worked:", r)  
        }  
    }  
    _, e := f2(42)  
    if ae, ok := e.(*argError); ok {  
        fmt.Println(ae.arg)  
        fmt.Println(ae.prob)  
    }  
}  

格式化消息的标准错误类型

fmt包中有个Errorf方法,我们可以通过它创建一个具有格式化字符串的标准错误类型,来看一下fmt.Errorf的源码:

func Errorf(format string, a ...interface{}) error {  
  p := newPrinter()  
  p.wrapErrs = true  
  p.doPrintf(format, a)  
  s := string(p.buf)  
  var err error  
  if p.wrappedErr == nil {  
    err = errors.New(s)  
  } else {  
    err = &wrapError{s, p.wrappedErr}  
  }  
  p.free()  
  return err  
}

可以看到,fmt.Errorf里面使用errors.New来创建error类型的实例,然后把格式化后字符串放入这个实例里面。典型使用案例:

const name, id = "bimmler", 17  
err := fmt.Errorf("user %q (id %d) not found", name, id)  // user="bimmler" (id=17) not found  
if err != nil {  
  fmt.Print(err)  
}

这样,err不仅包含了格式化的错误消息,而且还是error类型,比我们先用fmt.Printf再用errors.New的写法会更简洁。

天杀错误判断和处理逻辑

刚从其他语言转到Go语言时,会非常不习惯Go语言的错误处理逻辑。在Java和Python里面,我们可以使用throw来抛出异常,在另一个地方使用try...catch来捕获异常。而Go语言鼓励大家把错误放到返回值里面,但是呢,又提供了panic和recover来抛出和捕获异常。一般来说,我们把返回值里面返回的叫做错误(因为他们都是error类型),把抛出和捕获的叫做异常。

既然把错误放到返回值里,那我们就每次都需要判断返回里的错误是否为空,才能知道是不是正常返回了。判断和处理错误需要用到if,如果一段代码里面调用了很多函数,我们就能看到一连串的if,这种写法感觉简直就是疯了!

result1, err := err1()  
if err != nil {  
  fmt.Println(result1)  
}  
result2, err := err2()  
if err != nil {  
  fmt.Println(result2)  
}  
result3, err := err3()  
if err != nil {  
  fmt.Println(result3)  
}  
result4, err := err4()  
if err != nil {  
  fmt.Println(result4)  
}

不过这个没法避免,老老实实习惯一下吧!

panic/recover/defer

对于异常,Go语言可以使用panic来抛出一个恐慌性异常,一般来说,当程序遇到了比较大的问题,没有办法再执行下去,我们就用panic来抛出异常。来看一下panic源码:

func panic(v interface{})

panic接收一个interface{}类型的对象,我们上篇文章说过了,任何类型都是interface{}类型的子类型,因此,panic可以抛出任何对象。使用案例:

func main() {  
  panic("hello")  
}

输出:

panic: hello  
  
goroutine 1 [running]:  
main.main()  
    E:/goworkspace/blog/src/main/main.go:4 +0x40  

同时,我们可以使用recover来捕获那些被panic抛出对象:

func pa() string {  
  panic("me")  
}  
func main() {  
  p := pa()  
fmt.Println(p)  
if r := recover(); r != nil {  
   fmt.Println(r)  
  }  
}

输出:

panic: me  
  
goroutine 1 [running]:  
main.pa(...)  
    E:/goworkspace/blog/src/main/main.go:6  
main.main()  
    E:/goworkspace/blog/src/main/main.go:9 +0x40

怎么好像recover没起作用?这当然了,recover需要与defer一起使用,而且,recover的使用要放在panic抛出之前。下面的例子才对:

func pa() string {  
  panic("me")  
}  
func main() {  
  defer func() {  
    if r := recover(); r != nil {  
      fmt.Println(r)  // 输出:me  
    }  
  }()  
  p := pa()  // 此行panic抛出me字符串  
  fmt.Println(p)  // 此行不会执行  
}

defer的用法

defer关键字表示,当前这个函数在退出之前,执行一下defer后面的逻辑。相当于我们委托一些操作给Go语言,在函数退出之前执行,有点像Java和Python里面的finally作用了。

这样,我们就可以把一些一定要执行的操作,放在defer中了,比如,我们关闭某个已经打开的资源:

fsrc, err := os.Open("source.txt")  
if err != nil {  
  fmt.Println("open source file failed")  
  return  
}  
defer fsrc.Close()  // 第一个defer  
fdes, err := os.Open("target.txt")  
if err != nil {  
  fmt.Println("open target file failed")  
  return  
}  
defer fdes.Close()  // 第二个defer  
fmt.Println("do something here")

如果一个函数里面有多个defer,那么在函数推出之前,会先执行最后一个defer,然后再执行倒数第二个、倒数第三个...,就像后进先出栈的操作。

我们下一篇聊聊通道和goroutine。

喜欢的点个关注!感谢参考原文-http://bjbsair.com/2020-04-01/tech-info/18320.html

标准错误

Go语言内置的error接口,自定义的类型,只要实现该接口方法即可称为标准错误类型,来看看源码:

// The error built-in interface type is the conventional interface for  
// representing an error condition, with the nil value representing no error.  
type error interface {  
  Error() string  
}

自定义一个错误类型,实现error接口的Error()方法:

type MyError struct {  
  s string  
}  
func (myError MyError) Error() string {  
  return "MyError"  
}  
func main() {  
  var e MyError = MyError{"err"}  
  fmt.Println(e)  // 输出:MyError  
  err, ok := interface{}(e).(error)  
  fmt.Println(ok)  // 输出:true  
  fmt.Println(err)  // 输出:MyError  
}

从上面例子来看,err, ok := interface{}(e).(error)中的类型转换结果为true,说明自定义的类型就是error的子类型,也就证实了只要某个类型实现了Error()方法,那这个类型就是error类型。

errors包

Go语言的errors包有个内置的错误类型叫errorString,来看一下源码:

package errors  
  
  
// New returns an error that formats as the given text.  
// Each call to New returns a distinct error value even if the text is identical.  
func New(text string) error {  
  return &errorString{text}  
}  
  
  
// errorString is a trivial implementation of error.  
type errorString struct {  
  s string  
}  
  
  
func (e *errorString) Error() string {  
  return e.s  
}

从上面的源码看到,errorString类型实现了error接口的Error()方法,因此errorString类型就是error的子类型。

我们知道,当某个包下面的变量和方法名以小写开头时,这个变量或者方法只能在这个包下面才能访问。因此,我们自己写的代码没办法直接创建errorString的实例,我们可以使用errors里的New方法方便的创建error类型。

var e = errors.New("MyError")  
fmt.Println(e)  // 输出:MyError  
err, ok := interface{}(e).(error)  
fmt.Println(ok)  // 输出:true  
fmt.Println(err)  // 输出:MyError

和最上面的例子一样,err, ok := interface{}(e).(error)中的类型转换结果为true,说明errorString就是error的子类型。

创建标准错误

func f1(arg int) (int, error) {  
    if arg == 42 {  
        return -1, errors.New("can't work with 42")  // 使用错误提示创建标准错误  
    }  
    return arg + 3, nil  
}  
  
  
type argError struct {  
    arg  int  
    prob string  
}  
  
  
func (e *argError) Error() string {  // 自定义错误类型需要实现Error函数  
    return fmt.Sprintf("%d - %s", e.arg, e.prob)  
}  
func f2(arg int) (int, error) {  
    if arg == 42 {  
        return -1, &argError{arg, "can't work with it"}  
    }  
    return arg + 3, nil  
}  
func main() {  
    for _, i := range []int{7, 42} {  
        if r, e := f1(i); e != nil {  
            fmt.Println("f1 failed:", e)  // f1 failed: can't work with 42  
        } else {  
            fmt.Println("f1 worked:", r)  
        }  
    }  
    for _, i := range []int{7, 42} {  
        if r, e := f2(i); e != nil {  
            fmt.Println("f2 failed:", e)  
        } else {  
            fmt.Println("f2 worked:", r)  
        }  
    }  
    _, e := f2(42)  
    if ae, ok := e.(*argError); ok {  
        fmt.Println(ae.arg)  
        fmt.Println(ae.prob)  
    }  
}  

格式化消息的标准错误类型

fmt包中有个Errorf方法,我们可以通过它创建一个具有格式化字符串的标准错误类型,来看一下fmt.Errorf的源码:

func Errorf(format string, a ...interface{}) error {  
  p := newPrinter()  
  p.wrapErrs = true  
  p.doPrintf(format, a)  
  s := string(p.buf)  
  var err error  
  if p.wrappedErr == nil {  
    err = errors.New(s)  
  } else {  
    err = &wrapError{s, p.wrappedErr}  
  }  
  p.free()  
  return err  
}

可以看到,fmt.Errorf里面使用errors.New来创建error类型的实例,然后把格式化后字符串放入这个实例里面。典型使用案例:

const name, id = "bimmler", 17  
err := fmt.Errorf("user %q (id %d) not found", name, id)  // user="bimmler" (id=17) not found  
if err != nil {  
  fmt.Print(err)  
}

这样,err不仅包含了格式化的错误消息,而且还是error类型,比我们先用fmt.Printf再用errors.New的写法会更简洁。

天杀错误判断和处理逻辑

刚从其他语言转到Go语言时,会非常不习惯Go语言的错误处理逻辑。在Java和Python里面,我们可以使用throw来抛出异常,在另一个地方使用try...catch来捕获异常。而Go语言鼓励大家把错误放到返回值里面,但是呢,又提供了panic和recover来抛出和捕获异常。一般来说,我们把返回值里面返回的叫做错误(因为他们都是error类型),把抛出和捕获的叫做异常。

既然把错误放到返回值里,那我们就每次都需要判断返回里的错误是否为空,才能知道是不是正常返回了。判断和处理错误需要用到if,如果一段代码里面调用了很多函数,我们就能看到一连串的if,这种写法感觉简直就是疯了!

result1, err := err1()  
if err != nil {  
  fmt.Println(result1)  
}  
result2, err := err2()  
if err != nil {  
  fmt.Println(result2)  
}  
result3, err := err3()  
if err != nil {  
  fmt.Println(result3)  
}  
result4, err := err4()  
if err != nil {  
  fmt.Println(result4)  
}

不过这个没法避免,老老实实习惯一下吧!

panic/recover/defer

对于异常,Go语言可以使用panic来抛出一个恐慌性异常,一般来说,当程序遇到了比较大的问题,没有办法再执行下去,我们就用panic来抛出异常。来看一下panic源码:

func panic(v interface{})

panic接收一个interface{}类型的对象,我们上篇文章说过了,任何类型都是interface{}类型的子类型,因此,panic可以抛出任何对象。使用案例:

func main() {  
  panic("hello")  
}

输出:

panic: hello  
  
goroutine 1 [running]:  
main.main()  
    E:/goworkspace/blog/src/main/main.go:4 +0x40  

同时,我们可以使用recover来捕获那些被panic抛出对象:

func pa() string {  
  panic("me")  
}  
func main() {  
  p := pa()  
fmt.Println(p)  
if r := recover(); r != nil {  
   fmt.Println(r)  
  }  
}

输出:

panic: me  
  
goroutine 1 [running]:  
main.pa(...)  
    E:/goworkspace/blog/src/main/main.go:6  
main.main()  
    E:/goworkspace/blog/src/main/main.go:9 +0x40

怎么好像recover没起作用?这当然了,recover需要与defer一起使用,而且,recover的使用要放在panic抛出之前。下面的例子才对:

func pa() string {  
  panic("me")  
}  
func main() {  
  defer func() {  
    if r := recover(); r != nil {  
      fmt.Println(r)  // 输出:me  
    }  
  }()  
  p := pa()  // 此行panic抛出me字符串  
  fmt.Println(p)  // 此行不会执行  
}

defer的用法

defer关键字表示,当前这个函数在退出之前,执行一下defer后面的逻辑。相当于我们委托一些操作给Go语言,在函数退出之前执行,有点像Java和Python里面的finally作用了。

这样,我们就可以把一些一定要执行的操作,放在defer中了,比如,我们关闭某个已经打开的资源:

fsrc, err := os.Open("source.txt")  
if err != nil {  
  fmt.Println("open source file failed")  
  return  
}  
defer fsrc.Close()  // 第一个defer  
fdes, err := os.Open("target.txt")  
if err != nil {  
  fmt.Println("open target file failed")  
  return  
}  
defer fdes.Close()  // 第二个defer  
fmt.Println("do something here")

如果一个函数里面有多个defer,那么在函数推出之前,会先执行最后一个defer,然后再执行倒数第二个、倒数第三个...,就像后进先出栈的操作。

我们下一篇聊聊通道和goroutine。

喜欢的点个关注!感谢参考原文-http://bjbsair.com/2020-04-01/tech-info/18320.html

标准错误

Go语言内置的error接口,自定义的类型,只要实现该接口方法即可称为标准错误类型,来看看源码:

// The error built-in interface type is the conventional interface for  
// representing an error condition, with the nil value representing no error.  
type error interface {  
  Error() string  
}

自定义一个错误类型,实现error接口的Error()方法:

type MyError struct {  
  s string  
}  
func (myError MyError) Error() string {  
  return "MyError"  
}  
func main() {  
  var e MyError = MyError{"err"}  
  fmt.Println(e)  // 输出:MyError  
  err, ok := interface{}(e).(error)  
  fmt.Println(ok)  // 输出:true  
  fmt.Println(err)  // 输出:MyError  
}

从上面例子来看,err, ok := interface{}(e).(error)中的类型转换结果为true,说明自定义的类型就是error的子类型,也就证实了只要某个类型实现了Error()方法,那这个类型就是error类型。

errors包

Go语言的errors包有个内置的错误类型叫errorString,来看一下源码:

package errors  
  
  
// New returns an error that formats as the given text.  
// Each call to New returns a distinct error value even if the text is identical.  
func New(text string) error {  
  return &errorString{text}  
}  
  
  
// errorString is a trivial implementation of error.  
type errorString struct {  
  s string  
}  
  
  
func (e *errorString) Error() string {  
  return e.s  
}

从上面的源码看到,errorString类型实现了error接口的Error()方法,因此errorString类型就是error的子类型。

我们知道,当某个包下面的变量和方法名以小写开头时,这个变量或者方法只能在这个包下面才能访问。因此,我们自己写的代码没办法直接创建errorString的实例,我们可以使用errors里的New方法方便的创建error类型。

var e = errors.New("MyError")  
fmt.Println(e)  // 输出:MyError  
err, ok := interface{}(e).(error)  
fmt.Println(ok)  // 输出:true  
fmt.Println(err)  // 输出:MyError

和最上面的例子一样,err, ok := interface{}(e).(error)中的类型转换结果为true,说明errorString就是error的子类型。

创建标准错误

func f1(arg int) (int, error) {  
    if arg == 42 {  
        return -1, errors.New("can't work with 42")  // 使用错误提示创建标准错误  
    }  
    return arg + 3, nil  
}  
  
  
type argError struct {  
    arg  int  
    prob string  
}  
  
  
func (e *argError) Error() string {  // 自定义错误类型需要实现Error函数  
    return fmt.Sprintf("%d - %s", e.arg, e.prob)  
}  
func f2(arg int) (int, error) {  
    if arg == 42 {  
        return -1, &argError{arg, "can't work with it"}  
    }  
    return arg + 3, nil  
}  
func main() {  
    for _, i := range []int{7, 42} {  
        if r, e := f1(i); e != nil {  
            fmt.Println("f1 failed:", e)  // f1 failed: can't work with 42  
        } else {  
            fmt.Println("f1 worked:", r)  
        }  
    }  
    for _, i := range []int{7, 42} {  
        if r, e := f2(i); e != nil {  
            fmt.Println("f2 failed:", e)  
        } else {  
            fmt.Println("f2 worked:", r)  
        }  
    }  
    _, e := f2(42)  
    if ae, ok := e.(*argError); ok {  
        fmt.Println(ae.arg)  
        fmt.Println(ae.prob)  
    }  
}  

格式化消息的标准错误类型

fmt包中有个Errorf方法,我们可以通过它创建一个具有格式化字符串的标准错误类型,来看一下fmt.Errorf的源码:

func Errorf(format string, a ...interface{}) error {  
  p := newPrinter()  
  p.wrapErrs = true  
  p.doPrintf(format, a)  
  s := string(p.buf)  
  var err error  
  if p.wrappedErr == nil {  
    err = errors.New(s)  
  } else {  
    err = &wrapError{s, p.wrappedErr}  
  }  
  p.free()  
  return err  
}

可以看到,fmt.Errorf里面使用errors.New来创建error类型的实例,然后把格式化后字符串放入这个实例里面。典型使用案例:

const name, id = "bimmler", 17  
err := fmt.Errorf("user %q (id %d) not found", name, id)  // user="bimmler" (id=17) not found  
if err != nil {  
  fmt.Print(err)  
}

这样,err不仅包含了格式化的错误消息,而且还是error类型,比我们先用fmt.Printf再用errors.New的写法会更简洁。

天杀错误判断和处理逻辑

刚从其他语言转到Go语言时,会非常不习惯Go语言的错误处理逻辑。在Java和Python里面,我们可以使用throw来抛出异常,在另一个地方使用try...catch来捕获异常。而Go语言鼓励大家把错误放到返回值里面,但是呢,又提供了panic和recover来抛出和捕获异常。一般来说,我们把返回值里面返回的叫做错误(因为他们都是error类型),把抛出和捕获的叫做异常。

既然把错误放到返回值里,那我们就每次都需要判断返回里的错误是否为空,才能知道是不是正常返回了。判断和处理错误需要用到if,如果一段代码里面调用了很多函数,我们就能看到一连串的if,这种写法感觉简直就是疯了!

result1, err := err1()  
if err != nil {  
  fmt.Println(result1)  
}  
result2, err := err2()  
if err != nil {  
  fmt.Println(result2)  
}  
result3, err := err3()  
if err != nil {  
  fmt.Println(result3)  
}  
result4, err := err4()  
if err != nil {  
  fmt.Println(result4)  
}

不过这个没法避免,老老实实习惯一下吧!

panic/recover/defer

对于异常,Go语言可以使用panic来抛出一个恐慌性异常,一般来说,当程序遇到了比较大的问题,没有办法再执行下去,我们就用panic来抛出异常。来看一下panic源码:

func panic(v interface{})

panic接收一个interface{}类型的对象,我们上篇文章说过了,任何类型都是interface{}类型的子类型,因此,panic可以抛出任何对象。使用案例:

func main() {  
  panic("hello")  
}

输出:

panic: hello  
  
goroutine 1 [running]:  
main.main()  
    E:/goworkspace/blog/src/main/main.go:4 +0x40  

同时,我们可以使用recover来捕获那些被panic抛出对象:

func pa() string {  
  panic("me")  
}  
func main() {  
  p := pa()  
fmt.Println(p)  
if r := recover(); r != nil {  
   fmt.Println(r)  
  }  
}

输出:

panic: me  
  
goroutine 1 [running]:  
main.pa(...)  
    E:/goworkspace/blog/src/main/main.go:6  
main.main()  
    E:/goworkspace/blog/src/main/main.go:9 +0x40

怎么好像recover没起作用?这当然了,recover需要与defer一起使用,而且,recover的使用要放在panic抛出之前。下面的例子才对:

func pa() string {  
  panic("me")  
}  
func main() {  
  defer func() {  
    if r := recover(); r != nil {  
      fmt.Println(r)  // 输出:me  
    }  
  }()  
  p := pa()  // 此行panic抛出me字符串  
  fmt.Println(p)  // 此行不会执行  
}

defer的用法

defer关键字表示,当前这个函数在退出之前,执行一下defer后面的逻辑。相当于我们委托一些操作给Go语言,在函数退出之前执行,有点像Java和Python里面的finally作用了。

这样,我们就可以把一些一定要执行的操作,放在defer中了,比如,我们关闭某个已经打开的资源:

fsrc, err := os.Open("source.txt")  
if err != nil {  
  fmt.Println("open source file failed")  
  return  
}  
defer fsrc.Close()  // 第一个defer  
fdes, err := os.Open("target.txt")  
if err != nil {  
  fmt.Println("open target file failed")  
  return  
}  
defer fdes.Close()  // 第二个defer  
fmt.Println("do something here")

如果一个函数里面有多个defer,那么在函数推出之前,会先执行最后一个defer,然后再执行倒数第二个、倒数第三个...,就像后进先出栈的操作。

我们下一篇聊聊通道和goroutine。

喜欢的点个关注!感谢参考原文-http://bjbsair.com/2020-04-01/tech-info/18320.html

标准错误

Go语言内置的error接口,自定义的类型,只要实现该接口方法即可称为标准错误类型,来看看源码:

// The error built-in interface type is the conventional interface for  
// representing an error condition, with the nil value representing no error.  
type error interface {  
  Error() string  
}

自定义一个错误类型,实现error接口的Error()方法:

type MyError struct {  
  s string  
}  
func (myError MyError) Error() string {  
  return "MyError"  
}  
func main() {  
  var e MyError = MyError{"err"}  
  fmt.Println(e)  // 输出:MyError  
  err, ok := interface{}(e).(error)  
  fmt.Println(ok)  // 输出:true  
  fmt.Println(err)  // 输出:MyError  
}

从上面例子来看,err, ok := interface{}(e).(error)中的类型转换结果为true,说明自定义的类型就是error的子类型,也就证实了只要某个类型实现了Error()方法,那这个类型就是error类型。

errors包

Go语言的errors包有个内置的错误类型叫errorString,来看一下源码:

package errors  
  
  
// New returns an error that formats as the given text.  
// Each call to New returns a distinct error value even if the text is identical.  
func New(text string) error {  
  return &errorString{text}  
}  
  
  
// errorString is a trivial implementation of error.  
type errorString struct {  
  s string  
}  
  
  
func (e *errorString) Error() string {  
  return e.s  
}

从上面的源码看到,errorString类型实现了error接口的Error()方法,因此errorString类型就是error的子类型。

我们知道,当某个包下面的变量和方法名以小写开头时,这个变量或者方法只能在这个包下面才能访问。因此,我们自己写的代码没办法直接创建errorString的实例,我们可以使用errors里的New方法方便的创建error类型。

var e = errors.New("MyError")  
fmt.Println(e)  // 输出:MyError  
err, ok := interface{}(e).(error)  
fmt.Println(ok)  // 输出:true  
fmt.Println(err)  // 输出:MyError

和最上面的例子一样,err, ok := interface{}(e).(error)中的类型转换结果为true,说明errorString就是error的子类型。

创建标准错误

func f1(arg int) (int, error) {  
    if arg == 42 {  
        return -1, errors.New("can't work with 42")  // 使用错误提示创建标准错误  
    }  
    return arg + 3, nil  
}  
  
  
type argError struct {  
    arg  int  
    prob string  
}  
  
  
func (e *argError) Error() string {  // 自定义错误类型需要实现Error函数  
    return fmt.Sprintf("%d - %s", e.arg, e.prob)  
}  
func f2(arg int) (int, error) {  
    if arg == 42 {  
        return -1, &argError{arg, "can't work with it"}  
    }  
    return arg + 3, nil  
}  
func main() {  
    for _, i := range []int{7, 42} {  
        if r, e := f1(i); e != nil {  
            fmt.Println("f1 failed:", e)  // f1 failed: can't work with 42  
        } else {  
            fmt.Println("f1 worked:", r)  
        }  
    }  
    for _, i := range []int{7, 42} {  
        if r, e := f2(i); e != nil {  
            fmt.Println("f2 failed:", e)  
        } else {  
            fmt.Println("f2 worked:", r)  
        }  
    }  
    _, e := f2(42)  
    if ae, ok := e.(*argError); ok {  
        fmt.Println(ae.arg)  
        fmt.Println(ae.prob)  
    }  
}  

格式化消息的标准错误类型

fmt包中有个Errorf方法,我们可以通过它创建一个具有格式化字符串的标准错误类型,来看一下fmt.Errorf的源码:

func Errorf(format string, a ...interface{}) error {  
  p := newPrinter()  
  p.wrapErrs = true  
  p.doPrintf(format, a)  
  s := string(p.buf)  
  var err error  
  if p.wrappedErr == nil {  
    err = errors.New(s)  
  } else {  
    err = &wrapError{s, p.wrappedErr}  
  }  
  p.free()  
  return err  
}

可以看到,fmt.Errorf里面使用errors.New来创建error类型的实例,然后把格式化后字符串放入这个实例里面。典型使用案例:

const name, id = "bimmler", 17  
err := fmt.Errorf("user %q (id %d) not found", name, id)  // user="bimmler" (id=17) not found  
if err != nil {  
  fmt.Print(err)  
}

这样,err不仅包含了格式化的错误消息,而且还是error类型,比我们先用fmt.Printf再用errors.New的写法会更简洁。

天杀错误判断和处理逻辑

刚从其他语言转到Go语言时,会非常不习惯Go语言的错误处理逻辑。在Java和Python里面,我们可以使用throw来抛出异常,在另一个地方使用try...catch来捕获异常。而Go语言鼓励大家把错误放到返回值里面,但是呢,又提供了panic和recover来抛出和捕获异常。一般来说,我们把返回值里面返回的叫做错误(因为他们都是error类型),把抛出和捕获的叫做异常。

既然把错误放到返回值里,那我们就每次都需要判断返回里的错误是否为空,才能知道是不是正常返回了。判断和处理错误需要用到if,如果一段代码里面调用了很多函数,我们就能看到一连串的if,这种写法感觉简直就是疯了!

result1, err := err1()  
if err != nil {  
  fmt.Println(result1)  
}  
result2, err := err2()  
if err != nil {  
  fmt.Println(result2)  
}  
result3, err := err3()  
if err != nil {  
  fmt.Println(result3)  
}  
result4, err := err4()  
if err != nil {  
  fmt.Println(result4)  
}

不过这个没法避免,老老实实习惯一下吧!

panic/recover/defer

对于异常,Go语言可以使用panic来抛出一个恐慌性异常,一般来说,当程序遇到了比较大的问题,没有办法再执行下去,我们就用panic来抛出异常。来看一下panic源码:

func panic(v interface{})

panic接收一个interface{}类型的对象,我们上篇文章说过了,任何类型都是interface{}类型的子类型,因此,panic可以抛出任何对象。使用案例:

func main() {  
  panic("hello")  
}

输出:

panic: hello  
  
goroutine 1 [running]:  
main.main()  
    E:/goworkspace/blog/src/main/main.go:4 +0x40  

同时,我们可以使用recover来捕获那些被panic抛出对象:

func pa() string {  
  panic("me")  
}  
func main() {  
  p := pa()  
fmt.Println(p)  
if r := recover(); r != nil {  
   fmt.Println(r)  
  }  
}

输出:

panic: me  
  
goroutine 1 [running]:  
main.pa(...)  
    E:/goworkspace/blog/src/main/main.go:6  
main.main()  
    E:/goworkspace/blog/src/main/main.go:9 +0x40

怎么好像recover没起作用?这当然了,recover需要与defer一起使用,而且,recover的使用要放在panic抛出之前。下面的例子才对:

func pa() string {  
  panic("me")  
}  
func main() {  
  defer func() {  
    if r := recover(); r != nil {  
      fmt.Println(r)  // 输出:me  
    }  
  }()  
  p := pa()  // 此行panic抛出me字符串  
  fmt.Println(p)  // 此行不会执行  
}

defer的用法

defer关键字表示,当前这个函数在退出之前,执行一下defer后面的逻辑。相当于我们委托一些操作给Go语言,在函数退出之前执行,有点像Java和Python里面的finally作用了。

这样,我们就可以把一些一定要执行的操作,放在defer中了,比如,我们关闭某个已经打开的资源:

fsrc, err := os.Open("source.txt")  
if err != nil {  
  fmt.Println("open source file failed")  
  return  
}  
defer fsrc.Close()  // 第一个defer  
fdes, err := os.Open("target.txt")  
if err != nil {  
  fmt.Println("open target file failed")  
  return  
}  
defer fdes.Close()  // 第二个defer  
fmt.Println("do something here")

如果一个函数里面有多个defer,那么在函数推出之前,会先执行最后一个defer,然后再执行倒数第二个、倒数第三个...,就像后进先出栈的操作。

我们下一篇聊聊通道和goroutine。

喜欢的点个关注!感谢参考原文-http://bjbsair.com/2020-04-01/tech-info/18320.html

标准错误

Go语言内置的error接口,自定义的类型,只要实现该接口方法即可称为标准错误类型,来看看源码:

// The error built-in interface type is the conventional interface for  
// representing an error condition, with the nil value representing no error.  
type error interface {  
  Error() string  
}

自定义一个错误类型,实现error接口的Error()方法:

type MyError struct {  
  s string  
}  
func (myError MyError) Error() string {  
  return "MyError"  
}  
func main() {  
  var e MyError = MyError{"err"}  
  fmt.Println(e)  // 输出:MyError  
  err, ok := interface{}(e).(error)  
  fmt.Println(ok)  // 输出:true  
  fmt.Println(err)  // 输出:MyError  
}

从上面例子来看,err, ok := interface{}(e).(error)中的类型转换结果为true,说明自定义的类型就是error的子类型,也就证实了只要某个类型实现了Error()方法,那这个类型就是error类型。

errors包

Go语言的errors包有个内置的错误类型叫errorString,来看一下源码:

package errors  
  
  
// New returns an error that formats as the given text.  
// Each call to New returns a distinct error value even if the text is identical.  
func New(text string) error {  
  return &errorString{text}  
}  
  
  
// errorString is a trivial implementation of error.  
type errorString struct {  
  s string  
}  
  
  
func (e *errorString) Error() string {  
  return e.s  
}

从上面的源码看到,errorString类型实现了error接口的Error()方法,因此errorString类型就是error的子类型。

我们知道,当某个包下面的变量和方法名以小写开头时,这个变量或者方法只能在这个包下面才能访问。因此,我们自己写的代码没办法直接创建errorString的实例,我们可以使用errors里的New方法方便的创建error类型。

var e = errors.New("MyError")  
fmt.Println(e)  // 输出:MyError  
err, ok := interface{}(e).(error)  
fmt.Println(ok)  // 输出:true  
fmt.Println(err)  // 输出:MyError

和最上面的例子一样,err, ok := interface{}(e).(error)中的类型转换结果为true,说明errorString就是error的子类型。

创建标准错误

func f1(arg int) (int, error) {  
    if arg == 42 {  
        return -1, errors.New("can't work with 42")  // 使用错误提示创建标准错误  
    }  
    return arg + 3, nil  
}  
  
  
type argError struct {  
    arg  int  
    prob string  
}  
  
  
func (e *argError) Error() string {  // 自定义错误类型需要实现Error函数  
    return fmt.Sprintf("%d - %s", e.arg, e.prob)  
}  
func f2(arg int) (int, error) {  
    if arg == 42 {  
        return -1, &argError{arg, "can't work with it"}  
    }  
    return arg + 3, nil  
}  
func main() {  
    for _, i := range []int{7, 42} {  
        if r, e := f1(i); e != nil {  
            fmt.Println("f1 failed:", e)  // f1 failed: can't work with 42  
        } else {  
            fmt.Println("f1 worked:", r)  
        }  
    }  
    for _, i := range []int{7, 42} {  
        if r, e := f2(i); e != nil {  
            fmt.Println("f2 failed:", e)  
        } else {  
            fmt.Println("f2 worked:", r)  
        }  
    }  
    _, e := f2(42)  
    if ae, ok := e.(*argError); ok {  
        fmt.Println(ae.arg)  
        fmt.Println(ae.prob)  
    }  
}  

格式化消息的标准错误类型

fmt包中有个Errorf方法,我们可以通过它创建一个具有格式化字符串的标准错误类型,来看一下fmt.Errorf的源码:

func Errorf(format string, a ...interface{}) error {  
  p := newPrinter()  
  p.wrapErrs = true  
  p.doPrintf(format, a)  
  s := string(p.buf)  
  var err error  
  if p.wrappedErr == nil {  
    err = errors.New(s)  
  } else {  
    err = &wrapError{s, p.wrappedErr}  
  }  
  p.free()  
  return err  
}

可以看到,fmt.Errorf里面使用errors.New来创建error类型的实例,然后把格式化后字符串放入这个实例里面。典型使用案例:

const name, id = "bimmler", 17  
err := fmt.Errorf("user %q (id %d) not found", name, id)  // user="bimmler" (id=17) not found  
if err != nil {  
  fmt.Print(err)  
}

这样,err不仅包含了格式化的错误消息,而且还是error类型,比我们先用fmt.Printf再用errors.New的写法会更简洁。

天杀错误判断和处理逻辑

刚从其他语言转到Go语言时,会非常不习惯Go语言的错误处理逻辑。在Java和Python里面,我们可以使用throw来抛出异常,在另一个地方使用try...catch来捕获异常。而Go语言鼓励大家把错误放到返回值里面,但是呢,又提供了panic和recover来抛出和捕获异常。一般来说,我们把返回值里面返回的叫做错误(因为他们都是error类型),把抛出和捕获的叫做异常。

既然把错误放到返回值里,那我们就每次都需要判断返回里的错误是否为空,才能知道是不是正常返回了。判断和处理错误需要用到if,如果一段代码里面调用了很多函数,我们就能看到一连串的if,这种写法感觉简直就是疯了!

result1, err := err1()  
if err != nil {  
  fmt.Println(result1)  
}  
result2, err := err2()  
if err != nil {  
  fmt.Println(result2)  
}  
result3, err := err3()  
if err != nil {  
  fmt.Println(result3)  
}  
result4, err := err4()  
if err != nil {  
  fmt.Println(result4)  
}

不过这个没法避免,老老实实习惯一下吧!

panic/recover/defer

对于异常,Go语言可以使用panic来抛出一个恐慌性异常,一般来说,当程序遇到了比较大的问题,没有办法再执行下去,我们就用panic来抛出异常。来看一下panic源码:

func panic(v interface{})

panic接收一个interface{}类型的对象,我们上篇文章说过了,任何类型都是interface{}类型的子类型,因此,panic可以抛出任何对象。使用案例:

func main() {  
  panic("hello")  
}

输出:

panic: hello  
  
goroutine 1 [running]:  
main.main()  
    E:/goworkspace/blog/src/main/main.go:4 +0x40  

同时,我们可以使用recover来捕获那些被panic抛出对象:

func pa() string {  
  panic("me")  
}  
func main() {  
  p := pa()  
fmt.Println(p)  
if r := recover(); r != nil {  
   fmt.Println(r)  
  }  
}

输出:

panic: me  
  
goroutine 1 [running]:  
main.pa(...)  
    E:/goworkspace/blog/src/main/main.go:6  
main.main()  
    E:/goworkspace/blog/src/main/main.go:9 +0x40

怎么好像recover没起作用?这当然了,recover需要与defer一起使用,而且,recover的使用要放在panic抛出之前。下面的例子才对:

func pa() string {  
  panic("me")  
}  
func main() {  
  defer func() {  
    if r := recover(); r != nil {  
      fmt.Println(r)  // 输出:me  
    }  
  }()  
  p := pa()  // 此行panic抛出me字符串  
  fmt.Println(p)  // 此行不会执行  
}

defer的用法

defer关键字表示,当前这个函数在退出之前,执行一下defer后面的逻辑。相当于我们委托一些操作给Go语言,在函数退出之前执行,有点像Java和Python里面的finally作用了。

这样,我们就可以把一些一定要执行的操作,放在defer中了,比如,我们关闭某个已经打开的资源:

fsrc, err := os.Open("source.txt")  
if err != nil {  
  fmt.Println("open source file failed")  
  return  
}  
defer fsrc.Close()  // 第一个defer  
fdes, err := os.Open("target.txt")  
if err != nil {  
  fmt.Println("open target file failed")  
  return  
}  
defer fdes.Close()  // 第二个defer  
fmt.Println("do something here")

如果一个函数里面有多个defer,那么在函数推出之前,会先执行最后一个defer,然后再执行倒数第二个、倒数第三个...,就像后进先出栈的操作。

我们下一篇聊聊通道和goroutine。

喜欢的点个关注!感谢参考原文-http://bjbsair.com/2020-04-01/tech-info/18320.html

标准错误

Go语言内置的error接口,自定义的类型,只要实现该接口方法即可称为标准错误类型,来看看源码:

// The error built-in interface type is the conventional interface for  
// representing an error condition, with the nil value representing no error.  
type error interface {  
  Error() string  
}

自定义一个错误类型,实现error接口的Error()方法:

type MyError struct {  
  s string  
}  
func (myError MyError) Error() string {  
  return "MyError"  
}  
func main() {  
  var e MyError = MyError{"err"}  
  fmt.Println(e)  // 输出:MyError  
  err, ok := interface{}(e).(error)  
  fmt.Println(ok)  // 输出:true  
  fmt.Println(err)  // 输出:MyError  
}

从上面例子来看,err, ok := interface{}(e).(error)中的类型转换结果为true,说明自定义的类型就是error的子类型,也就证实了只要某个类型实现了Error()方法,那这个类型就是error类型。

errors包

Go语言的errors包有个内置的错误类型叫errorString,来看一下源码:

package errors  
  
  
// New returns an error that formats as the given text.  
// Each call to New returns a distinct error value even if the text is identical.  
func New(text string) error {  
  return &errorString{text}  
}  
  
  
// errorString is a trivial implementation of error.  
type errorString struct {  
  s string  
}  
  
  
func (e *errorString) Error() string {  
  return e.s  
}

从上面的源码看到,errorString类型实现了error接口的Error()方法,因此errorString类型就是error的子类型。

我们知道,当某个包下面的变量和方法名以小写开头时,这个变量或者方法只能在这个包下面才能访问。因此,我们自己写的代码没办法直接创建errorString的实例,我们可以使用errors里的New方法方便的创建error类型。

var e = errors.New("MyError")  
fmt.Println(e)  // 输出:MyError  
err, ok := interface{}(e).(error)  
fmt.Println(ok)  // 输出:true  
fmt.Println(err)  // 输出:MyError

和最上面的例子一样,err, ok := interface{}(e).(error)中的类型转换结果为true,说明errorString就是error的子类型。

创建标准错误

func f1(arg int) (int, error) {  
    if arg == 42 {  
        return -1, errors.New("can't work with 42")  // 使用错误提示创建标准错误  
    }  
    return arg + 3, nil  
}  
  
  
type argError struct {  
    arg  int  
    prob string  
}  
  
  
func (e *argError) Error() string {  // 自定义错误类型需要实现Error函数  
    return fmt.Sprintf("%d - %s", e.arg, e.prob)  
}  
func f2(arg int) (int, error) {  
    if arg == 42 {  
        return -1, &argError{arg, "can't work with it"}  
    }  
    return arg + 3, nil  
}  
func main() {  
    for _, i := range []int{7, 42} {  
        if r, e := f1(i); e != nil {  
            fmt.Println("f1 failed:", e)  // f1 failed: can't work with 42  
        } else {  
            fmt.Println("f1 worked:", r)  
        }  
    }  
    for _, i := range []int{7, 42} {  
        if r, e := f2(i); e != nil {  
            fmt.Println("f2 failed:", e)  
        } else {  
            fmt.Println("f2 worked:", r)  
        }  
    }  
    _, e := f2(42)  
    if ae, ok := e.(*argError); ok {  
        fmt.Println(ae.arg)  
        fmt.Println(ae.prob)  
    }  
}  

格式化消息的标准错误类型

fmt包中有个Errorf方法,我们可以通过它创建一个具有格式化字符串的标准错误类型,来看一下fmt.Errorf的源码:

func Errorf(format string, a ...interface{}) error {  
  p := newPrinter()  
  p.wrapErrs = true  
  p.doPrintf(format, a)  
  s := string(p.buf)  
  var err error  
  if p.wrappedErr == nil {  
    err = errors.New(s)  
  } else {  
    err = &wrapError{s, p.wrappedErr}  
  }  
  p.free()  
  return err  
}

可以看到,fmt.Errorf里面使用errors.New来创建error类型的实例,然后把格式化后字符串放入这个实例里面。典型使用案例:

const name, id = "bimmler", 17  
err := fmt.Errorf("user %q (id %d) not found", name, id)  // user="bimmler" (id=17) not found  
if err != nil {  
  fmt.Print(err)  
}

这样,err不仅包含了格式化的错误消息,而且还是error类型,比我们先用fmt.Printf再用errors.New的写法会更简洁。

天杀错误判断和处理逻辑

刚从其他语言转到Go语言时,会非常不习惯Go语言的错误处理逻辑。在Java和Python里面,我们可以使用throw来抛出异常,在另一个地方使用try...catch来捕获异常。而Go语言鼓励大家把错误放到返回值里面,但是呢,又提供了panic和recover来抛出和捕获异常。一般来说,我们把返回值里面返回的叫做错误(因为他们都是error类型),把抛出和捕获的叫做异常。

既然把错误放到返回值里,那我们就每次都需要判断返回里的错误是否为空,才能知道是不是正常返回了。判断和处理错误需要用到if,如果一段代码里面调用了很多函数,我们就能看到一连串的if,这种写法感觉简直就是疯了!

result1, err := err1()  
if err != nil {  
  fmt.Println(result1)  
}  
result2, err := err2()  
if err != nil {  
  fmt.Println(result2)  
}  
result3, err := err3()  
if err != nil {  
  fmt.Println(result3)  
}  
result4, err := err4()  
if err != nil {  
  fmt.Println(result4)  
}

不过这个没法避免,老老实实习惯一下吧!

panic/recover/defer

对于异常,Go语言可以使用panic来抛出一个恐慌性异常,一般来说,当程序遇到了比较大的问题,没有办法再执行下去,我们就用panic来抛出异常。来看一下panic源码:

func panic(v interface{})

panic接收一个interface{}类型的对象,我们上篇文章说过了,任何类型都是interface{}类型的子类型,因此,panic可以抛出任何对象。使用案例:

func main() {  
  panic("hello")  
}

输出:

panic: hello  
  
goroutine 1 [running]:  
main.main()  
    E:/goworkspace/blog/src/main/main.go:4 +0x40  

同时,我们可以使用recover来捕获那些被panic抛出对象:

func pa() string {  
  panic("me")  
}  
func main() {  
  p := pa()  
fmt.Println(p)  
if r := recover(); r != nil {  
   fmt.Println(r)  
  }  
}

输出:

panic: me  
  
goroutine 1 [running]:  
main.pa(...)  
    E:/goworkspace/blog/src/main/main.go:6  
main.main()  
    E:/goworkspace/blog/src/main/main.go:9 +0x40

怎么好像recover没起作用?这当然了,recover需要与defer一起使用,而且,recover的使用要放在panic抛出之前。下面的例子才对:

func pa() string {  
  panic("me")  
}  
func main() {  
  defer func() {  
    if r := recover(); r != nil {  
      fmt.Println(r)  // 输出:me  
    }  
  }()  
  p := pa()  // 此行panic抛出me字符串  
  fmt.Println(p)  // 此行不会执行  
}

defer的用法

defer关键字表示,当前这个函数在退出之前,执行一下defer后面的逻辑。相当于我们委托一些操作给Go语言,在函数退出之前执行,有点像Java和Python里面的finally作用了。

这样,我们就可以把一些一定要执行的操作,放在defer中了,比如,我们关闭某个已经打开的资源:

fsrc, err := os.Open("source.txt")  
if err != nil {  
  fmt.Println("open source file failed")  
  return  
}  
defer fsrc.Close()  // 第一个defer  
fdes, err := os.Open("target.txt")  
if err != nil {  
  fmt.Println("open target file failed")  
  return  
}  
defer fdes.Close()  // 第二个defer  
fmt.Println("do something here")

如果一个函数里面有多个defer,那么在函数推出之前,会先执行最后一个defer,然后再执行倒数第二个、倒数第三个...,就像后进先出栈的操作。

我们下一篇聊聊通道和goroutine。

喜欢的点个关注!感谢参考原文-http://bjbsair.com/2020-04-01/tech-info/18320.html

标准错误

Go语言内置的error接口,自定义的类型,只要实现该接口方法即可称为标准错误类型,来看看源码:

// The error built-in interface type is the conventional interface for  
// representing an error condition, with the nil value representing no error.  
type error interface {  
  Error() string  
}

自定义一个错误类型,实现error接口的Error()方法:

type MyError struct {  
  s string  
}  
func (myError MyError) Error() string {  
  return "MyError"  
}  
func main() {  
  var e MyError = MyError{"err"}  
  fmt.Println(e)  // 输出:MyError  
  err, ok := interface{}(e).(error)  
  fmt.Println(ok)  // 输出:true  
  fmt.Println(err)  // 输出:MyError  
}

从上面例子来看,err, ok := interface{}(e).(error)中的类型转换结果为true,说明自定义的类型就是error的子类型,也就证实了只要某个类型实现了Error()方法,那这个类型就是error类型。

errors包

Go语言的errors包有个内置的错误类型叫errorString,来看一下源码:

package errors  
  
  
// New returns an error that formats as the given text.  
// Each call to New returns a distinct error value even if the text is identical.  
func New(text string) error {  
  return &errorString{text}  
}  
  
  
// errorString is a trivial implementation of error.  
type errorString struct {  
  s string  
}  
  
  
func (e *errorString) Error() string {  
  return e.s  
}

从上面的源码看到,errorString类型实现了error接口的Error()方法,因此errorString类型就是error的子类型。

我们知道,当某个包下面的变量和方法名以小写开头时,这个变量或者方法只能在这个包下面才能访问。因此,我们自己写的代码没办法直接创建errorString的实例,我们可以使用errors里的New方法方便的创建error类型。

var e = errors.New("MyError")  
fmt.Println(e)  // 输出:MyError  
err, ok := interface{}(e).(error)  
fmt.Println(ok)  // 输出:true  
fmt.Println(err)  // 输出:MyError

和最上面的例子一样,err, ok := interface{}(e).(error)中的类型转换结果为true,说明errorString就是error的子类型。

创建标准错误

func f1(arg int) (int, error) {  
    if arg == 42 {  
        return -1, errors.New("can't work with 42")  // 使用错误提示创建标准错误  
    }  
    return arg + 3, nil  
}  
  
  
type argError struct {  
    arg  int  
    prob string  
}  
  
  
func (e *argError) Error() string {  // 自定义错误类型需要实现Error函数  
    return fmt.Sprintf("%d - %s", e.arg, e.prob)  
}  
func f2(arg int) (int, error) {  
    if arg == 42 {  
        return -1, &argError{arg, "can't work with it"}  
    }  
    return arg + 3, nil  
}  
func main() {  
    for _, i := range []int{7, 42} {  
        if r, e := f1(i); e != nil {  
            fmt.Println("f1 failed:", e)  // f1 failed: can't work with 42  
        } else {  
            fmt.Println("f1 worked:", r)  
        }  
    }  
    for _, i := range []int{7, 42} {  
        if r, e := f2(i); e != nil {  
            fmt.Println("f2 failed:", e)  
        } else {  
            fmt.Println("f2 worked:", r)  
        }  
    }  
    _, e := f2(42)  
    if ae, ok := e.(*argError); ok {  
        fmt.Println(ae.arg)  
        fmt.Println(ae.prob)  
    }  
}  

格式化消息的标准错误类型

fmt包中有个Errorf方法,我们可以通过它创建一个具有格式化字符串的标准错误类型,来看一下fmt.Errorf的源码:

func Errorf(format string, a ...interface{}) error {  
  p := newPrinter()  
  p.wrapErrs = true  
  p.doPrintf(format, a)  
  s := string(p.buf)  
  var err error  
  if p.wrappedErr == nil {  
    err = errors.New(s)  
  } else {  
    err = &wrapError{s, p.wrappedErr}  
  }  
  p.free()  
  return err  
}

可以看到,fmt.Errorf里面使用errors.New来创建error类型的实例,然后把格式化后字符串放入这个实例里面。典型使用案例:

const name, id = "bimmler", 17  
err := fmt.Errorf("user %q (id %d) not found", name, id)  // user="bimmler" (id=17) not found  
if err != nil {  
  fmt.Print(err)  
}

这样,err不仅包含了格式化的错误消息,而且还是error类型,比我们先用fmt.Printf再用errors.New的写法会更简洁。

天杀错误判断和处理逻辑

刚从其他语言转到Go语言时,会非常不习惯Go语言的错误处理逻辑。在Java和Python里面,我们可以使用throw来抛出异常,在另一个地方使用try...catch来捕获异常。而Go语言鼓励大家把错误放到返回值里面,但是呢,又提供了panic和recover来抛出和捕获异常。一般来说,我们把返回值里面返回的叫做错误(因为他们都是error类型),把抛出和捕获的叫做异常。

既然把错误放到返回值里,那我们就每次都需要判断返回里的错误是否为空,才能知道是不是正常返回了。判断和处理错误需要用到if,如果一段代码里面调用了很多函数,我们就能看到一连串的if,这种写法感觉简直就是疯了!

result1, err := err1()  
if err != nil {  
  fmt.Println(result1)  
}  
result2, err := err2()  
if err != nil {  
  fmt.Println(result2)  
}  
result3, err := err3()  
if err != nil {  
  fmt.Println(result3)  
}  
result4, err := err4()  
if err != nil {  
  fmt.Println(result4)  
}

不过这个没法避免,老老实实习惯一下吧!

panic/recover/defer

对于异常,Go语言可以使用panic来抛出一个恐慌性异常,一般来说,当程序遇到了比较大的问题,没有办法再执行下去,我们就用panic来抛出异常。来看一下panic源码:

func panic(v interface{})

panic接收一个interface{}类型的对象,我们上篇文章说过了,任何类型都是interface{}类型的子类型,因此,panic可以抛出任何对象。使用案例:

func main() {  
  panic("hello")  
}

输出:

panic: hello  
  
goroutine 1 [running]:  
main.main()  
    E:/goworkspace/blog/src/main/main.go:4 +0x40  

同时,我们可以使用recover来捕获那些被panic抛出对象:

func pa() string {  
  panic("me")  
}  
func main() {  
  p := pa()  
fmt.Println(p)  
if r := recover(); r != nil {  
   fmt.Println(r)  
  }  
}

输出:

panic: me  
  
goroutine 1 [running]:  
main.pa(...)  
    E:/goworkspace/blog/src/main/main.go:6  
main.main()  
    E:/goworkspace/blog/src/main/main.go:9 +0x40

怎么好像recover没起作用?这当然了,recover需要与defer一起使用,而且,recover的使用要放在panic抛出之前。下面的例子才对:

func pa() string {  
  panic("me")  
}  
func main() {  
  defer func() {  
    if r := recover(); r != nil {  
      fmt.Println(r)  // 输出:me  
    }  
  }()  
  p := pa()  // 此行panic抛出me字符串  
  fmt.Println(p)  // 此行不会执行  
}

defer的用法

defer关键字表示,当前这个函数在退出之前,执行一下defer后面的逻辑。相当于我们委托一些操作给Go语言,在函数退出之前执行,有点像Java和Python里面的finally作用了。

这样,我们就可以把一些一定要执行的操作,放在defer中了,比如,我们关闭某个已经打开的资源:

fsrc, err := os.Open("source.txt")  
if err != nil {  
  fmt.Println("open source file failed")  
  return  
}  
defer fsrc.Close()  // 第一个defer  
fdes, err := os.Open("target.txt")  
if err != nil {  
  fmt.Println("open target file failed")  
  return  
}  
defer fdes.Close()  // 第二个defer  
fmt.Println("do something here")

如果一个函数里面有多个defer,那么在函数推出之前,会先执行最后一个defer,然后再执行倒数第二个、倒数第三个...,就像后进先出栈的操作。

我们下一篇聊聊通道和goroutine。

喜欢的点个关注!感谢参考原文-http://bjbsair.com/2020-04-01/tech-info/18320.html

标准错误

Go语言内置的error接口,自定义的类型,只要实现该接口方法即可称为标准错误类型,来看看源码:

// The error built-in interface type is the conventional interface for  
// representing an error condition, with the nil value representing no error.  
type error interface {  
  Error() string  
}

自定义一个错误类型,实现error接口的Error()方法:

type MyError struct {  
  s string  
}  
func (myError MyError) Error() string {  
  return "MyError"  
}  
func main() {  
  var e MyError = MyError{"err"}  
  fmt.Println(e)  // 输出:MyError  
  err, ok := interface{}(e).(error)  
  fmt.Println(ok)  // 输出:true  
  fmt.Println(err)  // 输出:MyError  
}

从上面例子来看,err, ok := interface{}(e).(error)中的类型转换结果为true,说明自定义的类型就是error的子类型,也就证实了只要某个类型实现了Error()方法,那这个类型就是error类型。

errors包

Go语言的errors包有个内置的错误类型叫errorString,来看一下源码:

package errors  
  
  
// New returns an error that formats as the given text.  
// Each call to New returns a distinct error value even if the text is identical.  
func New(text string) error {  
  return &errorString{text}  
}  
  
  
// errorString is a trivial implementation of error.  
type errorString struct {  
  s string  
}  
  
  
func (e *errorString) Error() string {  
  return e.s  
}

从上面的源码看到,errorString类型实现了error接口的Error()方法,因此errorString类型就是error的子类型。

我们知道,当某个包下面的变量和方法名以小写开头时,这个变量或者方法只能在这个包下面才能访问。因此,我们自己写的代码没办法直接创建errorString的实例,我们可以使用errors里的New方法方便的创建error类型。

var e = errors.New("MyError")  
fmt.Println(e)  // 输出:MyError  
err, ok := interface{}(e).(error)  
fmt.Println(ok)  // 输出:true  
fmt.Println(err)  // 输出:MyError

和最上面的例子一样,err, ok := interface{}(e).(error)中的类型转换结果为true,说明errorString就是error的子类型。

创建标准错误

func f1(arg int) (int, error) {  
    if arg == 42 {  
        return -1, errors.New("can't work with 42")  // 使用错误提示创建标准错误  
    }  
    return arg + 3, nil  
}  
  
  
type argError struct {  
    arg  int  
    prob string  
}  
  
  
func (e *argError) Error() string {  // 自定义错误类型需要实现Error函数  
    return fmt.Sprintf("%d - %s", e.arg, e.prob)  
}  
func f2(arg int) (int, error) {  
    if arg == 42 {  
        return -1, &argError{arg, "can't work with it"}  
    }  
    return arg + 3, nil  
}  
func main() {  
    for _, i := range []int{7, 42} {  
        if r, e := f1(i); e != nil {  
            fmt.Println("f1 failed:", e)  // f1 failed: can't work with 42  
        } else {  
            fmt.Println("f1 worked:", r)  
        }  
    }  
    for _, i := range []int{7, 42} {  
        if r, e := f2(i); e != nil {  
            fmt.Println("f2 failed:", e)  
        } else {  
            fmt.Println("f2 worked:", r)  
        }  
    }  
    _, e := f2(42)  
    if ae, ok := e.(*argError); ok {  
        fmt.Println(ae.arg)  
        fmt.Println(ae.prob)  
    }  
}  

格式化消息的标准错误类型

fmt包中有个Errorf方法,我们可以通过它创建一个具有格式化字符串的标准错误类型,来看一下fmt.Errorf的源码:

func Errorf(format string, a ...interface{}) error {  
  p := newPrinter()  
  p.wrapErrs = true  
  p.doPrintf(format, a)  
  s := string(p.buf)  
  var err error  
  if p.wrappedErr == nil {  
    err = errors.New(s)  
  } else {  
    err = &wrapError{s, p.wrappedErr}  
  }  
  p.free()  
  return err  
}

可以看到,fmt.Errorf里面使用errors.New来创建error类型的实例,然后把格式化后字符串放入这个实例里面。典型使用案例:

const name, id = "bimmler", 17  
err := fmt.Errorf("user %q (id %d) not found", name, id)  // user="bimmler" (id=17) not found  
if err != nil {  
  fmt.Print(err)  
}

这样,err不仅包含了格式化的错误消息,而且还是error类型,比我们先用fmt.Printf再用errors.New的写法会更简洁。

天杀错误判断和处理逻辑

刚从其他语言转到Go语言时,会非常不习惯Go语言的错误处理逻辑。在Java和Python里面,我们可以使用throw来抛出异常,在另一个地方使用try...catch来捕获异常。而Go语言鼓励大家把错误放到返回值里面,但是呢,又提供了panic和recover来抛出和捕获异常。一般来说,我们把返回值里面返回的叫做错误(因为他们都是error类型),把抛出和捕获的叫做异常。

既然把错误放到返回值里,那我们就每次都需要判断返回里的错误是否为空,才能知道是不是正常返回了。判断和处理错误需要用到if,如果一段代码里面调用了很多函数,我们就能看到一连串的if,这种写法感觉简直就是疯了!

result1, err := err1()  
if err != nil {  
  fmt.Println(result1)  
}  
result2, err := err2()  
if err != nil {  
  fmt.Println(result2)  
}  
result3, err := err3()  
if err != nil {  
  fmt.Println(result3)  
}  
result4, err := err4()  
if err != nil {  
  fmt.Println(result4)  
}

不过这个没法避免,老老实实习惯一下吧!

panic/recover/defer

对于异常,Go语言可以使用panic来抛出一个恐慌性异常,一般来说,当程序遇到了比较大的问题,没有办法再执行下去,我们就用panic来抛出异常。来看一下panic源码:

func panic(v interface{})

panic接收一个interface{}类型的对象,我们上篇文章说过了,任何类型都是interface{}类型的子类型,因此,panic可以抛出任何对象。使用案例:

func main() {  
  panic("hello")  
}

输出:

panic: hello  
  
goroutine 1 [running]:  
main.main()  
    E:/goworkspace/blog/src/main/main.go:4 +0x40  

同时,我们可以使用recover来捕获那些被panic抛出对象:

func pa() string {  
  panic("me")  
}  
func main() {  
  p := pa()  
fmt.Println(p)  
if r := recover(); r != nil {  
   fmt.Println(r)  
  }  
}

输出:

panic: me  
  
goroutine 1 [running]:  
main.pa(...)  
    E:/goworkspace/blog/src/main/main.go:6  
main.main()  
    E:/goworkspace/blog/src/main/main.go:9 +0x40

怎么好像recover没起作用?这当然了,recover需要与defer一起使用,而且,recover的使用要放在panic抛出之前。下面的例子才对:

func pa() string {  
  panic("me")  
}  
func main() {  
  defer func() {  
    if r := recover(); r != nil {  
      fmt.Println(r)  // 输出:me  
    }  
  }()  
  p := pa()  // 此行panic抛出me字符串  
  fmt.Println(p)  // 此行不会执行  
}

defer的用法

defer关键字表示,当前这个函数在退出之前,执行一下defer后面的逻辑。相当于我们委托一些操作给Go语言,在函数退出之前执行,有点像Java和Python里面的finally作用了。

这样,我们就可以把一些一定要执行的操作,放在defer中了,比如,我们关闭某个已经打开的资源:

fsrc, err := os.Open("source.txt")  
if err != nil {  
  fmt.Println("open source file failed")  
  return  
}  
defer fsrc.Close()  // 第一个defer  
fdes, err := os.Open("target.txt")  
if err != nil {  
  fmt.Println("open target file failed")  
  return  
}  
defer fdes.Close()  // 第二个defer  
fmt.Println("do something here")

如果一个函数里面有多个defer,那么在函数推出之前,会先执行最后一个defer,然后再执行倒数第二个、倒数第三个...,就像后进先出栈的操作。

我们下一篇聊聊通道和goroutine。

喜欢的点个关注!感谢参考原文-http://bjbsair.com/2020-04-01/tech-info/18320.html

标准错误

Go语言内置的error接口,自定义的类型,只要实现该接口方法即可称为标准错误类型,来看看源码:

// The error built-in interface type is the conventional interface for  
// representing an error condition, with the nil value representing no error.  
type error interface {  
  Error() string  
}

自定义一个错误类型,实现error接口的Error()方法:

type MyError struct {  
  s string  
}  
func (myError MyError) Error() string {  
  return "MyError"  
}  
func main() {  
  var e MyError = MyError{"err"}  
  fmt.Println(e)  // 输出:MyError  
  err, ok := interface{}(e).(error)  
  fmt.Println(ok)  // 输出:true  
  fmt.Println(err)  // 输出:MyError  
}

从上面例子来看,err, ok := interface{}(e).(error)中的类型转换结果为true,说明自定义的类型就是error的子类型,也就证实了只要某个类型实现了Error()方法,那这个类型就是error类型。

errors包

Go语言的errors包有个内置的错误类型叫errorString,来看一下源码:

package errors  
  
  
// New returns an error that formats as the given text.  
// Each call to New returns a distinct error value even if the text is identical.  
func New(text string) error {  
  return &errorString{text}  
}  
  
  
// errorString is a trivial implementation of error.  
type errorString struct {  
  s string  
}  
  
  
func (e *errorString) Error() string {  
  return e.s  
}

从上面的源码看到,errorString类型实现了error接口的Error()方法,因此errorString类型就是error的子类型。

我们知道,当某个包下面的变量和方法名以小写开头时,这个变量或者方法只能在这个包下面才能访问。因此,我们自己写的代码没办法直接创建errorString的实例,我们可以使用errors里的New方法方便的创建error类型。

var e = errors.New("MyError")  
fmt.Println(e)  // 输出:MyError  
err, ok := interface{}(e).(error)  
fmt.Println(ok)  // 输出:true  
fmt.Println(err)  // 输出:MyError

和最上面的例子一样,err, ok := interface{}(e).(error)中的类型转换结果为true,说明errorString就是error的子类型。

创建标准错误

func f1(arg int) (int, error) {  
    if arg == 42 {  
        return -1, errors.New("can't work with 42")  // 使用错误提示创建标准错误  
    }  
    return arg + 3, nil  
}  
  
  
type argError struct {  
    arg  int  
    prob string  
}  
  
  
func (e *argError) Error() string {  // 自定义错误类型需要实现Error函数  
    return fmt.Sprintf("%d - %s", e.arg, e.prob)  
}  
func f2(arg int) (int, error) {  
    if arg == 42 {  
        return -1, &argError{arg, "can't work with it"}  
    }  
    return arg + 3, nil  
}  
func main() {  
    for _, i := range []int{7, 42} {  
        if r, e := f1(i); e != nil {  
            fmt.Println("f1 failed:", e)  // f1 failed: can't work with 42  
        } else {  
            fmt.Println("f1 worked:", r)  
        }  
    }  
    for _, i := range []int{7, 42} {  
        if r, e := f2(i); e != nil {  
            fmt.Println("f2 failed:", e)  
        } else {  
            fmt.Println("f2 worked:", r)  
        }  
    }  
    _, e := f2(42)  
    if ae, ok := e.(*argError); ok {  
        fmt.Println(ae.arg)  
        fmt.Println(ae.prob)  
    }  
}  

格式化消息的标准错误类型

fmt包中有个Errorf方法,我们可以通过它创建一个具有格式化字符串的标准错误类型,来看一下fmt.Errorf的源码:

func Errorf(format string, a ...interface{}) error {  
  p := newPrinter()  
  p.wrapErrs = true  
  p.doPrintf(format, a)  
  s := string(p.buf)  
  var err error  
  if p.wrappedErr == nil {  
    err = errors.New(s)  
  } else {  
    err = &wrapError{s, p.wrappedErr}  
  }  
  p.free()  
  return err  
}

可以看到,fmt.Errorf里面使用errors.New来创建error类型的实例,然后把格式化后字符串放入这个实例里面。典型使用案例:

const name, id = "bimmler", 17  
err := fmt.Errorf("user %q (id %d) not found", name, id)  // user="bimmler" (id=17) not found  
if err != nil {  
  fmt.Print(err)  
}

这样,err不仅包含了格式化的错误消息,而且还是error类型,比我们先用fmt.Printf再用errors.New的写法会更简洁。

天杀错误判断和处理逻辑

刚从其他语言转到Go语言时,会非常不习惯Go语言的错误处理逻辑。在Java和Python里面,我们可以使用throw来抛出异常,在另一个地方使用try...catch来捕获异常。而Go语言鼓励大家把错误放到返回值里面,但是呢,又提供了panic和recover来抛出和捕获异常。一般来说,我们把返回值里面返回的叫做错误(因为他们都是error类型),把抛出和捕获的叫做异常。

既然把错误放到返回值里,那我们就每次都需要判断返回里的错误是否为空,才能知道是不是正常返回了。判断和处理错误需要用到if,如果一段代码里面调用了很多函数,我们就能看到一连串的if,这种写法感觉简直就是疯了!

result1, err := err1()  
if err != nil {  
  fmt.Println(result1)  
}  
result2, err := err2()  
if err != nil {  
  fmt.Println(result2)  
}  
result3, err := err3()  
if err != nil {  
  fmt.Println(result3)  
}  
result4, err := err4()  
if err != nil {  
  fmt.Println(result4)  
}

不过这个没法避免,老老实实习惯一下吧!

panic/recover/defer

对于异常,Go语言可以使用panic来抛出一个恐慌性异常,一般来说,当程序遇到了比较大的问题,没有办法再执行下去,我们就用panic来抛出异常。来看一下panic源码:

func panic(v interface{})

panic接收一个interface{}类型的对象,我们上篇文章说过了,任何类型都是interface{}类型的子类型,因此,panic可以抛出任何对象。使用案例:

func main() {  
  panic("hello")  
}

输出:

panic: hello  
  
goroutine 1 [running]:  
main.main()  
    E:/goworkspace/blog/src/main/main.go:4 +0x40  

同时,我们可以使用recover来捕获那些被panic抛出对象:

func pa() string {  
  panic("me")  
}  
func main() {  
  p := pa()  
fmt.Println(p)  
if r := recover(); r != nil {  
   fmt.Println(r)  
  }  
}

输出:

panic: me  
  
goroutine 1 [running]:  
main.pa(...)  
    E:/goworkspace/blog/src/main/main.go:6  
main.main()  
    E:/goworkspace/blog/src/main/main.go:9 +0x40

怎么好像recover没起作用?这当然了,recover需要与defer一起使用,而且,recover的使用要放在panic抛出之前。下面的例子才对:

func pa() string {  
  panic("me")  
}  
func main() {  
  defer func() {  
    if r := recover(); r != nil {  
      fmt.Println(r)  // 输出:me  
    }  
  }()  
  p := pa()  // 此行panic抛出me字符串  
  fmt.Println(p)  // 此行不会执行  
}

defer的用法

defer关键字表示,当前这个函数在退出之前,执行一下defer后面的逻辑。相当于我们委托一些操作给Go语言,在函数退出之前执行,有点像Java和Python里面的finally作用了。

这样,我们就可以把一些一定要执行的操作,放在defer中了,比如,我们关闭某个已经打开的资源:

fsrc, err := os.Open("source.txt")  
if err != nil {  
  fmt.Println("open source file failed")  
  return  
}  
defer fsrc.Close()  // 第一个defer  
fdes, err := os.Open("target.txt")  
if err != nil {  
  fmt.Println("open target file failed")  
  return  
}  
defer fdes.Close()  // 第二个defer  
fmt.Println("do something here")

如果一个函数里面有多个defer,那么在函数推出之前,会先执行最后一个defer,然后再执行倒数第二个、倒数第三个...,就像后进先出栈的操作。

我们下一篇聊聊通道和goroutine。

喜欢的点个关注!

上一篇:Go语言学习-函数


下一篇:Go语言学习-函数