Příkaz switch

A switch příkaz může nahradit více if kontroly.

Poskytuje popisnější způsob porovnání hodnoty s více variantami.

Syntaxe

switch má jeden nebo více case bloky a volitelné výchozí nastavení.

Vypadá to takto:

switch(x) {
 case 'value1': // if (x === 'value1')
 ...
 [break]

 case 'value2': // if (x === 'value2')
 ...
 [break]

 default:
 ...
 [break]
}
  • Hodnota x se kontroluje, zda je přísná rovnost s hodnotou z prvního case (tj. value1 ) a poté na druhý (value2 ) a tak dále.
  • Pokud je nalezena rovnost, switch spustí provádění kódu počínaje odpovídajícím case , až na nejbližší break (nebo do konce switch ).
  • Pokud neodpovídá žádná velká a malá písmena, pak default kód se provede (pokud existuje).

Příklad

Příklad switch (vykonaný kód je zvýrazněn):

let a = 2 + 2;

switch (a) {
 case 3:
 alert( 'Too small' );
 break;
 case 4:
 alert( 'Exactly!' );
 break;
 case 5:
 alert( 'Too big' );
 break;
 default:
 alert( "I don't know such values" );
}

Zde je switch začne porovnávat a od prvního case varianta, která je 3 . Zápas se nezdaří.

Potom 4 . To je shoda, takže provádění začíná od case 4 až po nejbližší break .

Pokud zde není break pak provádění pokračuje dalším case bez jakýchkoli kontrol.

Příklad bez break :

let a = 2 + 2;

switch (a) {
 case 3:
 alert( 'Too small' );
 case 4:
 alert( 'Exactly!' );
 case 5:
 alert( 'Too big' );
 default:
 alert( "I don't know such values" );
}

Ve výše uvedeném příkladu uvidíme sekvenční spuštění tří alert s:

alert( 'Exactly!' );
alert( 'Too big' );
alert( "I don't know such values" );
Jakýkoli výraz může být switch/case argument

Oba switch a case povolit libovolné výrazy.

Například:

let a = "1";
let b = 0;

switch (+a) {
 case b + 1:
 alert("this runs, because +a is 1, exactly equals b+1");
 break;

 default:
 alert("this doesn't run");
}

Zde +a dává 1 , což je ve srovnání s b + 1 v case a spustí se odpovídající kód.

Seskupení „případu“

Několik variant case které sdílejí stejný kód, lze seskupit.

Například pokud chceme, aby stejný kód běžel pro case 3 a case 5 :

let a = 3;

switch (a) {
 case 4:
 alert('Right!');
 break;

 case 3: // (*) grouped two cases
 case 5:
 alert('Wrong!');
 alert("Why don't you take a math class?");
 break;

 default:
 alert('The result is strange. Really.');
}

Nyní oba 3 a 5 zobrazit stejnou zprávu.

Schopnost „seskupovat“ případy je vedlejším efektem toho, jak switch/case funguje bez break . Zde je spuštění case 3 začíná od řádku (*) a prochází přes case 5 , protože neexistuje break .

Na typu záleží

Zdůrazněme, že kontrola rovnosti je vždy přísná. Aby se hodnoty shodovaly, musí být stejného typu.

Podívejme se například na kód:

let arg = prompt("Enter a value?");
switch (arg) {
 case '0':
 case '1':
 alert( 'One or zero' );
 break;

 case '2':
 alert( 'Two' );
 break;

 case 3:
 alert( 'Never executes!' );
 break;
 default:
 alert( 'An unknown value' );
}
  1. Pro 0 , 1 , první alert běží.
  2. Pro 2 druhý alert běží.
  3. Ale pro 3 , což je výsledek prompt je řetězec "3" , což se přesně nerovná === na číslo 3 . Takže máme mrtvý kód v case 3 ! default varianta se provede.