《Golang入门系列》Golang的错误和异常处理

最新推荐文章于 2023-02-26 11:54:58 发布
最新推荐文章于 2023-02-26 11:54:58 发布
阅读量1.8k 收藏 2
点赞数
分类专栏： Golang系列 文章标签： go
原文链接：https://www.cnblogs.com/zhangboyu/p/7911190.html
版权

本文转载：https://www.cnblogs.com/zhangboyu/p/7911190.html

  • 错误指的是可能出现问题的地方出现了问题，比如打开一个文件时失败，这种情况在人们的意料之中
  • 异常指的是不应该出现问题的地方出现了问题，比如引用了空指针，这种情况在人们的意料之外。
    可见，错误是业务过程的一部分，而异常不是 。

Golang中引入error接口类型作为错误处理的标准模式，如果函数要返回错误，则返回值类型列表中肯定包含error。error处理过程类似于C语言中的错误码，可逐层返回，直到被处理。

Golang中引入两个内置函数panic和recover来触发和终止异常处理流程，同时引入关键字defer来延迟执行defer后面的函数。
一直等到包含defer语句的函数执行完毕时，延迟函数（defer后的函数）才会被执行，而不管包含defer语句的函数是通过return的正常结束，还是由于panic导致的异常结束。你可以在一个函数中执行多条defer语句，它们的执行顺序与声明顺序相反。
当程序运行时，如果遇到引用空指针、下标越界或显式调用panic函数等情况，则先触发panic函数的执行，然后调用延迟函数。调用者继续传递panic，因此该过程一直在调用栈中重复发生：函数停止执行，调用延迟执行函数等。如果一路在延迟函数中没有recover函数的调用，则会到达该携程的起点，该携程结束，然后终止其他所有携程，包括主携程（类似于C语言中的主线程，该携程ID为1）。

错误和异常从Golang机制上讲，就是error和panic的区别。很多其他语言也一样，比如C++/Java，没有error但有errno，没有panic但有throw。

Golang错误和异常是可以互相转换的：

  • 错误转异常，比如程序逻辑上尝试请求某个URL，最多尝试三次，尝试三次的过程中请求失败是错误，尝试完第三次还不成功的话，失败就被提升为异常了。

  • 异常转错误，比如panic触发的异常被recover恢复后，将返回值中error类型的变量进行赋值，以便上层函数继续走错误处理流程。

Golang的错误处理

Golang错误处理方式一直是很多人诟病的地方，有些人吐槽说一半的代码都是"if err != nil { / 打印 && 错误处理 / }"，严重影响正常的处理逻辑。当我们区分错误和异常，根据规则设计函数，就会大大提高可读性和可维护性。

正确的错误处理姿势

  1. 失败的原因只有一个时，不使用error
func (self *AgentContext) CheckHostType(host_type string) error {
    switch host_type {
    case "virtual_machine":
        return nil
    case "bare_metal":
        return nil
    }
    return errors.New("CheckHostType ERROR:" + host_type)
}

我们可以看出，该函数失败的原因只有一个，所以返回值的类型应该为bool，而不是error，重构一下代码：

func (self *AgentContext) IsValidHostType(hostType string) bool {
    return hostType == "virtual_machine" || hostType == "bare_metal"
}

说明：大多数情况，导致失败的原因不止一种，尤其是对I/O操作而言，用户需要了解更多的错误信息，这时的返回值类型不再是简单的bool，而是error。

  1. 没有失败时，不使用error
    error在Golang中是如此的流行，以至于很多人设计函数时不管三七二十一都使用error，即使没有一个失败原因。
    示例代码：
func (self *CniParam) setTenantId() error {
    self.TenantId = self.PodNs
    return nil
}

对于上面的函数设计，就会有下面的调用代码，真是傻瓜式代码

err := self.setTenantId()
if err != nil {
    // log
    // free resource
    return errors.New(...)
}

  1. error应放到返回值类型列表的最后

  2. 误值应该统一定义，而不是胡乱定义
    很多人写代码时，到处return errors.New(value)，而错误value在表达同一个含义时也可能形式不同，比如“记录不存在”的错误value可能为：

  • “record is not existed.”

  • “record is not exist!”

  • “###record is not existed！！！”

这使得相同的错误value撒在一大片代码里，当上层函数要对特定错误value进行统一处理时，需要漫游所有下层代码，以保证错误value统一，不幸的是有时会有漏网之鱼，而且这种方式严重阻碍了错误value的重构。

于是，我们可以参考C/C++的错误码定义文件，在Golang的每个包中增加一个错误对象定义文件，如下所示：

