Golang 中的 defer 语句和panic有什么区别？

In Golang, both the defer statement and panic are important features related to program control flow, but their purposes and behaviors have significant differences.

defer Statement

The defer statement ensures that a block of code executes before a function returns, regardless of whether the function exits normally or due to an error. It is commonly used for resource cleanup, such as closing file handles, unlocking mutexes, or performing necessary cleanup tasks.

Example:

go
func readFile(filename string) {
    f, err := os.Open(filename)
    if err != nil {
        panic(err)
    }

    defer f.Close() // Ensures the file descriptor is properly closed before the function exits

    // Perform file reading
}

In this example, regardless of how the readFile function exits, defer f.Close() ensures that the file descriptor is properly closed, preventing resource leaks.

panic

panic is a mechanism for handling unrecoverable error situations. When a program encounters an error that prevents further execution, it can call panic to interrupt the current control flow, immediately starting to unwind the stack until it is caught by recover or causes the program to crash. panic can pass any type of parameter, typically an error or string, to convey error information.

Example:

go
func processRecord(id string) {
    record, err := getRecord(id)
    if err != nil {
        panic(fmt.Sprintf("failed to get record: %v", err))
    }

    // Process the record
}

In this example, if the getRecord function encounters an error, processRecord interrupts execution by calling panic and provides error details.

Interaction Between Them

When using panic and defer, if a panic occurs within a function, the defer statement is still executed. This provides great convenience for resource cleanup, even when errors occur.

Example:

go
func riskyOperation() {
    defer fmt.Println("cleaning up...")
    fmt.Println("attempting risky operation")
    panic("something bad happened")
}

func main() {
    defer fmt.Println("deferred in main")
    riskyOperation()
}

In this example, even if a panic occurs within the riskyOperation function, its internal defer statement is still executed, and the program terminates afterward unless other recover statements handle the panic.

In summary, defer is primarily used to ensure code execution integrity, even when errors occur; while panic is used to handle unrecoverable errors, providing a way to forcibly interrupt program execution. When used appropriately, both can make programs more robust when facing errors.