L’istruzione switch può essere utile per rimpiazzare multipli if.
E’ infatti un metodo molto più descrittivo per lavorare con un elemento che può avere svariati valori.
La sintassi
Un istruzione switch possiede uno o più case ed opzionalmente un blocco default.
Un esempio:
switch(x) {
case 'value1': // if (x === 'value1')
...
[break]
case 'value2': // if (x === 'value2')
...
[break]
default:
...
[break]
}
- Il valore di
xviene controllato utilizzando l’uguaglianza stretta con i valori dei blocchicase(value1evalue2nell’esempio sopra). - Se l’uguaglianza viene trovata,
switchinizia ad eseguire il codice partendo dal corrispondente bloccocase, fino albreakpiù vicino (oppure fino alla fine delloswitch). - Se non viene trovata nessuna uguaglianza allora viene eseguito il codice del blocco
default(se presente).
Un esempio
Un esempio di switch:
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" );
}
Qui lo switch inizia confrontando a con il primo case, il cui valore è 3. Non vi è corrispondenza.
Poi valuta 4. C’è una corrispondenza, quindi l’esecuzione inizia da case 4 fino al break più vicino.
Se non c’è nessun break l’esecuzione procede al prossimo case.
Un esempio senza 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" );
}
Nell’esempio sopra, non essendoci un break, abbiamo l’esecuzione sequenziale dei tre alert:
alert( 'Exactly!' );
alert( 'Too big' );
alert( "I don't know such values" );
switch/case.Sia switch che case accettano espressioni arbitrarie.
Ad esempio:
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");
}
Qui `+a` viene convertito in `1`, che nei `case` viene confrontato con `b + 1`, ed il codice corrispondente viene eseguito.
Raggruppare i “case”
Possiamo raggruppare diverse varianti di case e far loro eseguire lo stesso codice.
Ad esempio, se vogliamo eseguire lo stesso codice per case 3 e case 5:
let a = 3;
switch (a) {
case 4:
alert('Right!');
break;
case 3: // (*) raggruppiamo due casi
case 5:
alert('Wrong!');
alert("Why don't you take a math class?");
break;
default:
alert('The result is strange. Really.');
}
Ora sia 3 che 5 mostreranno lo stesso messaggio.
L’abilità di “raggruppare” più case è un effetto collaterale di come switch/case funziona senza break. Qui l’esecuzione del case 3 inizia dalla linea (*) e prosegue fino a case 5, perché non c’è alcun break.
Il tipo conta
Mettiamo in risalto che il confronto di uguaglianza è sempre stretto. I valori devono essere dello stesso tipo perché si possa avere una corrispondenza.
Ad esempio, consideriamo il codice:
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' );
}
- Per
0e1, viene eseguito il primoalert. - Per
2viene eseguito il secondoalert. - Per
3, il risultato delpromptè una stringa,"3", che non è strettamente uguale===al numero3. Quindi abbiamo del codice ‘morto’ nelcase 3! Verrà quindi eseguito il codice dentrodefault.
Commenti
<code>, per molte righe – includile nel tag<pre>, per più di 10 righe – utilizza una sandbox (plnkr, jsbin, codepen…)