var ERR_EOF = errors.New("EOF")
var ERR_CLOSED_PIPE = errors.New("io: read/write on closed pipe")
var ERR_NO_PROGRESS = errors.New("multiple Read calls return no data or error")
var ERR_SHORT_BUFFER = errors.New("short buffer")
var ERR_SHORT_WRITE = errors.New("short write")
var ERR_UNEXPECTED_EOF = errors.New("unexpected EOF")

  1. 错误逐层传递时，层层都加日志

  2. 错误处理使用defer
    我们一般通过判断error的值来处理错误，如果当前操作失败，需要将本函数中已经create的资源destroy掉，示例代码如下：

func deferDemo() error {
    err := createResource1()
    if err != nil {
        return ERR_CREATE_RESOURCE1_FAILED
    }
    err = createResource2()
    if err != nil {
        destroyResource1()
        return ERR_CREATE_RESOURCE2_FAILED
    }

    err = createResource3()
    if err != nil {
        destroyResource1()
        destroyResource2()
        return ERR_CREATE_RESOURCE3_FAILED
    }

    err = createResource4()
    if err != nil {
        destroyResource1()
        destroyResource2()
        destroyResource3()
        return ERR_CREATE_RESOURCE4_FAILED
    }
    return nil
}

当Golang的代码执行时，如果遇到defer的闭包调用，则压入堆栈。当函数返回时，会按照后进先出的顺序调用闭包。
对于闭包的参数是值传递，而对于外部变量却是引用传递，所以闭包中的外部变量err的值就变成外部函数返回时最新的err值。
根据这个结论，我们重构上面的示例代码：

func deferDemo() error {
    err := createResource1()
    if err != nil {
        return ERR_CREATE_RESOURCE1_FAILED
    }
    defer func() {
        if err != nil {
            destroyResource1()
        }
    }()
    err = createResource2()
    if err != nil {
        return ERR_CREATE_RESOURCE2_FAILED
    }
    defer func() {
        if err != nil {
            destroyResource2()
        }
    }()

    err = createResource3()
    if err != nil {
        return ERR_CREATE_RESOURCE3_FAILED
    }
    defer func() {
        if err != nil {
            destroyResource3()
        }
    }()

    err = createResource4()
    if err != nil {
        return ERR_CREATE_RESOURCE4_FAILED
    }
    return nil
}
  1. 当尝试几次可以避免失败时，不要立即返回错误
  2. 当上层函数不关心错误时，建议不返回error
  3. 当发生错误时，不忽略有用的返回值

Golang的异常处理

  1. 在程序开发阶段，坚持速错
    在早期开发以及任何发布阶段之前，最简单的同时也可能是最好的方法是调用panic函数来中断程序的执行以强制发生错误，使得该错误不会被忽略，因而能够被尽快修复。

  2. 在程序部署后，应该恢复异常，避免程序终止
    Goroutine如果panic了，并且没有recover，那么整个Golang进程（类似Erlang节点）就会异常退出。所以，一旦Golang程序部署后，在任何情况下发生的异常都不应该导致程序异常退出，我们在上层函数中加一个延迟执行的recover调用来达到这个目的，并且是否进行recover需要根据环境变量或配置文件来定，默认需要recover。
    这个姿势类似于C语言中的断言，但还是有区别：一般在Release版本中，断言被定义为空而失效，但需要有if校验存在进行异常保护，尽管契约式设计中不建议这样做。在Golang中，recover完全可以终止异常展开过程，省时省力。

我们在调用recover的延迟函数中以最合理的方式响应该异常：

  • 打印堆栈的异常调用信息和关键的业务信息，以便这些问题保留可见；
  • 将异常转换为错误，以便调用者让程序恢复到健康状态并继续安全运行。

我们看一个简单的例子：

func funcA() error {
    defer func() {
        if p := recover(); p != nil {
            fmt.Printf("panic recover! p: %v", p)
            // debug.PrintStack()
        }
    }()
    return funcB()
}

func funcB() error {
    // simulation
    panic("foo")
    return errors.New("success")
}

func test() {
    err := funcA()
    if err == nil {
        fmt.Printf("err is nil\\n")
    } else {
        fmt.Printf("err is %v\\n", err)
    }
}

我们期望test函数的输出是：

err is foo

实际上test函数的输出是：

err is nil

原因是panic异常处理机制不会自动将错误信息传递给error，所以要在funcA函数中进行显式的传递，代码如下所示：

