人非圣贤孰能无过,Go lang1.18入门精炼教程,由白丁入鸿儒,Go lang错误处理机制EP11

简介: 人非圣贤,孰能无过,有则改之,无则加勉。在编程语言层面,错误处理方式大体上有两大流派,分别是以Python为代表的异常捕获机制(try....catch);以及以Go lang为代表的错误返回机制(return error),前者是自动化流程,模式化的语法隔离正常逻辑和错误逻辑,而后者,需要将错误处理判断编排在正常逻辑中。虽然模式化语法更容易让人理解,但从系统资源开销角度看,错误返回机制明显更具优势。

人非圣贤,孰能无过,有则改之,无则加勉。在编程语言层面,错误处理方式大体上有两大流派,分别是以Python为代表的异常捕获机制(try....catch);以及以Go lang为代表的错误返回机制(return error),前者是自动化流程,模式化的语法隔离正常逻辑和错误逻辑,而后者,需要将错误处理判断编排在正常逻辑中。虽然模式化语法更容易让人理解,但从系统资源开销角度看,错误返回机制明显更具优势。

返回错误

Go lang的错误(error)也是一种数据类型,错误用内置的error 类型表示,就像其他的数据类型的,比如字符串、整形之类,错误的具体值可以存储在变量中,从函数中返回:

package main  
  
import "fmt"  
  
func handle() (int, error) {  
    return 1, nil  
}  
  
func main() {  
    i, err := handle()  
    if err != nil {  
        fmt.Println("报错了")  
        return  
    }  
  
    fmt.Println("逻辑正常")  
    fmt.Println(i)  
}

程序返回:



逻辑正常  
1

这里的逻辑是,如果handle函数成功执行并且返回,那么入口函数就会正常打印返回值i,假设handel函数执行过程中出现错误,将返回一个非nil错误。

如果一个函数返回一个错误,那么理论上,它肯定是函数返回的最后一个值,因为在执行阶段中可能会返回正常的值,而错误位置是未知的,所以,handle函数返回的值是最后一个值。

go lang中处理错误的常见方式是将返回的错误与nil进行比较。nil值表示没有发生错误,而非nil值表示出现错误。在我们的例子中,我们检查错误是否为nil。如果它不是nil,我们会通过fmt.Println方法提醒用户并且从主函数返回,结束逻辑。

再来个例子:

package main  
  
import (  
    "fmt"  
    "net/http"  
)  
  
func main() {  
  
    resp, err := http.Get("123123")  
    if err != nil {  
        fmt.Println(err)  
        return  
    }  
  
    fmt.Println(resp.StatusCode)  
  
}

这回我们使用标准库包http向一个叫做123123的网址发起请求,当然了,请求过程中有可能发生一些未知错误,所以我们使用err变量获取Get方法的最后一个返回值,如果err不是nil,那么就说明请求过程中报错了,这里打印具体错误,然后从主函数中返回。

程序返回:

Get "123123": unsupported protocol scheme ""

很明显,肯定报错了,因为Go lang并不知道所谓的123123到底是什么网络协议。

具体错误类型

在Go lang中,错误本质上是一个接口:



type error interface {  
    Error() string  
}

包含一个带有Error字符串的函数。任何实现这个接口的类型都可以作为一个错误使用。这个函数可以打印出具体错误的说明。

当打印错误时,fmt.Println函数在内部调用Error() 方法来获取错误的说明:

Get "123123": unsupported protocol scheme ""

但有的时候,除了系统级别的错误说明,我们还需要针对错误进行分类,通过不同的错误类型的种类来决定下游的处理方式。

既然有了错误说明,为什么还需要错误类型,直接通过说明判断不就行了?这是因为系统的错误说明可能会随着go lang版本的迭代而略有不同,而一个错误的错误类型则大概率不会发生变化。

通过对标准库文档的解读:https://pkg.go.dev/net/http#ProtocolError,我们就可以对返回的错误类型进行判断:

package main  
  
