Příkaz „switch“

Příkaz switch dokáže nahradit nÄ›kolik podmínÄ›ných příkazů if.

Poskytuje přehlednější způsob, jak porovnat hodnotu s několika variantami.

Syntaxe

Příkaz switch obsahuje jeden nebo více bloků case a nepovinný blok default.

Vypadá to takto:

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

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

  default:
    ...
    [break]
}

• Je ověřena striktní rovnost hodnoty x s hodnotou z prvního case (tj. hodnota1), pak s druhou hodnota2, a tak dále.
• Pokud je rovnost nalezena, switch začne vykonávat kód od odpovídajícího case až do nejbližšího break (nebo do konce bloku switch).
• Není-li nalezena žádná rovnost, je vykonán kód default (pokud je uveden).

Příklad

Příklad příkazu switch (vykonaný kód je zvýraznÄ›n):

let a = 2 + 2;

switch (a) {
  case 3:
    alert( 'Příliš málo' );
    break;
  case 4:
    alert( 'Přesně!' );
    break;
  case 5:
    alert( 'Příliš mnoho' );
    break;
  default:
    alert( "Takové hodnoty neznám" );
}

Zde switch začne porovnávat a od první varianty, kterou je 3. Porovnání neuspÄ›je.

Pak 4. Tady je nalezena shoda, takže se začne vykonávat kód obsažený v case 4 a skončí na nejbližším break.

Není-li přítomen příkaz break, spustí se kód v dalších case bez jakéhokoliv porovnání.

Příklad bez break:

let a = 2 + 2;

switch (a) {
  case 3:
    alert( 'Příliš málo' );
  case 4:
    alert( 'Přesně!' );
  case 5:
    alert( 'Příliš mnoho' );
  default:
    alert( "Takové hodnoty neznám" );
}

V uvedeném příkladu vidíme sekvenční vykonání tří alertů:

alert( 'Přesně!' );
alert( 'Příliš mnoho' );
alert( "Takové hodnoty neznám" );

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

switch (+a) {
  case b + 1:
    alert("toto se vykoná, protože +a je 1, což se rovná b+1");
    break;

  default:
    alert("toto se nevykoná");
}

Seskupování „case“

Je možné seskupit nÄ›kolik case variant, které mají mít stejný kód.

Například když chceme, aby se stejný kód spustil pro case 3 a case 5:

let a = 3;

switch (a) {
  case 4:
    alert('Správně!');
    break;

  case 3: // (*) dvě seskupené varianty
  case 5:
    alert('Å patnÄ›!');
    alert("Proč nenavštěvujete kurz matematiky?");
    break;

  default:
    alert('Tento výsledek je divný. Opravdu.');
}

Nyní 3 a 5 zobrazí stejnou zprávu.

Schopnost „seskupovat“ varianty je vedlejší efekt toho, jak switch/case funguje bez break. Zde provádÄ›ní case 3 začne od řádku (*) a projde pÅ™es case 5, protože tam není žádný break.

Na datovém typu záleží

Zdůrazňujeme, že ověření rovnosti je vždy striktní. Aby se hodnoty rovnaly, musí být stejného typu.

Jako příklad poslouží tento kód:

let arg = prompt("Zadejte hodnotu");
switch (arg) {
  case '0':
  case '1':
    alert( 'Jedna nebo nula' );
    break;

  case '2':
    alert( 'DvÄ›' );
    break;

  case 3:
    alert( 'Toto se nikdy nevykoná!' );
    break;
  default:
    alert( 'Neznámá hodnota' );
}

1. Pro 0 a 1 se spustí první alert.
2. Pro 2 se spustí druhý alert.
3. AvÅ¡ak pro 3 je výsledkem příkazu prompt Å™etÄ›zec "3", který není striktnÄ› roven === číslu 3. Proto jsme pro case 3 získali mrtvý kód! Spustí se varianta default.