How does the defer keyword work in Go and what problem does it solve in this code example?

How the Defer Keyword Works in Go

In Go, the defer keyword is used to defer the execution of a function call until the surrounding function returns. The parameters and function value of the deferred call are evaluated as usual when the defer statement is executed, but the actual function is invoked just before the surrounding function's return statement.

Evaluation Order

The evaluation order of statements with defer keyword follows a last-in, first-out (LIFO) approach. For example, consider the following code:

<code class="go">defer func1()()
defer func2()()
fmt.Println("main function")</code>

In this example, the call to func1() will be deferred and executed immediately before the return of the main function. Similarly, the call to func2() will be deferred and executed before the call to func1().

Real-World Example

A common use case for defer is to automatically release resources before a function returns. For example, a file handle can be opened at the beginning of a function and closed using defer before the function returns.

Deferring a Feature Implementation

Consider the example in the problem:

<code class="go">defer fmt.Println("Your age is:", getAge(age)) // calls getAge
defer fmt.Println("Your ticket price is:", printTicket(age, ticketprice)) // calls printTicket</code>

In this code, the call to getAge() is deferred before the call to printTicket(). This means that the evaluation of age and the calculation of ticketPrice will occur immediately, while the actual printing of the age and ticket price will be deferred until the function returns.

By using defer, you can ensure that the age and ticket price are always printed, even if an error occurs during the function execution.

Solution to the Problem

The original code in the problem had an issue where the printTicket function was not being called correctly for ages greater than 13. This was because the ticketPrice variable was being declared but never assigned a value. By using defer, we can ensure that the ticket price is calculated correctly before it is printed.

Here's a corrected version of the code:

<code class="go">package main

import "fmt"

func main() {
    var age int
    defer fmt.Println("Your age is:", getAge(&age))
    defer fmt.Println("Your ticket price is:", printTicket(age))
}

func printTicket(age int) float64 {
    var ticketPrice float64
    switch {
    case age <= 13:
        ticketPrice = 9.99
    case age > 13 && age < 65:
        ticketPrice = 19.99
    case age >= 65:
        ticketPrice = 12.99
    }
    return ticketPrice
}

func getAge(age *int) int {
    fmt.Println("What is your age?")
    fmt.Scan(age)
    for *age < 0 || *age > 100 {
        fmt.Println("That cannot be, please enter your age again")
        fmt.Scan(age)
    }
    return *age
}</code>

With this fix, the code will correctly print the ticket price based on the user's age.

The above is the detailed content of How does the defer keyword work in Go and what problem does it solve in this code example?. For more information, please follow other related articles on the PHP Chinese website!