创建打开文件msvbvm60.dll错误_程序猿学GO：错误处理

五：错误处理

错误表示程序中出现了异常情况。比如当我们试图打开一个文件时，文件系统里却并没有这个文件。这就是异常情况，它用一个错误来表示。 在 Go 中，错误一直是很常见的。错误用内建的 error 类型来表示。

就像其他的内建类型（如 int、float64 等），错误值可以存储在变量里、作为函数的返回值等等。

现在我们开始编写一个示例，该程序试图打开一个并不存在的文件。

package main
 
import (  
    "fmt"
    "os"
)
 
func main() {  
    f, err := os.Open("/test.txt")
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Println(f.Name(), "opened successfully")
}

在程序的第 9 行，我们试图打开路径为 /test.txt 的文件（playground 显然并不存在这个文件）。os 包里的 Open 函数有如下签名：

func Open(name string) (file *File, err error)

如果成功打开文件，Open 函数会返回一个文件句柄（File Handler）和一个值为 nil 的错误。而如果打开文件时发生了错误，会返回一个不等于 nil 的错误。

如果一个函数 或方法返回了错误，按照惯例，错误会作为最后一个值返回。于是 Open 函数也是将 err 作为最后一个返回值。

按照 Go 的惯例，在处理错误时，通常都是将返回的错误与 nil 比较。nil 值表示了没有错误发生，而非 nil 值表示出现了错误。在这里，我们第 10 行检查了错误值是否为 nil。如果不是 nil，我们会简单地打印出错误，并在 main 函数中返回。

• 错误类型的表示

让我们进一步深入，理解 error 类型是如何定义的。error 是一个接口类型，定义如下：

type error interface {  
    Error() string
}

error 有了一个签名为 Error() string 的方法。所有实现该接口的类型都可以当作一个错误类型。Error() 方法给出了错误的描述。

fmt.Println 在打印错误时，会在内部调用 Error() string 方法来得到该错误的描述。上一节示例中的第 11 行，就是这样打印出错误的描述的。

1. 断言底层结构体类型，使用结构体字段获取更多信息

如果你仔细阅读了 Open 函数的文档，你可以看见它返回的错误类型是 *PathError。PathError 是结构体类型，它在标准库中的实现如下：

type PathError struct {  
    Op   string
    Path string
    Err  error
}

func (e *PathError) Error() string { return e.Op + " " + e.Path + ": " + e.Err.Error() }

通过上面的代码，你就知道了 *PathError 通过声明 Error() string 方法，实现了 error 接口。Error() string 将文件操作、路径和实际错误拼接，并返回该字符串。

• 自定义错误的实现

使用 New 函数创建自定义错误

创建自定义错误最简单的方法是使用 errors 包中的 New 函数。

在使用 New 函数 创建自定义错误之前，我们先来看看 New 是如何实现的。如下所示，是 errors 包 中的 New 函数的实现。

// Package errors implements functions to manipulate errors.
package errors
 
// New returns an error that formats as the given text.
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
}

New 函数的实现很简单。errorString 是一个结构体类型，只有一个字符串字段 s。第 14 行使用了 errorString 指针接受者（Pointer Receiver），来实现 error 接口的 Error() string 方法。

第 5 行的 New 函数有一个字符串参数，通过这个参数创建了 errorString 类型的变量，并返回了它的地址。于是它就创建并返回了一个新的错误。

现在我们已经知道了 New 函数是如何工作的，我们开始在程序里使用 New 来创建自定义错误吧。

我们将创建一个计算圆半径的简单程序，如果半径为负，它会返回一个错误。

package main
import (  
    "errors"
    "fmt"
    "math"
)
func circleArea(radius float64) (float64, error) {  
    if radius < 0 {
        return 0, errors.New("Area calculation failed, radius is less than zero")
    }
    return math.Pi * radius * radius, nil
}
func main() {  
    radius := -20.0
    area, err := circleArea(radius)
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Printf("Area of circle %0.2f", area)
}

使用 Errorf 给错误添加更多信息

上面的程序效果不错，但是如果我们能够打印出当前圆的半径，那就更好了。这就要用到 fmt 包中的 Errorf 函数了。Errorf 函数会根据格式说明符，规定错误的格式，并返回一个符合该错误的字符串。

接下来我们使用 Errorf 函数来改进我们的程序。

package main
 
import (  
    "fmt"
    "math"
)
 
func circleArea(radius float64) (float64, error) {  
    if radius < 0 {
        return 0, fmt.Errorf("Area calculation failed, radius %0.2f is less than zero", radius)
    }
    return math.Pi * radius * radius, nil
}
 
func main() {  
    radius := -20.0
    area, err := circleArea(radius)
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Printf("Area of circle %0.2f", area)
}
 

• 使用结构体类型和字段提供错误的更多信息