import (  
    "fmt"  
    "net"  
    "net/http"  
)  
  
func main() {  
  
    resp, err := http.Get("123123")  
    if err, ok := err.(net.Error); ok && err.Timeout() {  
        fmt.Println("超时错误")  
        fmt.Println(err)  
  
    } else if err != nil {  
        fmt.Println("其他错误")  
        fmt.Println(err)  
    }  
  
    fmt.Println(resp.StatusCode)  
  
}

程序返回:

其他错误  
Get "123123": unsupported protocol scheme ""

这里我们把超时(Timeout)和其他错误区分开来,分别进入不同的错误处理逻辑。

定制错误

定制错误通过标准库errors为程序的错误做个性化定制,假设某个函数的作用是做除法运算,而如果除数为0,则返回一个错误:

package main  
  
import (  
    "errors"  
    "fmt"  
)  
  
func test(num1 int, num2 int) (int, error) {  
    if num2 == 0 {  
        return 0, errors.New("除数不能为0")  
    }  
    return num1 / num2, nil  
}  
  
func main() {  
  
    res, err := test(2, 1)  
    if err != nil {  
        fmt.Println(err)  
        return  
    }  
    fmt.Println("结果是", res)  
}

程序返回:

结果是 2

但如果参数不合法:

package main  
  
import (  
    "errors"  
    "fmt"  
)  
  
func test(num1 int, num2 int) (int, error) {  
    if num2 == 0 {  
        return 0, errors.New("除数不能为0")  
    }  
    return num1 / num2, nil  
}  
  
func main() {  
  
    res, err := test(2, 0)  
    if err != nil {  
        fmt.Println(err)  
        return  
    }  
    fmt.Println("结果是", res)  
}

程序返回:

除数不能为0

假设,出于某种原因,我们对除数有定制化需求,比如不能为0或者为1,但条件变成了多条件,此时需要将除数显性的展示在错误说明中,以便更具象化的提醒用户:

package main  
  
import (  
    "fmt"  
)  
  
func test(num1 int, num2 int) (int, error) {  
    if (num2 == 0) || (num2 == 1) {  
        return 0, fmt.Errorf("除数为%d,除数不能为0或者1", num2)  
    }  
    return num1 / num2, nil  
}  
  
func main() {  
  
    res, err := test(2, 1)  
    if err != nil {  
        fmt.Println(err)  
        return  
    }  
    fmt.Println("结果是", res)  
}

程序返回:

除数为1,除数不能为0或者1

这里使用fmt包的Errorf函数根据一个格式说明器格式化错误,并返回一个字符串作为值来满足错误。

此外,还可以使用使用结构体和结构体中的属性提供关于错误的更多信息:

type testError struct {  
    err string  
    num int  
}

这里定义结构体testError,里面两个属性,分别是错误说明和除数值。

随后,我们使用一个指针接收器区域错误来实现错误接口的Error() string方法。这个方法打印出错误的除数值和错误说明:

func (e *testError) Error() string {  
    return fmt.Sprintf("除数 %d:%s", e.num, e.err)  
}

接着通过结构体寻址调用:

func test(num1 int, num2 int) (int, error) {  
    if (num2 == 0) || (num2 == 1) {  
        return 0, &testError{"除数非法", num2}  
    }  
    return num1 / num2, nil  
}

完整代码:

package main  
  
import (  
    "fmt"  
)  
  
type testError struct {  
    err string  
    num int  
}  
  
func (e *testError) Error() string {  
    return fmt.Sprintf("除数 %d:%s", e.num, e.err)  
}  
  
func test(num1 int, num2 int) (int, error) {  
    if (num2 == 0) || (num2 == 1) {  
        return 0, &testError{"除数非法", num2}  
    }  
    return num1 / num2, nil  
}  
  
func main() {  
  
    res, err := test(2, 1)  
    if err != nil {  
        fmt.Println(err)  
        return  
    }  
    fmt.Println("结果是", res)  
}

程序返回:

除数 1:除数非法

