Switch Statement is another way of controlling the flow in GoLang. It is pretty much similar to if statements but both have their advantages and disadvantages depending on your use case. Below is a simple switch structure:

switch {
	case condition-1:
    	// Code block 1 - Executed if condition-1 is true
    case condition-2:
    	// Code block 2 - Executed if condition-2 is true
    case condition-3:
    	// Code block 3 - Executed if condition-3 is true
    default:
        // Executed if all other cases are false
}

Switch Statement in GoLang follows different rules in comparison to other programming languages. So, let's take a look at the following examples to understand these rules.

Example 1:

func exampleOne() {
	fmt.Println(" ----- Example One: -----")
	switch {
	case 1 == 1:
		fmt.Println("1 is equal to 1")
	case 2 == 2:
		fmt.Println("2 is equal to 2")
	case 3 == 3:
		fmt.Println("3 is equal to 3")
	case 2 == 3:
		fmt.Println("2 is not equal to 3")
	}
	fmt.Println()
}

Result:

 ----- Example One: -----
1 is equal to 1

Here as you can see, we didn't even need to define a variable for switch to evaluate. The first case statement that becomes true will executed.

Interesting fact is that even if the next case is also true, it is not evaluated anymore. Here, it only evaluates the first true case. In other languages, we also need to have break for every case block, otherwise, the next cases (even if false) will be executed. In GoLang, break is not needed as it will only execute the code block within the first case that is true.

Example 2:

func exampleTwo() {
	fmt.Println(" ----- Example Two: -----")
	switch {
	case 1 == 1:
		fmt.Println("1 is equal to 1")
		fallthrough
	case 2 == 2:
		fmt.Println("2 is equal to 2")
	case 3 == 3:
		fmt.Println("3 is equal to 3")
	case 2 == 3:
		fmt.Println("2 is not equal to 3")
	}
	fmt.Println()
}

Result:

 ----- Example Two: -----
1 is equal to 1
2 is equal to 2

In case we want the next case block to be executed as well, we need to add fallthrough keyword.

Another interesting fact is that even if the next case evaluates to false it will still be executed.

Example 3:

func exampleThree() {
	fmt.Println(" ----- Example Three: -----")
	switch {
	case 1 == 1:
		fmt.Println("1 is equal to 1")
		fallthrough
	case 1 == 2:
		fmt.Println("1 is not equal to 2")
	case 3 == 3:
		fmt.Println("3 is equal to 3")
	case 2 == 3:
		fmt.Println("2 is not equal to 3")
	}
	fmt.Println()
}

Result:

 ----- Example Three: -----
1 is equal to 1
1 is not equal to 2

As mentioned in previous example, even if the next case evaluates to false, as long as the previous case is executed and has fallthrough keyword, it will still be executed.

Example 4

func exampleFour() {
	fmt.Println(" ----- Example Four: -----")
	switch {
	case 1 == 2:
		fmt.Println("1 is not equal to 2")
	default:
		fmt.Println("Reached default")
	}
	fmt.Println()
}

Result:

 ----- Example Four: -----
Reached default

default keyword works the same way as other programming languages. If none of the previous cases are true, default block will be executed.

Example 5:

func exampleFive() {
	fmt.Println(" ----- Example Five: -----")

	name := "Darwin"

	switch name {
	case "Darwin":
		fmt.Println("Name is Darwin")
	case "Test":
		fmt.Println("Name is Test")
	default:
		fmt.Println("Reached default")
	}
	fmt.Println()
}

Result:

----- Example Five: -----
Name is Darwin

In this example we have a name to be evaluated in the switch line. This checks which case has the same value as the name and executes that code block.

Example 6:

func exampleSix() {
	fmt.Println(" ----- Example Six: -----")

	name := "Yehey"

	switch name {
	case "Darwin", "Mark", "Yehey":
		fmt.Println("Name is Darwin")
	case "Test":
		fmt.Println("Name is Test")
	default:
		fmt.Println("Reached default")
	}
	fmt.Println()
}

Result:

----- Example Six: -----
Name is Darwin

Our case can have multiple possible options. From what you can see above, if the name is equal to "Darwin", "Mark", or "Yehey", the case block will be executed.

Complete Code:

package main

import "fmt"

func main() {
	exampleOne()
	exampleTwo()
	exampleThree()
	exampleFour()
	exampleFive()
	exampleSix()
}

func exampleOne() {
	fmt.Println(" ----- Example One: -----")
	switch {
	case 1 == 1:
		fmt.Println("1 is equal to 1")
	case 2 == 2:
		fmt.Println("2 is equal to 2")
	case 3 == 3:
		fmt.Println("3 is equal to 3")
	case 2 == 3:
		fmt.Println("2 is not equal to 3")
	}
	fmt.Println()
}

func exampleTwo() {
	fmt.Println(" ----- Example Two: -----")
	switch {
	case 1 == 1:
		fmt.Println("1 is equal to 1")
		fallthrough
	case 2 == 2:
		fmt.Println("2 is equal to 2")
	case 3 == 3:
		fmt.Println("3 is equal to 3")
	case 2 == 3:
		fmt.Println("2 is not equal to 3")
	}
	fmt.Println()
}

func exampleThree() {
	fmt.Println(" ----- Example Three: -----")
	switch {
	case 1 == 1:
		fmt.Println("1 is equal to 1")
		fallthrough
	case 1 == 2:
		fmt.Println("1 is not equal to 2")
	case 3 == 3:
		fmt.Println("3 is equal to 3")
	case 2 == 3:
		fmt.Println("2 is not equal to 3")
	}
	fmt.Println()
}

func exampleFour() {
	fmt.Println(" ----- Example Four: -----")
	switch {
	case 1 == 2:
		fmt.Println("1 is not equal to 2")
	default:
		fmt.Println("Reached default")
	}
	fmt.Println()
}

func exampleFive() {
	fmt.Println(" ----- Example Five: -----")

	name := "Darwin"

	switch name {
	case "Darwin":
		fmt.Println("Name is Darwin")
	case "Test":
		fmt.Println("Name is Test")
	default:
		fmt.Println("Reached default")
	}
	fmt.Println()
}

func exampleSix() {
	fmt.Println(" ----- Example Six: -----")

	name := "Yehey"

	switch name {
	case "Darwin", "Mark", "Yehey":
		fmt.Println("Name is Darwin")
	case "Test":
		fmt.Println("Name is Test")
	default:
		fmt.Println("Reached default")
	}
	fmt.Println()
}

GoLang Playground Link

Result:

 ----- Example One: -----
1 is equal to 1

 ----- Example Two: -----
1 is equal to 1
2 is equal to 2

 ----- Example Three: -----
1 is equal to 1
1 is not equal to 2

 ----- Example Four: -----
Reached default

 ----- Example Five: -----
Name is Darwin

 ----- Example Six: -----
Name is Darwin