func funcA() (err error) {
    defer func() {
        if p := recover(); p != nil {
            fmt.Println("panic recover! p:", p)
            str, ok := p.(string)
            if ok {
                err = errors.New(str)
            } else {
                err = errors.New("panic")
            }
            debug.PrintStack()
        }
    }()
    return funcB()
}
  1. 对于不应该出现的分支，使用异常处理
    当某些不应该发生的场景发生时，我们就应该调用panic函数来触发异常。比如，当程序到达了某条逻辑上不可能到达的路径：
switch s := suit(drawCard()); s {
    case "Spades":
    // ...
    case "Hearts":
    // ...
    case "Diamonds":
    // ... 
    case "Clubs":
    // ...
    default:
        panic(fmt.Sprintf("invalid suit %v", s))
}
  1. 针对入参不应该有问题的函数，使用panic设计

入参不应该有问题一般指的是硬编码，我们先看“一个启示”一节中提到的两个函数（Compile和MustCompile），其中MustCompile函数是对Compile函数的包装：

func MustCompile(str string) *Regexp {
    regexp, error := Compile(str)
    if error != nil {
        panic(`regexp: Compile(` + quote(str) + `): ` + error.Error())
    }
    return regexp
}

所以，对于同时支持用户输入场景和硬编码场景的情况，一般支持硬编码场景的函数是对支持用户输入场景函数的包装。
对于只支持硬编码单一场景的情况，函数设计时直接使用panic，即返回值类型列表中不会有error，
这使得函数的调用处理非常方便（没有了乏味的"if err != nil {/ 打印 && 错误处理 /}"代码块）。