通过结构体的定义,错误说明更加规整,并且更易于维护。

异常(panic/recover)

异常的概念是,本来不应该出现问题的地方出现了问题,某些情况下,当程序发生异常时,无法继续运行,此时,我们会使用 panic 来终止程序。当函数发生 panic 时,它会终止运行,在执行完所有的延迟函数后,程序返回到该函数的调用方,这样的过程会一直持续下去,直到当前协程的所有函数都返回退出,然后程序会打印出 panic 信息,接着打印出堆栈跟踪,最后程序终止:

package main  
  
import "fmt"  
  
func main() {  
  
    panic("panic error")  
  
    fmt.Println("下游逻辑")  
  
}

程序返回:

panic: panic error

可以看到,panic方法执行后,程序下游逻辑并未执行,所以panic使用场景是,当下游依赖上游的操作,而上游的问题导致下游无计可施的时候,使用panic抛出异常。

但延迟执行是个例外:

package main  
  
import "fmt"  
  
func myTest() {  
    defer fmt.Println("defer myTest")  
    panic("panic myTest")  
}  
func main() {  
    defer fmt.Println("defer main")  
    myTest()  
}

程序返回:

defer myTest  
defer main  
panic: panic myTest

这里当函数发生 panic 时,它会终止运行,在执行完所有的延迟函数后,程序返回到该函数的调用方,这样的过程会一直持续下去,直到当前协程的所有函数都返回退出,然后程序会打印出 panic 信息,接着打印出堆栈跟踪,最后程序终止。

此外,recover方法可以捕获异常的异常,从而打印异常信息后,继续执行下游逻辑:

package main  
  
import "fmt"  
  
func outOfArray(x int) {  
    defer func() {  
        // recover() 可以将捕获到的 panic 信息打印  
        if err := recover(); err != nil {  
            fmt.Println(err)  
        }  
    }()  
    var array [5]int  
    array[x] = 1  
}  
func main() {  
  
    outOfArray(20)  
  
    fmt.Println("下游逻辑")  
}

程序返回:

runtime error: index out of range [20] with length 5  
下游逻辑

结语

综上,Go lang的错误处理,属实不太优雅,大多数情况下会有很多重复代码:if err != nil,这在一定程度上影响了代码的可读性和可维护性,同时容易丢失底层错误类型,且定位错误时,很难得到错误链,也就是在一定程度上阻碍了错误的追根溯源,但反过来想,错误本来就是业务的一部分,从业务角度上看,Golang这种返回错误的方式更贴合业务逻辑,你可以用多返回值包含 error处理业务异常,用 recover 处理系统异常。业务异常,可以定义为不会引起系统崩溃下游瘫痪的异常;系统异常可以定义为会引起系统崩溃下游瘫痪的异常。所以,归根结底,一套功夫的威力,真的不在于其招式的设计,而在于运用功夫的那个人能否发挥这套武功的全部潜力。

