{

Golang tutorials - Switch case statement examples


Golang Switch case statement guide with examples This article covers the Switch case statements with expressions and types with various syntax examples.

Golang Switch case statements

Switch case executes a particular code block when we have multiple code blocks based on condition.

It is an alternative syntax for writing if-else block.

Unlike other programming languages like Java and C+, where, a break is needed to stop its execution. Go language is automatically stopped its execution when the matching case executed. The Break keyword is not required.

There are two types of `Switch case types in the Go Programming language.

  • Expression Switch: In this case, Switch expressions are compared with case expressions.
  • Type Switch:Switch expression types are compared with case expressions.

Golang Expression Switch case

Expression switch is used to compare an expression with a value of case expressions.

Here is a syntax for switch case

switch (variable | boolean - expression | Integer type) {
    case boolean - expression | integer type
    Block of code contains statements
    case boolean - expression | integer type
    Block of code contains statements
    default: // default  case and it is optional  
        Block of code contains statements
}

Following are the keynotes of expression switch.

  • Switch executes from top to bottom, Stop its execution when a matching case occurs.
  • It contains any number of case statements with each case statement containing an expression and a colon.
  • the default case is optional. This will be executed when the matching case is not executed. This placed last case and a break is not required
  • Switch expression and case expression must be evaluated to the same type, Otherwise, it gives a compilation error.
  • For example, Switch evaluates to float and case evaluates to float only.
  • curly braces for the case body is optional.
  • if there are many matched cases, the first matched cases are executed.

Golang Switch case Example

Here is a basic example of switch-case statements.

In the below example, The number is declared with the value 1. In the switch, the number compares with the value of the number against all case statements. case statements are evaluated from top to bottom.

Matched first executes its code block, In this case, 1 is matched, and 1 matched is displayed to the console. switch expression can be enclosed with parenthesis and without parenthesis i.e both switch number or switch (number) are allowed and valid codes.

package main

import "fmt"

func main() {
    number: = 1
    switch number {
        case 1:
            fmt.Println("1 matched")
        case 2:
            fmt.Println("2 matched")
        case 3:
            fmt.Println("3 matched")
        case 4:
            fmt.Println("4 matched")
        default:
            fmt.Println("default matched")
    }
}

Output:

1 matched  

Following are various examples of the switch case.

The duplicate case with the same values are not allowed

In the below code, the duplicate case is declared with the same values - case 3 is declared two times.

The compiler gives compilation error - duplicate case 3 in switch previous case at

package main

import "fmt"

func main() {
    number: = 1
    switch number {
        case 1:
            fmt.Println("1 matched")
        case 2:
            fmt.Println("2 matched")
        case 3:
            fmt.Println("3 matched")
        case 3: // duplciate case is declared here - Compilation error  
            fmt.Println("3 matched")
        case 4:
            fmt.Println("4 matched")
        default:
            fmt.Println("default matched")
    }
}

Default case executes when the matched case is not declared

what will happen when the number is given as 10? to the same example.

the matching case for the number is not defined in the code. Hence, the default case will be executed and printed default matched text is printed to the console output.

package main

import "fmt"

func main() {
    number: = 11
    switch number {
        case 1:
            fmt.Println("1 matched")
        case 2:
            fmt.Println("2 matched")
        case 3:
            fmt.Println("3 matched")
        case 4:
            fmt.Println("4 matched")
        default:
            fmt.Println("default matched")
    }
}

of the above program is

default matched  

The default case is optional. It is advisable to be the last case statement, but there is no effect on the way of switch case functionality.

Switch with No expression or Condition in go language

The switch declare without expression or condition.

When no expression is used, It treats switch case as a true value. switch with no expression or condition or value always equals to switch true. case expression always should be expression or condition.

package main

import "fmt"

func main() {
    number: = 11
    switch {
        case number > 10:
            fmt.Println("Number is greater than 10")
        case number > 20:
            fmt.Println("Number is greater than 20")
        case number > 30:
            fmt.Println("Number is greater than 30")
        default:
            fmt.Println("default matched")
    }
}

and output of the program code is

the number is greater than 10  

when no expressions in the switch case, the case expression must be non-constants

package main

import "fmt"

func main() {
    number: = 11
    switch {
        case 1:
            fmt.Println("1 matched")
        case 2:
            fmt.Println("2 matched")
        case 3:
            fmt.Println("3 matched")
        case 4:
            fmt.Println("4 matched")
        default:
            fmt.Println("default matched")
    }
}

the above code is not compiled. The reason is switch without expression code should have case non-constants.

The compilation error is invalid case 1 in a switch (mismatched types int and bool) Complete error for the command is go run filename

.\First.go:8:2: invalid case 1 in switch (mismatched types int and bool)  
.\First.go:10:2: invalid case 2 in switch (mismatched types int and bool)  
.\First.go:12:2: invalid case 3 in switch (mismatched types int and bool)  
.\First.go:14:2: invalid case 4 in switch (mismatched types int and bool)  

Switch case contains multiple expressions or conditions

It can have multiple expressions separated by a comma symbol.

Here is an example

package main
import "fmt"

func main() {
    weekday: = "tuesday"
    switch weekday {
        case "monday", "tuesday", "wednesday", "thursday", "friday":
            fmt.Println("Working Day")
        default:
            fmt.Println("Not working day: weekend")
    }
}

The output of the above program is

Working Day  

the above code, Code checks weekday is working day or not. the case is defined with multiple strings which are declared as working days.

fallthrough case in the switch in the case body

Normally, when the matched case is found with the switch case, the code inside matched case executes, and the control exits from the switch case.

fallthrough statement is special functionality used to jump the control from the next immediate available case fallthrough is a keyword in golang, hence it will not be used as a variable or function name.

package main

import "fmt"

func main() {
    number: = 1
    switch number {
        case 1:
            fmt.Println("1 matched")
            fallthrough
        case 2:
            fmt.Println("2 matched")
            fallthrough
        case 3:
            fmt.Println("3 matched")
        case 4:
            fmt.Println("4 matched")
        default:
            fmt.Println("default matched")
    }
}

The output of the above program is

1 matched  
2 matched  
3 matched  

without the fallthrough statement, The output is

1 matched  

In the above code, Control comes to the matched case, case 1 is matched, a fallthrough statement exists, and Control transfers to the first line of code of the next case 2 statement. This statement is the last statement inside the code of the case statement.

if you declare fallthrough is not a line of code, It gives a compilation error the following code gives fallthrough statement out of place

package main

import "fmt"

func main() {
    number: = 1
    switch number {
        case 1:
            fallthrough // not allowed as first or middle - compilation error  
            fmt.Println("1 matched")
        case 2:
            fmt.Println("2 matched")
            fallthrough
        case 3:
            fmt.Println("3 matched")
        case 4:
            fmt.Println("4 matched")
        default:
            fmt.Println("default matched")
    }
}

switch case floating values example

Switch and case expression can also be declared with floating values and it is valid code. Other languages are not supported to be used in switch case expressions.

Golang has no issues with it.

The below program contains floating numbers, and matched cases with floating values are evaluated. In this case, 6.5 matched is printed to the console.

func main() {
    number: = 6.5
    switch number {
        case 5.5:
            fmt.Println("5.5 matched")
        case 6.5:
            fmt.Println("6.5 matched")
        default:
            fmt.Println("default matched")
    }
}

and output of the above program is

6.5 matched 

switch case String literals in golang

The expression can also be string literals.

String literals are a group of characters enclosed in double quotes.

It checks the exact match of string literals.

In the below code, the Case contains String literals, the Switch expression contain string variable, the Matched case is evaluated, and the output is TWO matched

func main() {  
 number := "TWO"  
 switch number {  
 case "ONE":  
  fmt.Println("ONE matched")  
 case "TWO":  
  fmt.Println("TWO matched")  
 default:  
  fmt.Println("default matched")  
 }  
}  

The output of the above program is

TWO matched  

Break statement to exit from the loop

break statement can also be used in switch cases.

It is used to exit from the inner loop inside the switch.

When you are using for loop with a switch case, the break keyword will be used.

Here is an example without a break statement for loop iterates with 3 values, Inside the loop, Switch is declared, and matched cases values are printed.

func main() {
    var numbArray = [3] int {
        1, 2, 5
    }
    for _, numb: = range numbArray {
        switch numb {
            case 1:
                fmt.Println("1 matched")
            case 2:
                fmt.Println("2 matched")
                break
            case 0:
                fmt.Println("0 matched")
        }
    }
}

Output:

1 matched  
2 matched  

Now we will rewrite the code with break and named labels in switch-case statements.

In the below loop code, for the first matched case, the break label is used, It exists from the named label and outputs only 1 matched case.

func main() {
    var numbArray = [3] int {
        1, 2, 5
    }
    MyLoopName:
        for _, numb: = range numbArray {
            switch numb {
                case 1:
                    fmt.Println("1 matched")
                    break MyLoopName
                case 2:
                    fmt.Println("2 matched")
                    break
                case 0:
                    fmt.Println("0 matched")
            }
        }
}

Output:

1 matched  

Functions can be used as Expression in switch and case

the expression can also be a function named calls and valid in go language.

Following is an example of functions in switch expressions.

In the below example, the Simple function is declared, It just returns the passed parameter no value is processed. This is being used in Switch expression as well as case expression.

func myfunction(parameter string) string {
    return parameter
}
func main() {
    switch myfunction("mon") {
        case myfunction("mon"), myfunction("tue"), myfunction("wed"), myfunction("thu"), myfunction("fri"):
            fmt.Println("working day")
        case myfunction("sat"), myfunction("sun"):
            fmt.Println("Not working day: weekend")
    }
}

Output:

working day  

Type Switch in Goland

Type switch is mostly used in interfaces.

Type switch is the way of checking multiple types and evaluating the first matched type case. These are mostly used to type assertions Difference between the expression switch and type switch, the Normal switch is compared values with case values.

Type switch compares types not values with case types.
Here is a syntax for type switch

func main() {
    switch variable.(type) {
        case type:
            Code block statements
        case type:
            code block statements
        default:
            code block statements
    }
}

variable.(type) represents type assertion that contains specific type as “type”. Following are key points of the type switch expressions

  • You can define any number of case statements
  • The expression defined in this type always of the interface type variable
  • Like a normal switch expression, Default is also optional, and last declared, the break is not required.
  • Switch type and case type must be of the same type or follows the is-a principle.
  • When switch type and case type are matched, matched case code body is executed, and exit from the switch code, Break is not required

switch type assertion interface example

In the below example, interface() is an empty interface type that can accept any type of value.

package main

import "fmt"

func main() {
    var interfaceDemo interface {} = 45

    switch interfaceDemo.(type) {
        case string:
            fmt.Println("string type matched")
        case int:
            fmt.Println("int type matched")
        default:
            fmt.Println("default type matched")

    }
}

The output:

int type matched  

type switch struct example

Type switch casecan be used withstruct data types.

struct type contains a custom type that contains multiple types.

package main

import "fmt"

func main() {
    type Employee struct {
        ID int
        Name string
    }
    emp: = Employee {
        1, "Kiran"
    }
    var empInterface interface {}
    empInterface = emp
    switch empInterface.(type) {
        case Employee:
            fmt.Println("Employee type matched")
        case string:
            fmt.Println("String type matched")
        default:
            fmt.Println("default type matched")
    }
} 

output:

Employee type matched  

Conclusion

Learn about the complete tutorial switch case in golang.

THE BEST NEWSLETTER ANYWHERE
Join 6,000 subscribers and get a daily digest of full stack tutorials delivered to your inbox directly.No spam ever. Unsubscribe any time.

Similar Posts
Subscribe
You'll get a notification every time a post gets published here.