JavaScript switch/case statements

last modified April 16, 2025

In this article we show how to use the switch and case keywords to create conditional statements in JavaScript.

The switch/case statement

The switch statement evaluates an expression and executes code based on matching cases. It provides an alternative to long if-else chains when testing a single value against multiple possibilities.

Each case represents a possible match for the switch expression. When a match is found, the corresponding code block executes until a break statement is encountered.

The default case executes when no matches are found. While optional, it's good practice to include a default case for handling unexpected values.

Basic switch statement

The following example demonstrates the basic structure of a switch statement.

let day = 3;
let dayName;
switch (day) {
 case 1:
 dayName = 'Monday';
 break;
 case 2:
 dayName = 'Tuesday';
 break;
 case 3:
 dayName = 'Wednesday';
 break;
 case 4:
 dayName = 'Thursday';
 break;
 case 5:
 dayName = 'Friday';
 break;
 default:
 dayName = 'Weekend';
}
console.log(dayName);

This code converts a numeric day to its corresponding name. The switch evaluates the day variable and executes the matching case. Without break statements, execution would "fall through" to subsequent cases.

$ node main.js
Wednesday

Fall-through behavior

JavaScript switch statements exhibit fall-through behavior by default.

let grade = 'B';
let message;
switch (grade) {
 case 'A':
 case 'B':
 case 'C':
 message = 'Passing grade';
 break;
 case 'D':
 message = 'Barely passing';
 break;
 case 'F':
 message = 'Failing grade';
 break;
 default:
 message = 'Unknown grade';
}
console.log(message);

Here multiple cases share the same code block. Grades A, B, and C all result in the same message. This demonstrates intentional fall-through, which can be useful for grouping related cases together.

$ node main.js
Passing grade

Strict comparison

Switch statements use strict comparison (===) when matching cases.

let value = '5';
switch (value) {
 case 5:
 console.log('Number 5');
 break;
 case '5':
 console.log('String "5"');
 break;
 default:
 console.log('Unknown value');
}

This example shows that the string '5' doesn't match the number 5 due to strict type comparison. The switch statement distinguishes between different data types when evaluating cases.

$ node main.js
String "5"

Using expressions in cases

Case labels can contain expressions that evaluate to constant values.

let score = 85;
let grade;
switch (true) {
 case score >= 90:
 grade = 'A';
 break;
 case score >= 80:
 grade = 'B';
 break;
 case score >= 70:
 grade = 'C';
 break;
 case score >= 60:
 grade = 'D';
 break;
 default:
 grade = 'F';
}
console.log(grade);

This technique uses boolean expressions in cases by switching on true. Each case is evaluated until a matching condition is found. It provides a clean alternative to complex if-else chains for range checking.

$ node main.js
B

Switch with multiple conditions

Switch statements can handle multiple conditions in a single case.

let fruit = 'apple';
let color;
switch (fruit) {
 case 'apple':
 case 'strawberry':
 color = 'red';
 break;
 case 'banana':
 case 'lemon':
 color = 'yellow';
 break;
 case 'orange':
 color = 'orange';
 break;
 default:
 color = 'unknown';
}
console.log(color);

This example groups fruits by color. Multiple fruits can share the same color assignment. The switch statement provides a clean way to handle these grouped conditions without repetitive code.

$ node main.js
red

Switch vs if-else

Switch statements often provide cleaner code than equivalent if-else chains.

let browser = 'Firefox';
switch (browser) {
 case 'Chrome':
 case 'Firefox':
 case 'Safari':
 console.log('Supported browser');
 break;
 case 'IE':
 console.log('Deprecated browser');
 break;
 default:
 console.log('Unknown browser');
}

The switch version is more readable than a series of if-else statements when checking multiple exact matches. It clearly shows all possible cases and their corresponding actions in a structured format.

$ node main.js
Supported browser

Practical example: command processor

Here's a practical example of using switch to process different commands.

function processCommand(cmd) {
 switch (cmd.toLowerCase()) {
 case 'start':
 console.log('Starting system...');
 break;
 case 'stop':
 console.log('Stopping system...');
 break;
 case 'restart':
 console.log('Restarting system...');
 break;
 case 'status':
 console.log('System status: OK');
 break;
 default:
 console.log(`Unknown command: ${cmd}`);
 }
}
processCommand('START');
processCommand('status');
processCommand('backup');

This command processor demonstrates how switch can handle different input commands. The toLowerCase() ensures case-insensitive matching. The default case handles invalid commands gracefully.

$ node main.js
Starting system...
System status: OK
Unknown command: backup

Source

switch - language reference

In this article we have demonstrated how to use the switch and case keywords to create conditional statements in JavaScript.

Author

My name is Jan Bodnar, and I am a passionate programmer with extensive programming experience. I have been writing programming articles since 2007. To date, I have authored over 1,400 articles and 8 e-books. I possess more than ten years of experience in teaching programming.

List all JavaScript tutorials.