In our previous learning, we have discussed functions and loops. Here we will be talking about switch
and defer
statements. Let's start with switch cases..
Switch statements are a way to compare multiple options and values together. They are similar to if-else statements but are more concise and readable
package main
import "fmt"
func main() {
var color string
fmt.Println("What color is the sky??")
switch fmt.Scan(&color); color {
case "red":
fmt.Println("Evening")
case "blue":
fmt.Println("Day")
case "pink":
fmt.Println("Evening")
case "black":
fmt.Println("Night")
default:
fmt.Println("Sky is what???")
}
}
Did you notice that the Go break
statement is not required at the end of a case
. break
statement is implicit in Go.
▶ go run switch.go
What color is the sky??
red
Evening
If you do want a case
to fall through to the next case
, you can use the fallthrough
keyword.
package main
import "fmt"
func main() {
var color string
fmt.Println("What color is the sky??")
switch fmt.Scan(&color); color {
case "blue":
fmt.Println("Day")
case "red":
fallthrough
case "pink":
fmt.Println("Evening")
case "black":
fmt.Println("Night")
default:
fmt.Println("Sky is what???")
}
}
▶ go run switch.go
What color is the sky??
red
Evening
default
is the case that runs if none of the other cases match.
switch
with no condition is same as switch true
package main
import (
"fmt"
"time"
)
func main() {
t := time.Now()
switch {
case t.Hour() < 12:
fmt.Println("Good morning.")
case t.Hour() < 17:
fmt.Println("Good afternoon.")
default:
fmt.Println("Good evening.")
}
}
▶ go run switch.go
Good afternoon.
Defer statement
defer
keyword allows a function to be executed automatically just before its enclosing function returns. The deferred call's arguments are evaluated immediately, but the function call is not executed until the surrounding function returns.
deferred functions
are mostly used for clean-up tasks or for closing connections.
package main
import (
"fmt"
"time"
)
func main() {
fmt.Println("You need rest.")
start := time.Now()
defer sleeping(start)
time.Sleep(5 * time.Second)
fmt.Println("You went to sleep.")
}
func sleeping(sleep time.Time) {
fmt.Printf("You slpet for %f seconds.", time.Since(sleep).Seconds())
}
▶ go run defer.go
You need rest.
You went to sleep.
You slpet for 5.001066 seconds.
Stacking defer
Deferred function calls are pushed onto a stack. When a function returns, its deferred calls are executed in LIFO (last-in-first-out) order.
package main
import "fmt"
func main() {
fmt.Println("counting")
for i := 0; i < 5; i++ {
defer fmt.Println(i)
}
fmt.Println("done")
}
▶ go run stackdefer.go
counting
done
4
3
2
1
0
Evaluation of arguments
The arguments of a deferred function are evaluated when the defer
statement is executed and not when the actual function call is done. you will understand this better with below example:
package main
import "fmt"
func main() {
a := 5
defer inc(a)
a++
fmt.Printf("a --> %v\n", a)
}
func inc(a int) {
fmt.Printf("a -> %v", a)
}
▶ go run defer2.go
a --> 6
a -> 5
defer
statements are not restricted to only functions; you can defer a method as well.
I guess we will wrap it up here. Stay tuned for the next learnings.
See you soon!
Thanks for joining our journey to learn Go (Golang)! In our next blog, we'll dive deeper into Go programming essentials. Stay tuned for more exciting learning adventures! Don't forget to subscribe to our newsletter for updates.