原文链接：https://javascript.info/switch，translate with ❤️ by zhangbao.

一个 switch 语句可以替换多个 if 检查。

它提供了一种更具描述性的方法来比较一个值和多个变体。

语法

switch 语句就可以有一个或者多个 case 块和一个可选的 default。

看起来像这样：

  1. switch(x) {
  2.   case 'value1':  // if (x === 'value1')
  3.     ...
  4.     [break]
  6.   case 'value2':  // if (x === 'value2')
  7.     ...
  8.     [break]
  10.   default:
  11.     ...
  12.     [break]
  13. }

  • x 的值使用严格相等运算符进行比较的，从第一个 case 开始（也就是 value1），然后是第二个等等（value2）。

  • 如果找到匹配的值后，switch 就从当前的 case 处开始执行代码，直到找到最近的 break（或者是到 switch 的结尾）。

  • 如果没有找到匹配的话，就会执行 defalt 中的代码（如果存在的话）。

例子

一个 switch 的例子：

  1. let a = 2 + 2;
  3. switch (a) {
  4.   case 3:
  5.     alert( 'Too small' );
  6.     break;
  7.   case 4:
  8.     alert( 'Exactly!' );
  9.     break;
  10.   case 5:
  11.     alert( 'Too large' );
  12.     break;
  13.   default:
  14.     alert( "I don't know such values" );
  15. }

这里的 switch 从第一个 case 开始去比较 a 是否等于 3，匹配失败。

然后是 4，匹配到了，所以执行从 case 4 开始，到最近的 break 结束。

如果没有 break 的话，执行会继续进入到下一个 case 而不会有任何检查。

一个没有 break 的例子：

  1. let a = 2 + 2;
  3. switch (a) {
  4.   case 3:
  5.     alert( 'Too small' );
  6.   case 4:
  7.     alert( 'Exactly!' );
  8.   case 5:
  9.     alert( 'Too big' );
  10.   default:
  11.     alert( "I don't know such values" );
  12. }

上面的例子，我们能看到连续 3 次弹出 alert：

  1. alert( 'Exactly!' );
  2. alert( 'Too big' );
  3. alert( "I don't know such values" );

⚠️switch/case 的参数可以是任意表达式

switch 和 case 都接受任意表达式作为参数。

例如：

  1. let a = "1";
  2. let b = 0;
  4. switch (+a) {
  5.   case b + 1:
  6.     alert("this runs, because +a is 1, exactly equals b+1");
  7.     break;
  9.   default:
  10.     alert("this doesn't run");
  11. }

这里 +a 得到 1，与 b + 1 这个 case 进行比较，对应的代码会遭执行。

“case”分组

分享相同代码的不同 case 变体可以组合成一个。

例如，如果我们想要一段逻辑在 case 3 和 case 5 时执行时：

  1. let a = 2 + 2;
  3. switch (a) {
  4.   case 4:
  5.     alert('Right!');
  6.     break;
  8.   case 3:                    // (*) 组合两种 case
  9.   case 5:
  10.     alert('Wrong!');
  11.     alert("Why don't you take a math class?");
  12.     break;
  14.   default:
  15.     alert('The result is strange. Really.');
  16. }

在 3 和 5 的情况下，会显示相同的信息。

这种“分组”的实现，得益于 switch/case 在没有 break 情况下的副作用。在 case 3 的情况，由于没有 break 就穿越到了 case 5。

类型敏感的

让我们强调一下，平等检查总是严格的。这些值必须是相同类型匹配的。

例如，考虑下下面的代码：

  1. let arg = prompt("Enter a value?")
  2. switch (arg) {
  3.   case '0':
  4.   case '1':
  5.     alert( 'One or zero' );
  6.     break;
  8.   case '2':
  9.     alert( 'Two' );
  10.     break;
  12.   case 3:
  13.     alert( 'Never executes!' );
  14.     break;
  15.   default:
  16.     alert( 'An unknown value' )
  17. }

  1. 对于 0，1，会执行第一个 alert。

  2. 对于 2，会执行第二个 alert。

  3. 但是对于 3，prompt 的结果是字符串 “3”，并不严格相等 === 与数值 3。因此这里不会执行 case 3！而是默认的 default 会执行。

（完）