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â¦)