In Go, the switch statement allows us to execute one code block among many alternatives.
Syntax
switch expression {
case 1:
// code block 1
case 2:
// code block 2
case 3:
// code block 3
...
...
default:
// default code block
}
The expression after the switch keyword is evaluated. If the result of the expression is equal to
case 1- code block 1 is executedcase 2- code block 2 is executedcase 3- code block 3 is executed
In case there is no match, the default code block is executed.
Note: We can also use if...else statements in place of switch. However, the syntax of the switch is much cleaner and easier to write.
Flowchart of Switch Statement
Example: switch case in Golang
// Program to print the day of the week using switch case
package main
import "fmt"
func main() {
dayOfWeek := 3
switch dayOfWeek {
case 1:
fmt.Println("Sunday")
case 2:
fmt.Println("Monday")
case 3:
fmt.Println("Tuesday")
case 4:
fmt.Println("Wednesday")
case 5:
fmt.Println("Thursday")
case 6:
fmt.Println("Friday")
case 7:
fmt.Println("Saturday")
default:
fmt.Println("Invalid day")
}
}
Output
Tuesday
In the above example, we have assigned 3 to the dayOfWeek variable. Now, the variable is compared with the value of each case statement.
Since the value matches with case 3, the statement fmt.Println("Tuesday") inside the case is executed.
Note: Unlike other programming languages like C and Java, we don't need to use break after every case. This is because in Go, the switch statement terminates after the first matching case.
Go switch case with fallthrough
If we need to execute other cases after the matching case, we can use fallthrough inside the case statement. For example,
// Program to print the day of the week using fallthrough in switch
package main
import "fmt"
func main() {
dayOfWeek := 3
switch dayOfWeek {
case 1:
fmt.Println("Sunday")
case 2:
fmt.Println("Monday")
case 3:
fmt.Println("Tuesday")
fallthrough
case 4:
fmt.Println("Wednesday")
case 5:
fmt.Println("Thursday")
case 6:
fmt.Println("Friday")
case 7:
fmt.Println("Saturday")
default:
fmt.Println("Invalid day")
}
}
Output
Tuesday Wednesday
In the above example, the expression in switch matches case 3 so, Tuesday is printed. However, Wednesday is also printed even if the case doesn't match.
This is because we have used fallthrough inside case 3.
Go switch with multiple cases
We can also use multiple values inside a single case block. In such case, the case block is executed if the expression matches with one of the case values.
Let's see an example,
// Program to check if the day is a weekend or a weekday
package main
import "fmt"
func main() {
dayOfWeek := "Sunday"
switch dayOfWeek {
case "Saturday", "Sunday":
fmt.Println("Weekend")
case "Monday","Tuesday","Wednesday","Thursday","Friday":
fmt.Println("Weekday")
default:
fmt.Println("Invalid day")
}
}
Output
Weekend
In the above example, we have used multiple values for each case:
- case "Saturday", "Sunday" - executes if dayOfWeek is either Saturday or Sunday
- case "Monday", "Tuesday", "Wednesday", "Thursday", "Friday" - executes if dayOfWeek is either one of the value
Golang switch without expression
In Go, the expression in switch is optional. If we don't use the expression, the switch statement is true by default. For example,
// Program to check if it's February or not using switch without expression
package main
import "fmt"
func main() {
numberOfDays := 28
// switch without any expression
switch {
case 28 == numberOfDays:
fmt.Println("It's February")
default:
fmt.Println("Not February")
}
}
Output
It's February
In the above example, switch doesn't have an expression. Hence, the statement is true.
Go switch optional statement
In Golang, we can also use an optional statement along with the expression. The statement and expression are separated by semicolons. For example,
// Program to check the day of a week using optional statement
package main
import "fmt"
func main() {
// switch with statement
switch day := 4; day {
case 1:
fmt.Println("Sunday")
case 2:
fmt.Println("Monday")
case 3:
fmt.Println("Tuesday")
case 4:
fmt.Println("Wednesday")
case 5:
fmt.Println("Thursday")
case 6:
fmt.Println("Friday")
case 7:
fmt.Println("Saturday")
default:
fmt.Println("Invalid Day!")
}
}
Output
Wednesday
In the above example, we have used the optional statement day := 4 along with the expression day. It matches case 4 and hence, Wednesday is printed.