What is a Switch / Match Statement?

A Switch / Match statement is a decision-making structure used when a program needs to choose one block of code from many possible options.

In simple words, a switch or match statement checks the value of an expression and compares it with multiple possible cases. When a matching case is found, the related block of code is executed.

It is especially useful when a program has many fixed choices, such as menu options, days of the week, calculator operations, user roles, status codes, or command choices.

Easy Real-Life Example

Similarly, a switch statement checks the selected value and runs the matching action.

SWITCH floorNumber
    CASE 1:
        DISPLAY "Going to Floor 1"

    CASE 2:
        DISPLAY "Going to Floor 2"

    CASE 3:
        DISPLAY "Going to Floor 3"

    DEFAULT:
        DISPLAY "Invalid floor"
END SWITCH

Why is Switch / Match Statement Needed?

When a program has many possible choices, writing many IF ELSE IF conditions can become long and difficult to read. A switch or match statement makes such logic cleaner and more organized.

General Syntax of Switch Statement

The language-neutral structure of a switch statement is:

SWITCH expression
    CASE value1:
        statements for value1

    CASE value2:
        statements for value2

    CASE value3:
        statements for value3

    DEFAULT:
        statements when no case matches
END SWITCH

The expression is checked once. Its value is compared with each case. If a case matches, the statements for that case are executed.

General Syntax of Match Statement

A match statement is similar to a switch statement, but in some modern programming languages it may support more flexible matching, such as matching values, patterns, types, or structures.

MATCH expression
    CASE pattern1:
        statements for pattern1

    CASE pattern2:
        statements for pattern2

    CASE pattern3:
        statements for pattern3

    DEFAULT:
        statements when no pattern matches
END MATCH

For this language-neutral course, students can understand SWITCH and MATCH as decision structures used to choose one matching case from many possible choices.

How Switch / Match Statement Works

A switch or match statement follows a clear decision flow.

Switch / Match Statement Flow

START
  ↓
Evaluate expression
  ↓
Does it match Case 1?
  ├── Yes → Execute Case 1
  └── No  → Check Case 2
              ├── Yes → Execute Case 2
              └── No  → Check Case 3
                          ├── Yes → Execute Case 3
                          └── No  → Execute Default
  ↓
Continue program

This flow shows how the program checks cases one by one until a matching option is found.

Main Parts of a Switch / Match Statement

Example 1: Calculator Operation

A calculator is a perfect example of using a switch or match statement because the operation is selected from fixed choices.

/*
This program selects calculator operation using SWITCH.
*/

ENTRY POINT
    DECLARE firstNumber AS DECIMAL = 0.0
    DECLARE secondNumber AS DECIMAL = 0.0
    DECLARE operation AS TEXT = ""
    DECLARE result AS DECIMAL = 0.0

    DISPLAY "Enter first number:"
    INPUT firstNumber

    DISPLAY "Enter second number:"
    INPUT secondNumber

    DISPLAY "Choose operation: +, -, *, /"
    INPUT operation

    SWITCH operation
        CASE "+":
            SET result = firstNumber + secondNumber
            DISPLAY "Result: " + result

        CASE "-":
            SET result = firstNumber - secondNumber
            DISPLAY "Result: " + result

        CASE "*":
            SET result = firstNumber * secondNumber
            DISPLAY "Result: " + result

        CASE "/":
            IF secondNumber != 0 THEN
                SET result = firstNumber / secondNumber
                DISPLAY "Result: " + result
            ELSE
                DISPLAY "Division by zero is not allowed"
            END IF

        DEFAULT:
            DISPLAY "Invalid operation"
    END SWITCH
END ENTRY POINT

The program checks the value of operation. If the operation is +, addition runs. If it is -, subtraction runs. If no operation matches, the default message is shown.

Example 2: Day Name from Day Number

This example displays the day name based on a number.

/*
This program displays day name using SWITCH.
*/

ENTRY POINT
    DECLARE dayNumber AS INTEGER = 0

    DISPLAY "Enter day number from 1 to 7:"
    INPUT dayNumber

    SWITCH dayNumber
        CASE 1:
            DISPLAY "Monday"

        CASE 2:
            DISPLAY "Tuesday"

        CASE 3:
            DISPLAY "Wednesday"

        CASE 4:
            DISPLAY "Thursday"

        CASE 5:
            DISPLAY "Friday"

        CASE 6:
            DISPLAY "Saturday"

        CASE 7:
            DISPLAY "Sunday"

        DEFAULT:
            DISPLAY "Invalid day number"
    END SWITCH
END ENTRY POINT

Sample Output

Enter day number from 1 to 7:
3

Wednesday

Since the entered value is 3, the program runs the case for Wednesday.

Example 3: Menu-Based Program

Switch statements are very useful in menu-driven programs.

