Introduction

Sometimes you want a switch to produce a value instead of just running statements. Whether that is elegant or awkward depends heavily on the language. Modern languages such as C# and newer Java support switch expressions directly, while older switch statements usually require assignment inside each branch or an alternative pattern such as a lookup table.

Traditional Switch Statement with Assignment

In languages with a classic statement-only switch, the usual pattern is to declare a variable and assign it inside each branch.

JavaScript example:

1const status = "paid";
2let label;
3
4switch (status) {
5  case "paid":
6    label = "Completed";
7    break;
8  case "pending":
9    label = "Waiting";
10    break;
11  default:
12    label = "Unknown";
13}
14
15console.log(label);

This works, but it spreads the assignment across branches and requires care around break.

Prefer Switch Expressions When the Language Supports Them

Some languages let the switch itself evaluate to a value.

C# example:

1string status = "paid";
2
3string label = status switch
4{
5    "paid" => "Completed",
6    "pending" => "Waiting",
7    _ => "Unknown"
8};
9
10Console.WriteLine(label);

This is usually cleaner because:

• every branch returns a value
• there is no accidental fall-through
• the result is assigned in one place

Java has a similar newer form:

1String status = "paid";
2
3String label = switch (status) {
4    case "paid" -> "Completed";
5    case "pending" -> "Waiting";
6    default -> "Unknown";
7};
8
9System.out.println(label);

If your language supports switch expressions, use them for value selection.

Object or Dictionary Lookup Can Be Simpler

For plain key-to-value mapping, a lookup table is often simpler than a switch.

JavaScript example:

1const labels = {
2  paid: "Completed",
3  pending: "Waiting",
4  failed: "Rejected",
5};
6
7const status = "paid";
8const label = labels[status] ?? "Unknown";
9
10console.log(label);

Python equivalent:

1labels = {
2    "paid": "Completed",
3    "pending": "Waiting",
4    "failed": "Rejected",
5}
6
7status = "paid"
8label = labels.get(status, "Unknown")
9print(label)

This is often the best choice when the mapping is simple and there is no branch-specific logic.

When a Switch Is the Right Tool

A switch remains useful when:

• each branch contains more than one line of logic
• different branches need different local computations
• the language optimizes or reads more clearly with switch syntax

Example in JavaScript:

1const status = "paid";
2let message;
3
4switch (status) {
5  case "paid": {
6    const timestamp = new Date().toISOString();
7    message = `Completed at ${timestamp}`;
8    break;
9  }
10  case "pending":
11    message = "Waiting for payment";
12    break;
13  default:
14    message = "Unknown state";
15}
16
17console.log(message);

Here the switch is doing more than a simple constant mapping, so the statement form is still reasonable.

Avoid Fall-Through Bugs

If you assign inside a classic switch, forgetting break can overwrite the result:

1let label;
2
3switch ("paid") {
4  case "paid":
5    label = "Completed";
6  default:
7    label = "Unknown";
8}

The final value becomes "Unknown" because execution falls through. That is one reason expression-style switch forms are safer when available.

Common Pitfalls

• Using a classic switch for simple mappings where a dictionary or switch expression would be cleaner.
• Forgetting break and accidentally overwriting the variable.
• Declaring the result variable in a scope that allows partially initialized states.
• Writing branch logic so complex that the switch stops being readable.
• Forcing switch syntax in languages where other constructs are more natural.

Summary

• In older switch statements, assign the variable inside each branch.
• In languages with switch expressions, let the switch return the value directly.
• For simple key-to-value mappings, a dictionary or lookup object is often cleaner than a switch.
• Be careful about fall-through when using classic switch syntax.
• Choose the construct that best matches whether you are selecting a value or running branch-specific logic.