DEV Community: Adjie Djaka Permana

Go Control Flow - Deferring Panic with Recovery

Adjie Djaka Permana — Mon, 02 Aug 2021 07:57:22 +0000

Pre-requisite

I assume that you must have understood the basic of Go Lang.
I assume that you must have understood how basic control flow, like if-statement, switch, and loop works.
I advice you to clone my repository.

git clone https://github.com/codewithdjaeger/go-with-golang.git

cd go-with-golang/control-flow

Control Flow

Technically, control flow is the order in which individual statements, instructions, or function calls of an imperative program are executed or evaluated. Simply, it is the order of the lines of the code which contains either functions or statements that will be executed.

The most common control flow in almost every language is if-statement, switch, and looping. But, Go also has its signature control flow and they are defer, panic, and recovery. Usually, they're used to handling the error that is occurred in the control flow.

Defer the Flow Deferrer

defer, as its name, it is a keyword that will postpone the execution of a function calls until before the function in which the defer statement is located returns. Simply, any function calls that is preceded by the defer keyword will be fired immediately before the function returns. To make it clearer, take a look at the code below.

package main

import "fmt"

func main() {
    defer fmt.Println("This will be printed at the end")
    fmt.Println("This will be printed at the beginning")
}

// Output : 
// This will be printed at the beginning
// This will be printed at the end

Just for you know, defer only handle function calls. Otherwise, it will raise an error.

Usually, defer is used to help you handle the task that you might forget, like closing a file. For more advanced uses, it will help you to deal with the error. But, we will discuss this later. For now, take a look at the code below to see the example of defer use to close the file.

package main

import (
    "fmt"
    "io/ioutil"
    "log"
    "net/http"
)

func main() {
    res, err := http.Get("http://www.google.com/robots.txt")
    if err != nil {
        log.Fatal(err)
    }
    defer res.Body.Close() // Close response body
    robots, err := ioutil.ReadAll(res.Body) // Read response body
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println(robots)
}

As you can see in the code above, we have close the response body before the program reads it. Normally, it will cause the program to be terminated because the program trying to read on a closed response body. But, thanks to defer, the closing of the response body will be postponed until before the main function reaches its return.

So, what if we precede defer in all function calls in order?

Theoretically, the program will scan and execute all deferred function calls from the last order and it will result in the LIFO (Last In First Out) output.

package main

import "fmt"

func main() {
    defer fmt.Println("This will be printed last")
    defer fmt.Println("This will be printed second")
    defer fmt.Println("This will be printed first")
}

// Output : 
// This will be printed first
// This will be printed second
// This will be printed last

Panic, Makes Me Panic

Exception in Go is called panic, it can either be thrown by runtime or forced by programmer to handle the worse case. It will terminate current running control flow like the example below.

package main

import "fmt"

func main() {
    fmt.Println("Get ready!")
    panic("LET'S PANIC!!!")
    fmt.Println("This will not be executed")
}

// Output :
// Get ready!
// panic: LET'S PANIC!!!

// goroutine 1 [running]:
// main.main()
//        D:/Code/learn/learn-golang/control flow/panic.go:7 +0xa5
// exit status 2

Also, panic will fire all defer function calls that is declared before the panic within the same function.

package main

import "fmt"

func main() {
    defer fmt.Println("This will be printed immediately when panic occurred!")
    fmt.Println("Get ready!")
    panic("LET'S PANIC!!!")
}

// Output :
// Get ready!
// This will be printed immediately when panic occurred!
// panic: LET'S PANIC!!!

// goroutine 1 [running]:
// main.main()
//         D:/Code/learn/learn-golang/control flow/panicDefer.go:8 +0x105
// exit status 2

From the code above, we've known that defer will still be executed despite the program is terminated by panic. It explains why defer can be used to deal with errors. But, How? We will cover this in the recover function section.

Recover Will Do the Recovery

recover helps you to regain control after panicking. It's really useful to clean up the mess caused by the error and prevent your program from just terminating without closing or doing some clean-up task.

To do it, we can combine the uses of defer and recover like the example below.

package main

import (
    "fmt"
    "log"
)

func recoveryFunction() {
    if err := recover(); err != nil {
        log.Println("Program Recovered from", err)
    }
}

func panicFunction() {
    defer recoveryFunction()
    fmt.Println("Get Ready!")
    panic("PANIC!!!!")
    fmt.Println("Panic End")
}

func main() {
    fmt.Println("Program Initialized")
    panicFunction()
    fmt.Println("Program end")
}

// Output :
// Program Initialized
// Get Ready!
// 2021/08/02 13:56:36 Program Recovered from PANIC!!!!
// Program end

In the above example, we defer function that contains recover function. From there, we see that the program doesn't throw something like the output below and also does not terminate the program.

// goroutine 1 [running]:
// main.main()
//         D:/Code/learn/learn-golang/control flow/panicDefer.go:8 +0x105
// exit status 2

Instead, it prints a log of what happened and still runs the program until its end. It is good because, in the real world, the program is expected not to be terminated/exit and left the process unfinished when the error occurred.

Conclusions

Control flow is the order of lines of code that will be executed.
In Go, there are 3 signatures part of error handling, it is defer, panic, and recover.
defer will Postpone the execution of function calls until before the function return.
panic can either be thrown by runtime error or forced with custom error.
recover can be used to determine how the error will be handled instead of terminating the program.

Let's Go Pointer

Adjie Djaka Permana — Fri, 30 Jul 2021 15:20:24 +0000

Pre-requisite

I assume that you have installed and configured Go in your machine
I assume you want to learn about pointer especially in Go
I advice you to clone my repository

git clone https://github.com/codewithdjaeger/go-with-golang.git

