switch/case — Maple v0.0.11 Documentation

### Navigation

- next
- previous |
- LeafLabs |
- Index »
- Complete Language Index »

# `switch`/`case`

Like if statements, A `switch` statement controls program flow by allowing you to specify different code that should be executed under various cases.

The general syntax looks like this:

    switch (var) {
    case val1:
        // statements
        break;
    case val2:
        // statements
        break;
    ...
    default:
        // statements
    }

Where `var` is a variable whose value to investigate, and the `val1`, `val2` after each `case` are constant values that `var` might be.

## Description

A `switch` statement compares the value of a variable to the values specified in `case` statements. When a `case` statement is found whose value matches that of the variable, the code in that case statement is run.

Here’s a more concrete example:

    switch (var) {
    case 1:
        doThing1();
        break;
    case 2:
        doThing2();
        break;
    }
    afterTheSwitch();

In the above example, if `var == 1`, then the code beginning on the line after `case 1` gets executed. That is, if `var` is one, `doThing1()` gets called first, and then the `break` statement is executed.

The `break` keyword exits the `switch` statement, and is typically used at the end of each `case`. Since there is a `break` at the end of `case 1`, the `switch` statement exits, and the next line to be run is the one which calls `afterTheSwitch()`.

Without a `break`, the `switch` statement will continue executing the following `case` expressions (“falling-through”) until a `break` (or the end of the switch statement) is reached. Let’s pretend the `switch` looked like this instead:

    switch (var) {
    case 1:
        doThing1();
        // no break statement anymore
    case 2:
        doThing2();
        break;
    }
    afterTheSwitch();

Now, if `var` is one, `doThing1()` gets executed like before. However, without a `break`, the code would continue to be executed line-by-line, so `doThing2()` would be called next. At this point, a `break` has been reached, so the program continues by calling `afterTheSwitch()`. This is usually not what you want, which is why each `case` usually has a `break` at the end.

Writing “`default:`” instead of a `case` statement allows you to specify what to do if none of the `case` statements matches. Having a `default` is optional (you can leave it out), but if you have one, it must appear after all of the `case` statements. Let’s add a `default` to the `switch` we’ve been discussing:

    switch (var) {
    case 1:
        doThing1();
        break;
    case 2:
        doThing2();
        break;
    default:
        doSomethingElse();
    }
    afterTheSwitch();

If `var` is one, then `doThing1()` gets called. If `var` is two, `doThing2()` gets called. If `var` is anything else, `doSomethingElse()` gets called. As stated above, a `default` is optional. If you’re missing one and none of the `case` statements match, the `switch` does nothing at all, as if it weren’t there.

`switch` statements are often used with an enum value as the variable to compare. In this case, you can write down all of the values the `enum` takes as `case` statements, and be sure you’ve covered all the possibilities.

## See Also:

- if/else

License and Attribution

Portions of this page were adapted from the Arduino Reference Documentation, which is released under a Creative Commons Attribution-ShareAlike 3.0 License.

### Navigation

- next
- previous |
- LeafLabs |
- Index »
- Complete Language Index »