Switch statements are an important concept in programming and they are used for conditional execution. Switch statements in GO behave a little different as compared to other programming languages. So, in this blog we are going to understand switch statements in GO with the help of meaningful examples.
Getting Started
Let's look at the following example
package main
import "fmt"
func main() {
fruit := "Orange"
switch fruit {
case "Apple":
fmt.Printf("%v is a nice fruit\n", fruit)
case "Mango":
// We can have multiple lines of code inside case
out := fmt.Sprintf("%v is a nice fruit", fruit)
fmt.Println(out)
case "Guava":
// By default there's NO fall through
fmt.Printf("%v is a nice fruit\n", fruit)
case "Orange":
fmt.Printf("%v is a nice fruit\n", fruit)
default:
fmt.Println("Unrecognized fruit")
}
}
Can you guess the output of the above code snippet? If you've used switch statements in other programming languages you probably guessed the following
Mango is a nice fruit
Mango is a nice fruit
Mango is a nice fruit
Unrecognized fruit
But that's not the case with GO, here in switch statements we don't have fall through by default (fall through basically means executing all cases that come after the matching case). In GO only the statements within the matching case gets executed, so the output is simply Mango is a nice fruit
.
NOTE: switch expression == case expression
must be a valid comparison, so the code below would give an error.
package main
import "fmt"
func main() {
num := "Two"
switch num {
case 2:
fmt.Printf("Num is 2")
default:
fmt.Println("Num is not 2")
}
}
Using fallthrough
What if we want to fall through, well for that we need to explicitly specify this by using the fallthrough
keyword. So, the code below gives that output that we guessed earlier.
package main
import "fmt"
func main() {
fruit := "Mango"
switch fruit {
case "Apple":
fmt.Printf("%v is a nice fruit\n", fruit)
case "Mango":
out := fmt.Sprintf("%v is a nice fruit", fruit)
fmt.Println(out)
fallthrough
case "Guava":
fmt.Printf("%v is a nice fruit\n", fruit)
fallthrough
case "Orange":
fmt.Printf("%v is a nice fruit\n", fruit)
fallthrough
default:
fmt.Println("Unrecognized fruit")
}
}
Note that we had to specify fallthrough
multiple times to get the desired output, so fallthrough just executes the next case block (irrespective of whether that block is true or false) and not all the subsequent case blocks.
Also, as in other programming languages the default
case is optional and is triggered when no other cases match (the default case can be placed anywhere not necessarily at the very bottom)
Multiple Case Expressions
We can also have multiple case expressions separated by commas. If any of the case expressions match the switch expression, then the statements associated with that particular case are executed.
package main
import "fmt"
func main() {
fruit := "Onion";
switch fruit {
case "Apple", "Mango", "Guava":
fmt.Println("Fruit")
case "Potato", "Cabbage", "Onion":
fmt.Println("Vegetable")
default:
fmt.Println("What is it?")
}
}
// OUTPUT
// Vegetable
Till now I have only used literal values in switch and case expressions, but that's not the only possibility. Take a look at the following example
package main
import "fmt"
func main() {
fruit := "Onion"
switch fruit + "s" {
case "Apple" + "s", "Mango" + "es":
fmt.Println("Fruits")
case "Cabbage" + "s", "Onion" + "s":
fmt.Println("Vegetables")
default:
fmt.Println("What is it?")
}
}
// OUTPUT
// Vegetables
Switch Initializer
We can also have a switch initializer as shown below:
package main
import "fmt"
func main() {
switch fruit := "Onion"; fruit{
case "Apple", "Mango":
fmt.Println("Fruit")
case "Cabbage", "Onion":
fmt.Println("Vegetable")
default:
fmt.Println("What is it?")
}
}
Now the variable fruit
is only available within the switch block, not within the entire main
function.
Expressionless Switch
If we don't specify an expression to switch then it defaults to the boolean value true
and now the program looks for case expressions that evaluate to true
and this is similar to an if-else-if-else
chain.
package main
import "fmt"
func main() {
for i := 1; i <= 30; i++ {
switch {
case i%15 == 0:
fmt.Println(i, "Baz")
case i%3 == 0:
fmt.Println(i, "Foo")
case i%5 == 0:
fmt.Println(i, "Bar")
default:
// default is optional
fmt.Println(i)
}
}
}
Type Switches
A type switch compares types rather than values. It is otherwise similar to an expression switch. Take a look at the following example.
package main
import "fmt"
func main() {
var num interface{} = "Hello, World"
switch num.(type) {
case int:
fmt.Printf("num is of type int")
case bool:
fmt.Printf("num is of type bool")
case string:
fmt.Printf("num is of type string")
}
}
// OUTPUT
// num is of type string
So, I hope we now have a clear understanding of how switch statements work in GO.
Top comments (0)