相关文章
|
22天前
|
Cloud Native 安全 Java
Go语言深度解析:从入门到精通的完整指南
🌟蒋星熠Jaxonic,Go语言探索者。深耕云计算、微服务与并发编程,以代码为笔,在二进制星河中书写极客诗篇。分享Go核心原理、性能优化与实战架构,助力开发者掌握云原生时代利器。#Go语言 #并发编程 #性能优化
266 43
Go语言深度解析:从入门到精通的完整指南
|
5月前
|
人工智能 安全 算法
Go入门实战:并发模式的使用
本文详细探讨了Go语言的并发模式,包括Goroutine、Channel、Mutex和WaitGroup等核心概念。通过具体代码实例与详细解释,介绍了这些模式的原理及应用。同时分析了未来发展趋势与挑战,如更高效的并发控制、更好的并发安全及性能优化。Go语言凭借其优秀的并发性能,在现代编程中备受青睐。
178 33
|
1月前
|
Cloud Native 安全 Java
Go语言深度解析:从入门到精通的完整指南
🌟 蒋星熠Jaxonic,执着的星际旅人,用Go语言编写代码诗篇。🚀 Go语言以简洁、高效、并发为核心,助力云计算与微服务革新。📚 本文详解Go语法、并发模型、性能优化与实战案例,助你掌握现代编程精髓。🌌 从goroutine到channel,从内存优化到高并发架构,全面解析Go的强大力量。🔧 实战构建高性能Web服务,展现Go在云原生时代的无限可能。✨ 附技术对比、最佳实践与生态全景,带你踏上Go语言的星辰征途。#Go语言 #并发编程 #云原生 #性能优化
|
3月前
|
JSON 人工智能 Go
在Golang中序列化JSON字符串的教程
在Golang中,使用`json.Marshal()`可将数据结构序列化为JSON格式。若直接对JSON字符串进行序列化,会因转义字符导致错误。解决方案包括使用`[]byte`或`json.RawMessage()`来避免双引号被转义,从而正确实现JSON的序列化与反序列化。
163 7
|
5月前
|
Go 调度
GO语言函数的内部运行机制分析
以上就是Go语言中函数的内部运行机制的概述,展示了函数在Go语言编程中如何发挥作用,以及Go如何使用简洁高效的设计,使得代码更简单,更有逻辑性,更易于理解和维护。尽管这些内容深入了一些底层的概念,但我希望通过这种方式,将这些理论知识更生动、更形象地带给你,让你在理解的同时找到编程的乐趣。
83 5
|
5月前
|
安全 Go
defer关键字:延迟调用机制-《Go语言实战指南》
Go 语言中的 `defer` 是用于延迟执行函数调用的关键字,广泛应用于资源释放、异常捕获和日志记录等场景。它在函数返回前执行,支持栈式后进先出(LIFO)顺序,参数求值时机为声明时而非执行时。常见用法包括文件关闭、锁解锁及结合 `recover` 处理 panic。尽管高效,频繁使用可能带来性能开销,需谨慎处理。总结而言,`defer` 是构建健壮代码的核心工具之一。
|
6月前
|
存储 算法 数据可视化
【二叉树遍历入门:从中序遍历到层序与右视图】【LeetCode 热题100】94:二叉树的中序遍历、102:二叉树的层序遍历、199:二叉树的右视图(详细解析)(Go语言版)
本文详细解析了二叉树的三种经典遍历方式:中序遍历(94题)、层序遍历(102题)和右视图(199题)。通过递归与迭代实现中序遍历,深入理解深度优先搜索(DFS);借助队列完成层序遍历和右视图,掌握广度优先搜索(BFS)。文章对比DFS与BFS的思维方式,总结不同遍历的应用场景,为后续构造树结构奠定基础。
285 10
|
6月前
|
存储 算法 物联网
解析局域网内控制电脑机制:基于 Go 语言链表算法的隐秘通信技术探究
数字化办公与物联网蓬勃发展的时代背景下,局域网内计算机控制已成为提升工作效率、达成设备协同管理的重要途径。无论是企业远程办公时的设备统一调度,还是智能家居系统中多设备间的联动控制,高效的数据传输与管理机制均构成实现局域网内计算机控制功能的核心要素。本文将深入探究 Go 语言中的链表数据结构,剖析其在局域网内计算机控制过程中,如何达成数据的有序存储与高效传输,并通过完整的 Go 语言代码示例展示其应用流程。
121 0
|
14天前
|
存储 安全 Java
【Golang】(4)Go里面的指针如何?函数与方法怎么不一样?带你了解Go不同于其他高级语言的语法
结构体可以存储一组不同类型的数据,是一种符合类型。Go抛弃了类与继承,同时也抛弃了构造方法,刻意弱化了面向对象的功能,Go并非是一个传统OOP的语言,但是Go依旧有着OOP的影子,通过结构体和方法也可以模拟出一个类。
67 1
|
2月前
|
Cloud Native 安全 Java
Go:为云原生而生的高效语言
Go:为云原生而生的高效语言
250 1

热门文章

最新文章

推荐镜像

更多