What the heck is defer in golang?

Lucifer Chase — Mon, 24 May 2021 08:00:38 +0000

Do you struggle to get the hang of defer too?
Worry not 😁, I will try to explain it as simply as I can in this post.

A defer statement defers the execution of a function until the surrounding function returns.

The deferred call's arguments are evaluated immediately, but the function call is not executed until the surrounding function returns.

This program explains the execution of defer in a bit easier way:

func trace(s string) string {
    fmt.Println("entering:", s)
    return s
}

func un(s string) {
    fmt.Println("leaving:", s)
}

func a() {
    defer un(trace("a"))    // similarly trace("a") also gets 
                            // executed immediately
    fmt.Println("in a")
}

func b() {
    defer un(trace("b"))    // trace("b") gets executed 
                            // immediately but un("b") gets 
                            // execute at the very last
    fmt.Println("in b")
    a()
}

func main() {
    b()
}

Output:

entering: b     // output of trace("b")
in b            // note that un("b") is not executed instead 
                // program moves ahead
entering: a     // output of trace("a")
in a
leaving: a      // finally defered un("a") is called as a() 
                // returns
leaving: b      // at last un("b") is called

Deferred function calls are pushed onto a stack.

When a function returns, its deferred calls are executed in last-in-first-out order.

Here is a small program which visualise this:

package main

import "fmt"

func main() {
    fmt.Println("counting \n")
    defer fmt.Println("\ndone")     // This will get executed at 
                                    // the very last

    for i := 0; i < 10; i++ {
        defer fmt.Println(i)
    }
}

Output:

counting

9
8
7
6
5
4
3
2
1

done

However remember deferred function's arguments are evaluated immediately, hence it can give a different result

i := 0
defer fmt.Println(i)
i++

// It will print 0 even though i has become 1

A particularly good use of defer is to close a file.

package main
import (
    "os"
)

func main() {
    f, _ := os.Create("test.txt")
    defer f.Close()
    /*
        Stuff
    */
}

Deferring a call to a function such as Close has two advantages. First, it guarantees that you will never forget to close the file, a mistake that's easy to make if you later edit the function to add a new return path.

Second, it means that the close sits near the open, which is much clearer than placing it at the end of the function.

Source

A small thing nobody taught you in Python

Lucifer Chase — Mon, 24 May 2021 07:49:15 +0000

Have you ever noticed that some stuffs like lower(), upper(), sort() etc. are called like this variable.lower() or variable.sort(). But most of the other function are called like this len(variable), str(variable).

What's the difference?

Actually, the first set of examples are actually called attributes or methods.

Let's take the example of lower(), which acts on the str datatype.

str datatype is actually a class and has a number of functions inside it. These functions are called attribute and can be accessed by using the . notation.

class Hello:
    def world(self):
        print("Hello World")

hello = Hello()        # Instantiate the class Hello
hello.world()          # Access the attribute world()

# Prints: Hello World

If you are familiar with OOP programming, this is all very familiar to you. If not, you can read more here.

So, back to our example:

string = "Hello World"
print(string.lower())   # Here, I have called string's (str class) 
                        # attribute lower() which changes case to 
                        # lowercase

l = [1, 3, 2]
l.sort()                # Here, sort() is an attribute of l 
                        # (list datatype) which sorts the list

# Thus, lower() and sort() are actually functions inside the 
# str and list class respectively

On the other hand, the latter examples were all functions, like your normal def func() thing. They perform a certain task on the argument that is passed to them. The task may or may not be unique to a particular datatype.

string = "Hello World"
l = [1, 2, 3]

print(len(string))      # Prints the no. of characters in string 
                        # (str datatype)
print(len(l))           # Notice, len() can be applied to list 
                        # datatype (and various other types) too

I hope you leaned something new today 😁.

DEV Community: Lucifer Chase

What the heck is defer in golang?

A small thing nobody taught you in Python