Golang function error handling practice guide

Error Handling Practice Guide: Built-in Error Types: Use built-in types to create custom errors. error interface: Wrap errors using %w syntax to provide context. Check for errors: Use == nil to check if an error exists. Error Guard: Simplify error handling. Custom types: Create custom types to indicate errors and provide more information. Recovery: Use recover() to restore functions in the event of a panic.

Practical Guide to Handling Go Function Errors

Introduction

Getting it right in Go Handling errors is critical and can significantly improve the stability and maintainability of your application. This article introduces a variety of error handling techniques and provides practical examples to illustrate their use.

1. Built-in error types

Go provides several built-in error types, such as errors.New() and fmt. Errorf(""). We can create custom errors using these types.

2. error Interface

errorThe interface allows different error types to be compatible with each other. We can wrap errors to provide context by using the %w syntax.

Practical case 1:

import "errors"

func OpenFile(fname string) error {
    f, err := os.Open(fname)
    if err != nil {
        return errors.New("failed to open file: " + err.Error())
    }
    return nil
}

3. Check for errors

We can use== nil check for errors. If it is nil, it means there is no error.

Practical case 2:

func OpenFile(fname string) *os.File {
    f, err := os.Open(fname)
    if err != nil {
        return nil
    }
    return f
}

4. Error guard

Error guard syntax (if err := f(); err != nil { ... }) provides a simplified error handling method.

Practical case 3:

func OpenFile(fname string) (*os.File, error) {
    if f, err := os.Open(fname); err != nil {
        return nil, err
    } else {
        return f, nil
    }
}

5. Custom type

We can create a custom type to represent errors, and provide additional information.

Practical Case 4:

type FileError struct {
    fname string
    err   error
}

func (e FileError) Error() string {
    return fmt.Sprintf("failed to open file %s: %s", e.fname, e.err)
}

func OpenFile(fname string) (*os.File, error) {
    f, err := os.Open(fname)
    if err != nil {
        return nil, &FileError{fname, err}
    }
    return f, nil
}

6. Recovery

Userecover() Can be done in Resume function in case of panic.

Practical case 5:

func OpenFile(fname string) *os.File {
    defer func() {
        if r := recover(); r != nil {
            fmt.Printf("recover: %s\n", r)
        }
    }()
    f, err := os.Open(fname)
    if err != nil {
        panic(err)
    }
    return f
}

The above is the detailed content of Golang function error handling practice guide. For more information, please follow other related articles on the PHP Chinese website!