/*
This program handles menu selection using SWITCH.
*/

ENTRY POINT
    DECLARE choice AS INTEGER = 0

    DISPLAY "----- Main Menu -----"
    DISPLAY "1. Add Student"
    DISPLAY "2. View Student"
    DISPLAY "3. Update Student"
    DISPLAY "4. Delete Student"
    DISPLAY "5. Exit"

    DISPLAY "Enter your choice:"
    INPUT choice

    SWITCH choice
        CASE 1:
            DISPLAY "Add Student selected"

        CASE 2:
            DISPLAY "View Student selected"

        CASE 3:
            DISPLAY "Update Student selected"

        CASE 4:
            DISPLAY "Delete Student selected"

        CASE 5:
            DISPLAY "Exit selected"

        DEFAULT:
            DISPLAY "Invalid menu choice"
    END SWITCH
END ENTRY POINT

Each menu number maps to a specific action. This is easier to read than a long else-if ladder for fixed menu choices.

Example 4: User Role Matching

A switch or match statement can also be used to choose actions based on user role.

/*
This program displays access level based on user role.
*/

ENTRY POINT
    DECLARE userRole AS TEXT = ""

    DISPLAY "Enter user role:"
    INPUT userRole

    MATCH userRole
        CASE "admin":
            DISPLAY "Access granted to admin dashboard"

        CASE "teacher":
            DISPLAY "Access granted to teacher dashboard"

        CASE "student":
            DISPLAY "Access granted to student dashboard"

        CASE "guest":
            DISPLAY "Access granted to guest area"

        DEFAULT:
            DISPLAY "Unknown role"
    END MATCH
END ENTRY POINT

In this example, MATCH checks the role value and runs the matching block.

Switch / Match vs Else-If Ladder

Switch / match statements and else-if ladders are both used for decision making, but they are useful in different situations.

When to Use Switch / Match

Use switch or match when the program compares one value against multiple fixed choices.

When Not to Use Switch / Match

Switch or match may not be the best choice when conditions involve ranges, multiple unrelated variables, or complex logical checks.

Default Case

The DEFAULT case is used when no case matches the expression.

SWITCH choice
    CASE 1:
        DISPLAY "Start"

    CASE 2:
        DISPLAY "Settings"

    CASE 3:
        DISPLAY "Exit"

    DEFAULT:
        DISPLAY "Invalid choice"
END SWITCH

The default case is useful because it handles unexpected or invalid input.

Break / Exit Concept

In some programming languages, a matched case needs a break or exit instruction to stop execution from continuing into the next case.

Since this course is language-neutral, students should understand the concept as:

CASE value:
    Run this case
    Exit the switch after this case

Without proper exit behavior in languages that require it, the program may continue executing later cases unexpectedly.

Language-Neutral Switch with Exit Concept

SWITCH choice
    CASE 1:
        DISPLAY "Option 1 selected"
        EXIT SWITCH

    CASE 2:
        DISPLAY "Option 2 selected"
        EXIT SWITCH

    CASE 3:
        DISPLAY "Option 3 selected"
        EXIT SWITCH

    DEFAULT:
        DISPLAY "Invalid option"
END SWITCH

The EXIT SWITCH idea represents stopping after the matched case.

Trace Table for Switch Example

Let us trace a menu-based switch statement.

SWITCH choice
    CASE 1:
        DISPLAY "Add"
    CASE 2:
        DISPLAY "View"
    CASE 3:
        DISPLAY "Exit"
    DEFAULT:
        DISPLAY "Invalid"
END SWITCH

How Switch / Match Helps Debugging

Switch or match statements make debugging easier because cases are clearly separated.

Common Beginner Mistakes

Best Practices for Switch / Match Statement

Good switch or match logic should be clean, readable, and suitable for fixed choices.

Prerequisites Before Learning Switch / Match Statement

To understand switch and match statements properly, students should already know these concepts:

Practice Activity: Complete the Switch Statement

Complete the following pseudocode to display calculator operation names.

INPUT operation

SWITCH operation
    CASE "+":
        DISPLAY "Addition"

    CASE "-":
        DISPLAY "Subtraction"

    CASE "*":
        DISPLAY "________________"

    CASE "/":
        DISPLAY "________________"

    DEFAULT:
        DISPLAY "Invalid operation"
END SWITCH

Sample Answer

INPUT operation

SWITCH operation
    CASE "+":
        DISPLAY "Addition"

    CASE "-":
        DISPLAY "Subtraction"

    CASE "*":
        DISPLAY "Multiplication"

    CASE "/":
        DISPLAY "Division"

    DEFAULT:
        DISPLAY "Invalid operation"
END SWITCH

Mini Quiz

Interview Questions on Switch / Match Statement

Quick Summary