cd go-with-golang/pointer

What is this Pointer?

Pointer is a special variable. It stores the memory address of where the value is stored instead of the value itself. Simply, it stores the address of someone who has something. So, when the something that is owned by the someone is changed then the value in the pointer also changed.

Someone's address analogically is the memory address. It is always found as a hexadecimal value (e.g. 0xFF etc.), a number starting with 0x is hexadecimal. For the real example, I'll show you this code written in Go Lang.

var someone int = 10
var pointer *int = &someone

fmt.Println("Memory address of someone is", pointer)

// Output:
// Memory address of someone is 0xc000014098

From the example above, we know that pointer has the value of &someone and why would that happen? Despite we know that someone is assigned with 10. If you notice it already, yes, it is because of that suspicious & preceding the variable name and what exactly is it?

What Exactly Address and Dereferencing Operator Is?

It is one of two notations for declaring pointer variables. The & notation also called as address operator is used to get the memory address of the variable and it is always used preceding its variable name while the other, * notation also called as dereferencing operator, can be used preceding variable type, as the above example, or preceding its variable name.

If the address operator is used to get the memory address of its variable, so, what does the dereferencing operator do? Actually, it depends on how you use it. When it preceding variable type, it is used for declaring the pointer variable. While it is preceding its variable name, it is used to access the value that is stored in the memory address.

fmt.Println("Memory address of someone accessed by address operator is", &someone)
fmt.Println("Value of someone accessed by dereferencing operator is", *pointer)

// Output:
// Memory address of someone accessed by address operator is 0xc000014098
// Value of someone accessed by dereferencing operator is 10

What Actually This Pointer Things Do?

To answer this question that's bother your head, first, let's take a look at this.

var someone int = 10
var someoneElse int = someone

fmt.Println("Hello, someone's value is", someone)
fmt.Println("And someone else's value is", someoneElse)

someone = 20
fmt.Print("\n")

fmt.Println("Yeay, someone's value is changed to", someone)
fmt.Println("Oh no, someone else's value still", someoneElse)

// Output: 
// Hello, someone's value is 10
// And someone else's value is 10        

// Yeay, someone's value is changed to 20
// Oh no, someone else's value still 10

Really? So, what?

Okay, what I want to emphasize from the code above is when someone's value is changed, someoneElse's still, despite it has been assigned with the value of someone.

But why? What's wrong with that?

Okay, now take a look at this.

var someone int = 10
var someoneElse *int = &someone

fmt.Println("Hello, someone's value is", someone)
fmt.Println("And someone else's value is", *someoneElse)

someone = 20
fmt.Print("\n")

fmt.Println("Yeay, someone's value is changed to", someone)
fmt.Println("and finally, someone else's value is changed to", *someoneElse)

// Output:
// Hello, someone's value is 10
// And someone else's value is 10

// Yeay, someone's value is changed to 20
// and finally, someone else's value is changed to 20

From the last example, both someone and someoneElse value changed. It is not because of the notation, because it's just used to accessed the value, but it is because the pointer.

The first example show us that someoneElse has the value of someone, yes, that's right. But, actually despite they have the same value, their address are different as you can see from the example below.

var someone int = 10
var someoneElse int = someone

fmt.Println("Here, someone's memory address is", &someone)
fmt.Println("And someone else's memory address is", &someoneElse)

// Output :
// Here, someone's memory address is 0xc000014098
// And someone else's memory address is 0xc0000140b0

Yes, they're pointing to the different memory addresses and that explains why when someone's value is changed, someoneElse's not.

Are There Any Different Ways to Do Pointer in GO?

yes, there are.

Firstly, You must know that Go's compiler is smart enough to determine what type of value is assigned to a variable. So, you can use shorthand such as := to declare pointer instead of using regular declaration and let the compiler handle the rest. Take a look at the example below.

someone := 10
someoneElse := &someone

fmt.Println("Here, someone's value is", someone)
fmt.Println("And someone else's value is", *someoneElse)

// Output :
// Here, someone's value is 10
// And someone else's value is 10

Also, the array will return a pointer when you assign its slice to a variable like the example below.

someoneArray := []int{1, 2, 3}
someoneElseArray := someoneArray

fmt.Println("Here, someone array's value is", someoneArray)
fmt.Println("And someone else array's value is", someoneElseArray)

someoneArray[0] = 10
fmt.Print("\n")

fmt.Println("Yeay, someone array's value is changed to", someoneArray)
fmt.Println("And also someone else array's value is changed to", someoneElseArray)

// Output :
// Here, someone array's value is [1 2 3]
// And someone else array's value is [1 2 3]

// Yeay, someone array's value is changed to [10 2 3]        
// And also someone else array's value is changed to [10 2 3]

Lastly, you may use new() to return a pointer while using struct. like the example below.

package main

import "fmt"

type someoneStruct struct {
    value int
}

func main() {
    someone := new(someoneStruct)
    someoneElse := someone

    fmt.Println("Here, someone's value is", someone.value)
    fmt.Println("And someone else's value is", someoneElse.value)

    someone.value = 10
    fmt.Print("\n")

    fmt.Println("Yeay, someone's value is changed to", someone.value)
    fmt.Println("And also someone else's value is changed to", someoneElse.value)
}

// Output :
// Here, someone's value is 0
// And someone else's value is 0

// Yeay, someone's value is changed to 10        
// And also someone else's value is changed to 10

Conclusions

Pointer stores the memory address of a value instead of the value itself.
To declare the pointer variable you must use dereferencing operator (*) and address operator (&).
In Go, you can use shorthand (:=) to declare pointer variable and you can use slice of array or new() on a struct to return a pointer.