oneone7
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
深入理解golang的异常处理机制
01-01
前言 ...在go语言中，panic和recover函数在作用层面分别对等throw和catch语句，当然也存在不同之处。...上述两种异常机制的使用中，在处理异常时控制流程的走向也是相似的。 下面将分别举例说明： try catch finally机
golang异常处理详解
机智的程序员小熊
05-28 3173
小熊今天有意外收获，忍不住给大家分享我愉快的心情！昨天中午下楼取外卖的时候被一个同事认出来了，他问我：“是不是【编程三分钟】的作者，文章写的不错”。 你知道吗！我当时就是一愣，然后差点感动到哭出来，虽然小熊的号比不上大牛的号，不能随便发一篇文章都有成千上万的阅读量；但是非常开心的是，我还有你们，默默的关注我，爱你们~！ 今天想和大家聊聊 golang 的异常处理 异常处理思想 在 go 语言里是没有 try catch 的概念的，因为 try catch 会消耗更多资源，而且不管从 try 里面哪个地方跳出
golang异常处理 panic、defer、recover
是鲤鱼啊
11-19 3021
异常的使用场景可以这么简单描述：Go中抛出一个panic的异常，然后在defer中通过recover捕获这个异常，然后正常处理。 golang的defer机制详解_zhongcanw的博客-CSDN博客 例 1.defer defer是golang的一个特色功能，被称为“延迟调用函数”. ①延迟函数的参数在defer语句出现时就已经确定下来了 ...
Go_异常处理
itzhuzhu的博客
02-06 2328
异常就是程序出现了不正常的情况，会导致程序非正常停止，而异常处理就是针对非正常停止的情况，给出异常时的处理方式。语法错误不算异常体系中
golang中异常处理
LeoHan
05-03 2515
程序在运行过程中如果出现了问题，可以通过抛出异常、捕获异常来进行异常的处理，在golang中，异常的接口为error: type error interface { Error() string } 因此，只要一个结构体实现了Error() string方法，就是实现了error接口： type MyError struct { } func (err *MyError)Error() string{ return "this is MyError" } golang中可以通过panic来抛出异常
教你如何优雅处理Golang中的异常
Free雅轩的博客
02-26 857
我们在使用Golang时，不可避免会遇到异常情况的处理，与Java、Python等语言不同的是，Go中并没有try...catch...这样的语句块，我们知道在Java中使用try...catch...这种模式不仅能分离的错误与返回值和参数，也提供了结构化处理异常的可能，通过面向对象的思想，我们可以自定义错误类、子类，它们又可以包装其他错误，确保错误上下文不会丢失。当然，这种方式是有一定局限性的，它只能在对于同一个业务对象的不断操作下可以简化错误处理，对于多个业务对象的话，还是得需要各种 if err!
Golang中重复错误处理的优化方法
09-19
主要给大家介绍了关于Golang中重复错误处理优化的相关资料，文中通过示例代码介绍的非常详细，对大家学习或者使用Golang具有一定的参考学习价值，需要的朋友们下面来一起学习学习吧
Golang巧用defer进行错误处理的方法
12-31
本文主要跟大家介绍了Golang巧用defer进行错误处理的相关内容，分享出来供大家参考学习，下面来看看详细的介绍： 问题引入 毫无疑问，错误处理是程序的重要组成部分，有效且优雅的处理错误是大多数程序员的追求。很...
利用golang实现封装trycatch异常处理实例代码
09-21
Go语言追求简洁优雅，所以go语言不支持传统的 try…catch…finally 这种异常，最近发现了不错的trycatch包，下面这篇文章主要跟大家分享了关于利用golang实现封装trycatch异常处理的实例代码，需要的朋友可以参考下...
Golang 错误处理机制详解
neweastsun的专栏
11-28 1293
本文介绍Golang错误处理机制，包括不同类型错误处理、定义运行时错误等内容。
Go的研习笔记-day11（以Java的视角学习Go）
小诚信驿站
08-14 360
错误处理与测试 Go 没有像 Java 和 .NET 那样的 try/catch 异常机制：不能执行抛异常操作。但是有一套 defer-panic-and-recover 机制 Go为什么不使用try/catch机制 Go 的设计者觉得 try/catch 机制的使用太泛滥了，而且从底层向更高的层级抛异常太耗费资源。他们给 Go 设计的机制也可以 “捕捉” 异常，但是更轻量，并且只应该作为（...
golang中的异常处理和异常使用
weixin_59244784的博客
06-08 1891
golang中的异常处理和异常使用
【跟着我们学Golang】之异常处理
weixin_34161032的博客
05-28 242
Java中的异常分为Error和Exception来处理，这里也以错误和异常两种，来分别讲一讲Go的异常处理。 Go 语言没有类似 Java 或 .NET 中的异常处理机制，虽然可以使用 defer、panic、recover 模拟，但官方并不主张这样做。Go 语言的设计者认为其他语言的异常机制已被过度使用，上层逻辑需要为函数发生的异常付出太多的资源。同时，如果函数使用者觉得错误处理很麻烦而忽略...
golang错误处理机制（异常处理）
学亮编程手记
10-17 2072
看一段代码,引入错误处理 对上面代码的总结： 在默认情况下,当发生错误后(panic) ,程序就会退出(崩溃.) 如果我们希望:当发生错误后,可以捕获到错误,并进行处理,保证程序可以继续执行。还可 以在捕获到错误后,给管理员一个提示(邮件,短信。。。) 这里引出我们要将的错误处理机制 错误处理基本说明 Go 语言追求简洁优雅,所以,Go 语言不支持传统的 try…catch…finally 这种处理。 Go 中引入的处理方式为:defer, panic, recover 这几个异常的使用场景可以
golang 错误处理
qq_49723651的博客
01-22 1431
文章目录panic 和 recovererror错误和异常 panic 和 recover panic 和 recover 的函数签名如下： panic(i nterface{}) revover()interface{} panic的引发 1.程序主动调用panic函数。 2.程序产生运行时错误，由运行时检测并抛出。 发生panic后，程序会从调用panic的函数位置或发生panic的地方立即返回，逐层向上执行函数的defer语句，然后逐层打印函数调用堆栈，直到被recover捕获或运行到最外层
golang基础之异常处理
叱咤少帅的博客
10-19 359
222
golang panic recover自定义异常处理
xiaofeixia666888的博客
05-24 649
golang异常处理
Golang 错误和异常
发现问题，面对问题，分析问题，解决问题，总结问题
05-03 1812
在Go语言中，错误和异常是不相同的俩个概念。错误被认为是一种可以预期的结果；而异常则是一种非预期的结果， 发生异常可能表示程序中存在BUG或发生了其它不可控的问题。Go语言推荐使 用 recover 函数将内部异常转为错误处理，这使得用户可以真正的关心业务相关的错误处理。
Go语言中为什么fmt.Fprintln(...)会有告警，而fmt.Println(...)却没有？
热门推荐
菜鸟六十八@驿站
04-30 2万+
问题描述： 环境：Windows10 + GoLand 2019.3.4 x64 + Golang 现象： 在使用fmt包，调用fmt.Fprintln(…)写文件时，如果不接受函数的返回值，编辑器会提示Unhandled error错误 而对于fmt.Println(…) 则不会提示 问题分析： 我们来看一下源码 // Fprintln formats using the default f...
golang错误处理
最新发布
11-09
olang错误处理机制是通过error类型来实现的。在Golang中，函数可以返回一个error类型的值，...总的来说，Golang的错误处理机制相对简单，但是通过error类型、panic和recover函数的组合使用，可以实现灵活的错误处理。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值