The switch statement in Go is used for decision-making, similar to if-else, but it is more readable when multiple conditions need to be checked. It allows a variable to be tested against multiple values, executing the corresponding case when a match is found.
switch expression {
case value1:
// Code to execute if expression == value1
case value2:
// Code to execute if expression == value2
default:
// Code to execute if no cases match
}
đš Key Points:
â
No break statement is needed (unlike C, C++). Once a matching case executes, it automatically exits the switch block.
â
default case is optional, but it is used when no other case matches.
package main
import "fmt"
func main() {
day := "Monday"
switch day {
case "Monday":
fmt.Println("Start of the work week!")
case "Friday":
fmt.Println("Weekend is near!")
default:
fmt.Println("It's a regular day.")
}
}
đš Output:
Start of the work week!
đ Explanation:
day == "Monday", so the first case executes.switch after that.Go allows multiple cases to share the same block of code.
package main
import "fmt"
func main() {
day := "Saturday"
switch day {
case "Saturday", "Sunday":
fmt.Println("It's the weekend!")
default:
fmt.Println("It's a weekday.")
}
}
đš Output:
It's the weekend!
đ Explanation:
day == "Saturday", which matches case "Saturday", "Sunday", so the message is printed.In Go, a switch can work without an expression, making it similar to an if-else ladder.
package main
import "fmt"
func main() {
num := -5
switch {
case num > 0:
fmt.Println("Positive number")
case num < 0:
fmt.Println("Negative number")
default:
fmt.Println("Zero")
}
}
đš Output:
Negative number
đ Explanation:
num < 0, the second case executes.By default, Go does not fall through cases like C/C++. However, you can force execution of the next case using the fallthrough keyword.
package main
import "fmt"
func main() {
num := 1
switch num {
case 1:
fmt.Println("Case 1 executed")
fallthrough
case 2:
fmt.Println("Case 2 executed")
default:
fmt.Println("Default case")
}
}
đš Output:
Case 1 executed
Case 2 executed
đ Explanation:
num == 1, so case 1 executes.fallthrough forces case 2 to execute as well, even though num is not 2.A type switch is used when you want to check the type of a variable stored in an interface{}.
package main
import "fmt"
func typeCheck(i interface{}) {
switch v := i.(type) {
case int:
fmt.Println("It's an integer:", v)
case string:
fmt.Println("It's a string:", v)
default:
fmt.Println("Unknown type")
}
}
func main() {
typeCheck(10)
typeCheck("GoLang")
typeCheck(3.14)
}
đš Output:
It's an integer: 10
It's a string: GoLang
Unknown type
đ Explanation:
i and executes the corresponding case.int and string are matched, but 3.14 (float) falls into default.| Feature | Switch | If-Else |
|---|---|---|
| Readability | Better for multiple conditions | Becomes lengthy with many conditions |
| Performance | Faster (compiles to jump table) | Can be slower for many conditions |
| Type Checking | Can be used for type switches | Requires explicit type checks |
| Fallthrough | Disabled by default | Not applicable |
â
switch is more readable than multiple if-else statements.
â
No break is needed (it exits automatically).
â
You can have multiple values in one case.
â
Type switches allow checking variable types.
â
fallthrough forces execution of the next case.
đ Use switch for cleaner and faster conditional checks!
switch āĻ¸ā§āĻā§āĻāĻŽā§āĻ¨ā§āĻ āĻŦā§āĻ¯āĻŦāĻšāĻžāĻ° āĻāĻ°ā§ āĻāĻāĻāĻŋ āĻā§āĻ°āĻŋāĻ¯āĻŧā§āĻŦāĻ˛ āĻŦāĻŋāĻāĻŋāĻ¨ā§āĻ¨ āĻŽāĻžāĻ¨ā§āĻ° āĻ¸āĻžāĻĨā§ āĻ¤ā§āĻ˛āĻ¨āĻž āĻāĻ°ā§ āĻ¨āĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āĻ āĻā§āĻĄ āĻŦā§āĻ˛āĻ āĻāĻžāĻ˛āĻžāĻ¨ā§ āĻ¯āĻžāĻ¯āĻŧāĨ¤ āĻāĻāĻŋ if-else-āĻāĻ° āĻā§āĻ¯āĻŧā§ āĻ¸āĻšāĻ āĻ āĻĻā§āĻ°ā§āĻ¤āĻ¤āĻ° āĻ¸āĻŽāĻžāĻ§āĻžāĻ¨āĨ¤
switch expression {
case value1:
// āĻ¯āĻĻāĻŋ expression == value1 āĻšāĻ¯āĻŧ
case value2:
// āĻ¯āĻĻāĻŋ expression == value2 āĻšāĻ¯āĻŧ
default:
// āĻ¯āĻĻāĻŋ āĻāĻŋāĻā§āĻ āĻ¨āĻž āĻŽā§āĻ˛ā§
}
â āĻāĻĻāĻžāĻšāĻ°āĻŖ:
package main
import "fmt"
func main() {
day := "Monday"
switch day {
case "Monday":
fmt.Println("āĻ¸āĻĒā§āĻ¤āĻžāĻšā§āĻ° āĻļā§āĻ°ā§!")
case "Friday":
fmt.Println("āĻ¸āĻĒā§āĻ¤āĻžāĻšāĻžāĻ¨ā§āĻ¤ āĻāĻžāĻāĻžāĻāĻžāĻāĻŋ!")
default:
fmt.Println("āĻ¸āĻžāĻ§āĻžāĻ°āĻŖ āĻĻāĻŋāĻ¨āĨ¤")
}
}
đš āĻāĻāĻāĻĒā§āĻ:
āĻ¸āĻĒā§āĻ¤āĻžāĻšā§āĻ° āĻļā§āĻ°ā§!
case "Saturday", "Sunday":
fmt.Println("āĻāĻāĻŋ āĻā§āĻāĻŋāĻ° āĻĻāĻŋāĻ¨!")
â āĻāĻĻāĻžāĻšāĻ°āĻŖ:
day := "Sunday"
switch day {
case "Saturday", "Sunday":
fmt.Println("āĻāĻāĻŋ āĻā§āĻāĻŋāĻ° āĻĻāĻŋāĻ¨!")
default:
fmt.Println("āĻāĻāĻŋ āĻāĻ°ā§āĻŽāĻĻāĻŋāĻŦāĻ¸āĨ¤")
}
đš āĻāĻāĻāĻĒā§āĻ:
āĻāĻāĻŋ āĻā§āĻāĻŋāĻ° āĻĻāĻŋāĻ¨!
fallthroughnum := 1
switch num {
case 1:
fmt.Println("Case 1")
fallthrough
case 2:
fmt.Println("Case 2")
}
đš āĻāĻāĻāĻĒā§āĻ:
Case 1
Case 2
type switch)func typeCheck(i interface{}) {
switch i.(type) {
case int:
fmt.Println("āĻāĻāĻāĻŋ āĻāĻāĻāĻŋ āĻ¸āĻāĻā§āĻ¯āĻžāĨ¤")
case string:
fmt.Println("āĻāĻāĻāĻŋ āĻāĻāĻāĻŋ āĻ¸ā§āĻā§āĻ°āĻŋāĻāĨ¤")
}
}
â āĻ¸āĻāĻā§āĻˇā§āĻĒā§:
switch āĻ
āĻ¨ā§āĻ if-else āĻ¸ā§āĻā§āĻāĻŽā§āĻ¨ā§āĻāĻā§ āĻ¸āĻšāĻ āĻāĻ°ā§āĨ¤fallthrough āĻļā§āĻ§ā§āĻŽāĻžāĻ¤ā§āĻ° āĻĒāĻ°āĻŦāĻ°ā§āĻ¤ā§ case āĻāĻžāĻ˛āĻžāĻ¨ā§āĻ° āĻāĻ¨ā§āĻ¯ āĻŦā§āĻ¯āĻŦāĻšā§āĻ¤ āĻšāĻ¯āĻŧāĨ¤type switch āĻŦā§āĻ¯āĻŦāĻšāĻžāĻ° āĻāĻ°āĻž āĻ¯āĻžāĻ¯āĻŧāĨ¤đ Go-āĻ¤ā§ switch āĻŦā§āĻ¯āĻŦāĻšāĻžāĻ° āĻāĻ°ā§āĻ¨ āĻāĻ°āĻ āĻāĻžāĻ˛ā§ āĻĒāĻžāĻ°āĻĢāĻ°āĻŽā§āĻ¯āĻžāĻ¨ā§āĻ¸ā§āĻ° āĻāĻ¨ā§āĻ¯!