错误还可以用实现了 error 接口的结构体来表示。这种方式可以更加灵活地处理错误。在上面例子中，如果我们希望访问引发错误的半径，现在唯一的方法就是解析错误的描述信息 Area calculation failed, radius -20.00 is less than zero。这样做不太好，因为一旦描述信息发生变化，程序就会出错。

我们会创建一个实现 error 接口的结构体类型，并使用它的字段来提供关于错误的更多信息。

第一步就是创建一个表示错误的结构体类型。错误类型的命名约定是名称以 Error 结尾。因此我们不妨把结构体类型命名为 areaError。

type areaError struct {  
    err    string
    radius float64
}

上面的结构体类型有一个 radius 字段，它存储了与错误有关的半径，而 err 字段存储了实际的错误信息。

下一步是实现 error 接口。

func (e *areaError) Error() string {  
    return fmt.Sprintf("radius %0.2f: %s", e.radius, e.err)
}

在上面的代码中，我们使用指针接收者 *areaError，实现了 error 接口的 Error() string 方法。该方法打印出半径和关于错误的描述。

现在我们来编写 main 函数和 circleArea 函数来完成整个程序。

package main
 
import (  
    "fmt"
    "math"
)
 
type areaError struct {  
    err    string
    radius float64
}
 
func (e *areaError) Error() string {  
    return fmt.Sprintf("radius %0.2f: %s", e.radius, e.err)
}
 
func circleArea(radius float64) (float64, error) {  
    if radius < 0 {
        return 0, &areaError{"radius is negative", radius}
    }
    return math.Pi * radius * radius, nil
}
 
func main() {  
    radius := -20.0
    area, err := circleArea(radius)
    if err != nil {
        if err, ok := err.(*areaError); ok {
            fmt.Printf("Radius %0.2f is less than zero", err.radius)
            return
        }
        fmt.Println(err)
        return
    }
    fmt.Printf("Area of rectangle1 %0.2f", area)
}
 

在 main 函数的 26 行，我们试图计算半径为 -20 的圆的面积。由于半径小于零，因此会导致一个错误。

我们在第 27 行检查了错误是否为 nil，并在下一行断言了 *areaError 类型。如果错误是 *areaError 类型，我们就可以用 err.radius 来获取错误的半径（第 29 行），打印出自定义错误的消息，最后程序返回退出。

如果断言错误，我们就在第 32 行打印该错误，并返回。如果没有发生错误，在第 35 行会打印出面积。

• 使用结构体类型的方法来提供错误的更多信息

第一步就是创建一个表示错误的结构体。

type areaError struct {  
    err    string //error description
    length float64 //length which caused the error
    width  float64 //width which caused the error
}

上面的结构体类型除了有一个错误描述字段，还有可能引发错误的宽和高。

现在我们有了错误类型，我们来实现 error 接口，并给该错误类型添加两个方法，使它提供了更多的错误信息。

func (e *areaError) Error() string {  
    return e.err
}
func (e *areaError) lengthNegative() bool {  
    return e.length < 0
}
func (e *areaError) widthNegative() bool {  
    return e.width < 0
}

在上面的代码片段中，我们从 Error() string 方法中返回了关于错误的描述。当 length 小于零时，lengthNegative() bool 方法返回 true，而当 width 小于零时，widthNegative() bool 方法返回 true。这两个方法都提供了关于错误的更多信息，在这里，它提示我们计算面积失败的原因（长度为负数或者宽度为负数）。于是我们就有了两个错误类型结构体的方法，来提供更多的错误信息。

func rectArea(length, width float64) (float64, error) {  
    err := ""
    if length < 0 {
        err += "length is less than zero"
    }
    if width < 0 {
        if err == "" {
            err = "width is less than zero"
        } else {
            err += ", width is less than zero"
        }
    }
    if err != "" {
        return 0, &areaError{err, length, width}
    }
    return length * width, nil
}

上面的 rectArea 函数检查了长或宽是否小于零，如果小于零，rectArea 会返回一个错误信息，否则 rectArea 会返回矩形的面积和一个值为 nil 的错误。

让我们创建 main 函数来完成整个程序。

func main() {  
    length, width := -5.0, -9.0
    area, err := rectArea(length, width)
    if err != nil {
        if err, ok := err.(*areaError); ok {
            if err.lengthNegative() {
                fmt.Printf("error: length %0.2f is less than zeron", err.length)
 
            }
            if err.widthNegative() {
                fmt.Printf("error: width %0.2f is less than zeron", err.width)
 
            }
            return
        }
        fmt.Println(err)
        return
    }
    fmt.Println("area of rect", area)
}

在 main 程序中，我们检查了错误是否为 nil（第 4 行）。如果错误值不是 nil，我们会在下一行断言 *areaError 类型。然后，我们使用 lengthNegative() 和 widthNegative() 方法，检查错误的原因是长度小于零还是宽度小于零。这样我们就使用了错误结构体类型的方法，来提供更多的错误信息。

如果没有错误发生，就会打印矩形的面积。