{"id":242,"date":"2024-09-14T09:46:44","date_gmt":"2024-09-14T02:46:44","guid":{"rendered":"https:\/\/gotutorial.org\/?page_id=242"},"modified":"2024-09-27T11:28:23","modified_gmt":"2024-09-27T04:28:23","slug":"go-defer","status":"publish","type":"page","link":"https:\/\/www.gotutorial.org\/go-tutorial\/go-defer\/","title":{"rendered":"Go defer"},"content":{"rendered":"\n

Summary<\/strong>: in this tutorial, you will learn how to use the Go defer<\/code> keyword to defer the execution of a function until the surrounding function completes.<\/p>\n\n\n\n

Introduction to Go defer keyword<\/h2>\n\n\n\n

The defer<\/code> keyword schedules a function<\/a> call to be executed after the surrounding function completes.<\/p>\n\n\n\n

Here’s the syntax of the defer<\/code> keyword:<\/p>\n\n\n

func<\/span> outer<\/span>()<\/span><\/span> {\n    defer<\/span> inner()\n    \/\/ function body<\/span>\n    \/\/ ...<\/span>\n}<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
In this syntax, the defer<\/code> keyword schedules the inner()<\/code> function to run at the outer()<\/code> function exit<\/em>.<\/p>\n\n\n\n
Go will execute the outer()<\/code> function body first and then run the inner()<\/code> function.<\/p>\n\n\n\n
It’s important to notice that Go always executes the inner()<\/code> function regardless of how the outer()<\/code> function returns. For example:<\/p>\n\n\n
package<\/span> main\n\nimport<\/span> \"fmt\"<\/span>\n\nfunc<\/span> exit<\/span>()<\/span><\/span> {\n    fmt.Println(\"Bye!\"<\/span>)\n}\n\nfunc<\/span> sayHi<\/span>()<\/span> bool<\/span><\/span> {\n    defer<\/span> exit()\n    fmt.Println(\"Hi there\"<\/span>)\n    return<\/span> true<\/span>\n    \/\/ always execute the exit function<\/span>\n    \/\/ exit()<\/span>\n}\n\nfunc<\/span> main<\/span>()<\/span><\/span> {\n    sayHi()\n}<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
Output:<\/p>\n\n\n
Hi there\nBye!<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
How it works.<\/p>\n\n\n\n
First, define the exit()<\/code> function:<\/p>\n\n\n
func<\/span> exit<\/span>()<\/span><\/span> {\n   fmt.Println(\"Bye!\"<\/span>)\n}<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
Second, define the sayHi()<\/code> function:<\/p>\n\n\n
func<\/span> sayHi<\/span>()<\/span> bool<\/span><\/span> {\n   defer<\/span> exit()\n   fmt.Println(\"Hi there\"<\/span>)\n   return<\/span> true<\/span>\n   \/\/ always execute the exit function<\/span>\n   \/\/ exit()<\/span>\n}<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
Inside the sayHi()<\/code> function:<\/p>\n\n\n\n
    \n
  • Defer the exit()<\/code> function. <\/li>\n\n\n\n
  • Display a message \"Hi there\"<\/code> on the screen<\/li>\n\n\n\n
  • Return true<\/code><\/li>\n<\/ul>\n\n\n\n
    Third, call the sayHi()<\/code> function inside the main()<\/code> function:<\/p>\n\n\n
    func<\/span> main<\/span>()<\/span><\/span> {\n   sayHi()\n}<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
    After executing the sayHi()<\/code> function, Go executes the exit()<\/code> function.<\/p>\n\n\n\n
    Argument evaluation<\/h2>\n\n\n\n
    Go evaluates arguments immediately<\/strong> at the defer<\/code> statement but executes the function until the surrounding function completes. For example:<\/p>\n\n\n
    package<\/span> main\n\nimport<\/span> \"fmt\"<\/span>\n\nfunc<\/span> exit<\/span>(name string<\/span>)<\/span><\/span> {\n    fmt.Println(\"Bye\"<\/span>, name)\n}\n\nfunc<\/span> sayHi<\/span>(name string<\/span>)<\/span><\/span> {\n    defer<\/span> exit(name)\n    name = \"Alice\"<\/span>\n    fmt.Println(\"Hi\"<\/span>, name)\n}\n\nfunc<\/span> main<\/span>()<\/span><\/span> {\n    sayHi(\"Bob\"<\/span>)\n}\n<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
    Output:<\/p>\n\n\n
    Hi Alice\nBye Bob<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
    How it works.<\/p>\n\n\n\n
    First, define the exit()<\/code> function that accepts a string argument:<\/p>\n\n\n
    func<\/span> exit<\/span>(name string<\/span>)<\/span><\/span> {\n   fmt.Println(\"Bye\"<\/span>, name)\n}<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
    The exit()<\/code> argument displays a message Bye name<\/code> <\/p>\n\n\n\n
    Second, define the sayHi()<\/code> function that also accepts a string argument:<\/p>\n\n\n
    func<\/span> sayHi<\/span>(name string<\/span>)<\/span><\/span> {\n   defer<\/span> exit(name)\n   name = \"Alice\"<\/span>\n   fmt.Println(\"Hi\"<\/span>, name)\n}<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
    In the sayHi()<\/code> function:<\/p>\n\n\n\n
      \n
    • Defer the exit()<\/code> function. Go evaluates the name<\/code> argument in the first line of the sayHi()<\/code> function.<\/li>\n\n\n\n
    • Change the value of the name<\/code> parameter to \"Alice\"<\/code><\/li>\n\n\n\n
    • Display the Hi Alice<\/code> message.<\/li>\n<\/ul>\n\n\n\n
      Third, call the sayHi()<\/code> function with the “Bob” argument inside the main()<\/code> function:<\/p>\n\n\n
      func<\/span> main<\/span>()<\/span><\/span> {\n   sayHi(\"Bob\"<\/span>)\n}<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
      Since Go evaluates the name<\/code> argument at the first line of the sayHi<\/code> function, the output shows the message Bye Bob, not Bye Alice even though we changed the name to Alice<\/code> after deferring the call.<\/p>\n\n\n\n
      Using multiple defer statements<\/h2>\n\n\n\n
      Go allows you to have multiple defer<\/code> statements in a function. Go will execute them in the reverse order of their appearance:<\/p>\n\n\n
      func<\/span> outer<\/span>()<\/span><\/span> {\n    defer<\/span> inner1()\n    defer<\/span> inner2()\n    \/\/ function body<\/span>\n    \/\/ ...<\/span>\n}<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
      Inside the outer function, we have two defer statements that schedule the inner1()<\/code> and inner2()<\/code> functions to execute after the outer function completes. Go will execute the inner2()<\/code> function first and then the inner1()<\/code> function.<\/p>\n\n\n\n
      Behind the scenes, Go pushes deferred function calls onto a stack. When the surrounding function returns, Go executes the deferred calls in the last-in, first-out (LIFO) order. For example:<\/p>\n\n\n
      package<\/span> main\n\nimport<\/span> \"fmt\"<\/span>\n\nfunc<\/span> closeDbConnection<\/span>()<\/span><\/span> {\n    fmt.Println(\"Close the database connection\"<\/span>)\n}\nfunc<\/span> closeFile<\/span>()<\/span><\/span> {\n    fmt.Println(\"Close the file\"<\/span>)\n}\n\nfunc<\/span> writeDataToFile<\/span>()<\/span><\/span> {\n    defer<\/span> closeDbConnection()\n    defer<\/span> closeFile()\n    \/\/<\/span>\n    fmt.Println(\"Open a database connection\"<\/span>)\n    fmt.Println(\"Retrieving data from the database\"<\/span>)\n    fmt.Println(\"Write data to the file\"<\/span>)\n    fmt.Println(\"Open a file\"<\/span>)\n}\n\nfunc<\/span> main<\/span>()<\/span><\/span> {\n    writeDataToFile()\n}<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
      Output:<\/p>\n\n\n
      Open a database connection\nOpen a file\nRetrieving data from the database\nWrite data to the file\nClose the file\nClose the database connection<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
      How it works.<\/p>\n\n\n\n
      Step 1. Define the closeDbConnection<\/code> function:<\/p>\n\n\n
      func<\/span> closeDbConnection<\/span>()<\/span><\/span> {\n    fmt.Println(\"Close the database connection\"<\/span>)\n}<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
      Step 2. Define the closeFile()<\/code> function:<\/p>\n\n\n
      func<\/span> closeFile<\/span>()<\/span><\/span> {\n    fmt.Println(\"Close the file\"<\/span>)\n}<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
      Step 3. Define the writeDataToFile<\/code> function:<\/p>\n\n\n
      func<\/span> writeDataToFile<\/span>()<\/span><\/span> {\n    defer<\/span> closeDbConnection()\n    defer<\/span> closeFile()\n    \/\/<\/span>\n    fmt.Println(\"Open a database connection\"<\/span>)\n    fmt.Println(\"Retrieving data from the database\"<\/span>)\n    fmt.Println(\"Write data to the file\"<\/span>)\n    fmt.Println(\"Open a file\"<\/span>)\n}<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
      How writeDataToFile<\/code> works.<\/p>\n\n\n\n
      First, defer the closeDbConnection<\/code> and closeFile<\/code> functions to ensure that the file and database connection are closed after the function returns:<\/p>\n\n\n
      defer<\/span> closeDbConnection()\ndefer<\/span> closeFile()<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
      Go will execute the closeFile<\/code> function before the closeDbConnection<\/code> function.<\/p>\n\n\n\n
      Step 4. Call the writeDataToFile()<\/code> function inside the main()<\/code> function:<\/p>\n\n\n
      func<\/span> main<\/span>()<\/span><\/span> {\n    writeDataToFile()\n}<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
      Go defer use cases<\/h2>\n\n\n\n
        \n
      • Resource cleanup<\/strong>: you can use the defer<\/code> keyword to always clean up properly resources such as closing files and database connection.<\/li>\n\n\n\n
      • Logging<\/strong>: you can use the defer keyword to ensure that a certain log statement executes when a function returns.<\/li>\n\n\n\n
      • Locking<\/strong>: you can use the defer keyword to ensure a lock is unlocked when a function exits.<\/li>\n<\/ul>\n\n\n\n
        Measure function execution time<\/h2>\n\n\n\n
        The following example uses the defer<\/code> keyword defer a function call to measure the execution time of a function:<\/p>\n\n\n
        package<\/span> main\n\nimport<\/span> (\n    \"fmt\"<\/span>\n    \"time\"<\/span>\n)\n\nfunc<\/span> fn<\/span>()<\/span><\/span> {\n    fmt.Println(\"Called the fn function\"<\/span>)\n    for<\/span> i := 0<\/span>; i < 1<\/span>_000_000_000; i++ {\n    }\n}\n\nfunc<\/span> main<\/span>()<\/span><\/span> {\n    start := time.Now()\n    defer<\/span> func<\/span>()<\/span><\/span> {\n        elapsed := time.Since(start)\n        fmt.Printf(\"It took %d ms\\n\"<\/span>, elapsed.Milliseconds())\n    }()\n\n    \/\/ measure execution time of the fn<\/span>\n    fn()\n}<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
        Output:<\/p>\n\n\n
        Called the fn function\nIt took 411<\/span> ms<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
        How it works.<\/p>\n\n\n\n
        First, define fn<\/code> function that performs 1 billion loop iterations:<\/p>\n\n\n
        func<\/span> fn<\/span>()<\/span><\/span> {\n   fmt.Println(\"Called the fn function\"<\/span>)\n   for<\/span> i := 0<\/span>; i < 1<\/span>_000_000_000; i++ {\n   }\n}<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
        Second, declare the start<\/code> variable and initialize its values to the current local time:<\/p>\n\n\n
        start := time.Now()<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
        The Now()<\/code> function from the time module returns the current local time.<\/p>\n\n\n\n
        Third, defer a call to an anonymous function inside the main function:<\/p>\n\n\n
        defer<\/span> func<\/span>()<\/span><\/span> {\n    elapsed := time.Since(start)\n    fmt.Printf(\"It took %d ms\\n\"<\/span>, elapsed.Milliseconds())\n}()<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
        The function literal gets the duration using the Since()<\/code> function of the time<\/code> module and displays the elapsed time in milliseconds.<\/p>\n\n\n\n
        Finally, call the fn()<\/code> function:<\/p>\n\n\n
        fn()<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
        After executing the fn()<\/code> function, the main()<\/code> function returns. In turn, Go will execute the defer anonymous function call to print out the duration.<\/p>\n\n\n\n
        defer scope<\/h2>\n\n\n\n
        The scope of the defer statement is function. It means that the deferred calls must wait until the function exits. <\/p>\n\n\n\n
        Sometimes, you may not want to use the defer keyword. For example:<\/p>\n\n\n
        package main\n\nimport<\/span> (\n    \"fmt\"<\/span>\n    \"io\"<\/span>\n    \"os\"<\/span>\n)\n\nfunc main() {\n    filenames<\/span> := []string{\"1.txt\"<\/span>, \"2.txt\"<\/span>, \"3.txt\"<\/span>}\n\n    for<\/span> _, filename<\/span> := range filenames {\n        file, err<\/span> := os.Open(filename)\n        if<\/span> err != nil {\n            fmt.Println(err)\n            continue<\/span>\n        }\n        \/\/ read file<\/span>\n        data, err<\/span> := io.ReadAll(file)\n        if<\/span> err != nil {\n            fmt.Println(err)\n            continue<\/span>\n        }\n        fmt.Println(string(data))\n        \/\/ Close the file<\/span>\n        file.Close()\n    }\n}<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
        In this example, the program iterates over filenames<\/code>, reads each file, and displays the contents on the screen.<\/p>\n\n\n\n
        After each iteration, we call the Close()<\/code> method to close the file without using the defer<\/code> keyword. <\/p>\n\n\n\n
        If we used the defer<\/code> keyword, then the file would close when the function exits, not after each iteration, potentially causing an error of running out of file descriptors.<\/p>\n\n\n\n
        Defer Gotcha<\/h2>\n\n\n\n
        A defer<\/code> statement executes before the return is done. See the following example:<\/p>\n\n\n
        package<\/span> main\n\nimport<\/span> \"fmt\"<\/span>\n\nfunc<\/span> getX<\/span>()<\/span> (x int<\/span>)<\/span><\/span> {\n    defer<\/span> func<\/span>()<\/span><\/span> {\n        x = 10<\/span>\n    }()\n    x = 5<\/span>\n    return<\/span>\n}\n\nfunc<\/span> main<\/span>()<\/span><\/span> {\n    fmt.Println(getX())\n}\n<\/code><\/span>Code language:<\/span> Go<\/span> (<\/span>go<\/span>)<\/span><\/small><\/pre>\n\n\n
        Output:<\/p>\n\n\n
        10<\/code><\/span><\/pre>\n\n\n
        How it works.<\/p>\n\n\n\n
        First, define getX()<\/code> function that returns an integer. It has a named return value.<\/p>\n\n\n\n
        Second, call the defer<\/code> function that sets the return value to 10:<\/p>\n\n\n
        defer func() {\n   x = 10\n}()<\/code><\/span><\/pre>\n\n\n
        Third, set the return value to 5 and return:<\/p>\n\n\n
        x = 5<\/span>\nreturn<\/span><\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
        Finally, call the getX()<\/code> function in the main function and print out the return value.<\/p>\n\n\n\n
        The return value in this case is 10, not 5 because the defer<\/code> statement executes a function literal that sets x<\/code> to 10 before the return is done.<\/p>\n\n\n\n
        Summary<\/h2>\n\n\n\n
          \n
        • Use the defer<\/code> keyword to schedule a function call at the surrounding function exit.<\/li>\n\n\n\n
        • A function may have multiple defer<\/code> statements. Go executes the deferred function calls in the reverse order of their appearance.<\/li>\n\n\n\n
        • Use the defer<\/code> keyword for resource cleanup, logging, and locking.<\/li>\n\n\n\n
        • The scope of the defer<\/code> statement is its surrounding function<\/em>.<\/li>\n<\/ul>\n
          \n\t
          Was this tutorial helpful?<\/div>\n\t
          \n\t\t\n\t\t\t\n\t\t\t\t<\/path>\n\t\t\t<\/svg>\n\t\t\t Yes <\/span>\n\t\t<\/button>\n\n\t\t\n\t\t\t\n\t\t\t\t<\/path>\n\t\t\t<\/svg>\n\t\t\t No <\/span>\n\t\t<\/button>\n\t<\/div>\n\n\t
          \n\t\t
          \n\t\t\t
          <\/div>\n\t\t\t