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
. default
- Una clausola
default
è facoltativa e, se specificata, la clausola viene eseguita se il valore dell'espressione
non corrisponde a nessuna clausolacase
.
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 switch
, 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 programma 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 partirà dalla clausola il cui criterio è verificato, e proseguirà con la clausola successiva anche se il criterio 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');
}
Posso mettere un default in mezzo?
Certo che puoi! JavaScript passerà al default se non troverà nessun criterio corrispondente:
var foo = 5;
switch (foo) {
case 2:
console.log(2);
break; // incontra un break, quindi non procederà automaticamente su "default:"
default:
console.log('default')
// non c'è un break, quindi verrà eseguito anche il contenuto di "case 1:"!
case 1:
console.log('1');
}
Funziona anche se metti default prima di ogni altra clausola.
Riscrivere molteplici istruzioni If con Switch
Di seguito viene fornito un esempio:
var a = 100;
var b = NaN;
switch (true) {
case isNaN(a) || isNaN(b):
console.log('NaNNaN');
break;
case a === b:
console.log(0);
break;
case a < b:
console.log(-1);
break;
default:
console.log(1);
}
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 comando di case
ingnorando se verifica il criterio 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 realizzano 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:
Valore | Testo di log |
---|---|
foo è diverso da 1, 2, 3, 4, 5 or 10 | Per favore prendere un numero da 1 a 5 o 10! |
10 | Output: quindi quale è il tuo nome? |
1 | Output: quale è il tuo nome? |
2 | Output: il tuo nome? |
3 | Output: nome? |
4 | Output: ? |
5 | Output: ! |
Specifiche
Specifiche | Status | Commento |
---|---|---|
ECMAScript 3rd Edition (ECMA-262) | Standard | Definizione iniziale. Relaizzata in JavaScript 1.2 |
ECMAScript 5.1 (ECMA-262) The definition of 'switch statement' in that specification. |
Standard | |
ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'switch statement' in that specification. |
Standard | |
ECMAScript (ECMA-262) The definition of 'switch statement' in that specification. |
Living Standard |
Compatibilità dei browser
Feature | Chrome | Firefox (Gecko) | Internet Explorer | Opera | Safari |
---|---|---|---|---|---|
Basic support | (Yes) | (Yes) | (Yes) | (Yes) | (Yes) |
Feature | Android | Chrome for Android | Firefox Mobile (Gecko) | IE Mobile | Opera Mobile | Safari Mobile |
---|---|---|---|---|---|---|
Basic support | (Yes) | (Yes) | (Yes) | (Yes) | (Yes) | (Yes) |