switch

Il comando switch valuta un espressione, confronta il valore dell'espressione con ciascuna delle clausole case,  ed esegue i comandi ( statements ) associati alla clausola (case) che verifica il confronto.

Sintassi

switch (espressione) {
  case valore1:
    //Comandi eseguiti quando il valore dell'espressione coincide con valore1
    [break;]
  case valore2:
    //Comandi eseguiti quando il valore dell'espressione coincide con valore2
    [break;]
  ...
  case valoreN:
    //Comandi eseguiti quando il valore dell'espressione coincide con valoreN
    [break;]
  default:
    //Comandi eseguiti quando nessuno dei valori coincide col valore dell'epressione
    [break;]
}

espressione

Un'espressione il cui risultato è confrontato con ogni clausola case.

case valoreN

Clausola case usata nel confronto con l' espressione.

Descrizione

Un comando switch per prima cosa valuta espressione; poi cerca la prima clausola case la cui essa ha lo stesso valore del risultato dell'espressione di switch (utilizzando la strict comparison, ===); quindi il comando switch trasferisce il controllo alla clausola case, eseguendone i comandi. Se più clausole case sono verificate dal confronto con l'espressione di switch,  viene scelta la prima che verifica il confronto, anche se le clausole non sono uguali. Se nessuna clausola case risulta verificata dal confronto,  il programma cerca la clausola facoltativa default, e se la trova, trasferisce il controllo a questa, eseguendone i comandi. Se non viene trovata alcuna clausola default, il programma continua eseguendo il comando successivo alla fine del comando switch. Convenzionalmente, ma non necessariamente, la clausola default è l'ultima clausola.

Il comando facoltativo  break associato a ciascuna etichetta case assicura che, una volta eseguiti i comandi della clausola che verifica l'espressione di switch, il programma interrompa il comando switch e che continui eseguendo il comando successivo. Se il comando break viene omesso, il programma continua l'esecuzione dal comando successivo all'interno del comando di swich, quindi dal primo della successiva clausola case.

Esempi

Utilizzo di switch

Nell'esempio seguente, se expr vale "Banane", il programma confronta il valore con la clausola "Banane" ed esegue i comandi associati. Quando incontra break , il program interrompe il comando switch ed esegue il comando successivo a switch. Se break fosse omesso, sarebbero eseguiti anche i comandi della clausola  "Ciliegie" .

switch (expr) {
  case "Arance":
    console.log("Le arance costano €1,0 al chilo.");
    break;
  case "Mele":
    console.log("Le mele costano €0.64 al chilo.");
    break;
  case "Banane":
    console.log("Le banane costano €0.92 al chilo.");
    break;
  case "Ciliege":
    console.log("Le ciliegie costano €2.59 al chilo.");
    break;
  case "Manghi":
  case "Papaye":
    console.log("I manghi e le papaye costano €1.79 al chilo.");
    break;
  default:
    console.log("Spiacenti, non abbiamo " + expr + ".");
}

console.log("Desidera qualcos'altro ?");

Cosa accade se dimentico un break?

Se vi dimenticate un break lo script dalla clausola il cui criterio è verificato, e proseguirà con la clausola successiva anche se il ctiterio non era verifcato. Ecco alcuni esempi:

var foo = 0;
switch (foo) {
  case -1:
    console.log('1 negativo');
    break;
  case 0: // foo è 0 quindi il criterio è verificato; questo blocco verrà eseguito
    console.log(0);
    // NOTA: il break dimenticato sarebbe dovuto essere qui
  case 1: // manca il comando break in 'case 0:' quindi anche questo blocco sarà eseguito
    console.log(1);
    break; // incontra questo break così con proseguirà in 'case 2:'
  case 2:
    console.log(2);
    break;
  default:
    console.log('default');
}

Metodi per i case con più criteri

I sorgenti per questa tecnica possono essere scaricati qui:

Switch statement multiple cases in JavaScript (Stack Overflow)

Multi-case - operazione singola

Questo metodo si avvale del fatto che se non c'è un break break prima di un comando di case continuerà eseguento il successivo coamndo di case ingnorando se verifica il creiterio di esecuzione. Vedi la sezione  "Cosa accade se dimentico un break?"

Questo è un  esempio di un comando di switch a singola operazione sequenziale,  dove quattro valori diversi realizano la stessa cosa.

var Animale = 'Giraffa';
switch (Animale) {
  case 'Mucca':
  case 'Giraffa':
  case 'Cane':
  case 'Maiale':
    console.log('Queso animale anndrà sull'Arca di Noè.');
    break;
  case 'Dinosauro':
  default:
    console.log('Questo animale non andrà.');
}

Multi-case - operazioni concatenate

Questo è un esempio di un comando di switch ad operazione multipla sequenziale, dove, a seconda del numero intero fornito, si ricevono diversi output. Mostra come sia possibile sfruttare l'ordine in cui sono scritte le clausole, e come non debbano essere numericamente in sequenza. In JavaScript, si possono anche inserire definizioni di stringhe nei comandi case.

var foo = 1;
var output = 'Output: ';
switch (foo) {
  case 10:
    output += 'quindi ';
  case 1:
    output += 'quale ';
    output += 'è ';
  case 2:
    output += ' il tuo ';
  case 3:
    output += 'nome';
  case 4:
    output += '?';
    console.log(output);
    break;
  case 5:
    output += '!';
    console.log(output);
    break;
  default:
    console.log('Per favore prendere un numero da 1 a 5 o 10!');
}

Output per questo esempio:

Specifiche

Compatibilità dei browser

Vedi anche

• if...else