Exception handling of golang function type

Function types cannot directly throw exceptions in Go language. There are two ways to handle exceptions: Return error type: The function can return an error value, and if there is an error, it returns error information. Use the panic function: triggering panic can pass an exception, but use it with caution as it will terminate the program.

Function type exception handling in Go language

Function type is very common in Go language. It allows us to create functions that can be passed to other functions as parameters. Returns or stores a function value as a variable.

However, when using function types to handle errors, we need special handling. Unlike ordinary functions, function types cannot throw exceptions. To solve this problem, we can use the error type.

How to handle function type exceptions

There are two main ways to handle function type exceptions:

1. Use the error type: We can have the function type return an error value, and if an error occurs, return the corresponding error.
2. Using the panic function: We can use the panic function to raise and propagate exceptions, but use it with caution because panic will terminate the entire program.

Practical case

We create a function type mathOperation, which accepts two integers and performs the specified mathematical operation:

type mathOperation func(int, int) int

We Define three functions that perform addition, subtraction, and division operations respectively:

func add(a, b int) int {
    return a + b
}

func subtract(a, b int) int {
    return a - b
}

func divide(a, b int) int {
    if b == 0 {
        panic("cannot divide by zero")
    }
    return a / b
}

We can then use these functions as values ​​of type mathOperation:

var addOperation mathOperation = add
var subtractOperation mathOperation = subtract
var divideOperation mathOperation = divide

If we Trying to divide by 0, divideOperation will cause a panic:

result := divideOperation(10, 0) // 会引发 panic

We can capture and process this by using the recover function panic:

func main() {
    defer func() {
        if err := recover(); err != nil {
            log.Println("Error:", err)
        }
    }()

    result := divideOperation(10, 0)
    fmt.Println(result)
}

Output:

Error: cannot divide by zero

Alternatively, we can handle errors by using the error type:

func divideChecked(a, b int) (int, error) {
    if b == 0 {
        return 0, errors.New("cannot divide by zero")
    }
    return a / b, nil
}

func main() {
    result, err := divideChecked(10, 0)
    if err != nil {
        log.Println("Error:", err)
    } else {
        fmt.Println(result)
    }
}

Output:

Error: cannot divide by zero

The above is the detailed content of Exception handling of golang function type. For more information, please follow other related articles on the PHP Chinese website!