Une instruction switch peut remplacer plusieurs vérifications if .
Il donne une manière plus descriptive de comparer une valeur avec plusieurs variantes.
Le switch comporte un ou plusieurs blocs case et une valeur par défaut facultative.
Cela ressemble à ceci :
commutateur(x) {
cas 'valeur1' : // si (x === 'valeur1')
...
[casser]
cas 'valeur2' : // si (x === 'valeur2')
...
[casser]
défaut:
...
[casser]
} La valeur de x est vérifiée pour une stricte égalité avec la valeur du premier case (c'est-à-dire value1 ) puis jusqu'au second ( value2 ) et ainsi de suite.
Si l'égalité est trouvée, switch commence à exécuter le code en commençant par le case correspondant, jusqu'à la break la plus proche (ou jusqu'à la fin de switch ).
Si aucun cas ne correspond, le code default est exécuté (s'il existe).
Un exemple de switch (le code exécuté est mis en évidence) :
soit a = 2 + 2 ;
interrupteur (a) {
cas 3 :
alert( 'Trop petit' );
casser;
cas 4 :
alert( 'Exactement !' );
casser;
cas 5 :
alert( 'Trop gros' );
casser;
défaut:
alert( "Je ne connais pas ces valeurs" );
} Ici, le switch commence à comparer a à partir de la première variante case qui est 3 . Le match échoue.
Puis 4 . C'est une correspondance, donc l'exécution commence à partir case 4 jusqu'au break le plus proche.
S'il n'y a pas d' break , l'exécution continue avec le case suivant sans aucun contrôle.
Un exemple sans break :
soit a = 2 + 2 ;
interrupteur (a) {
cas 3 :
alert( 'Trop petit' );
cas 4 :
alert( 'Exactement !' );
cas 5 :
alert( 'Trop gros' );
défaut:
alert( "Je ne connais pas ces valeurs" );
} Dans l'exemple ci-dessus, nous verrons l'exécution séquentielle de trois alert :
alert( 'Exactement !' ); alert( 'Trop gros' ); alert( "Je ne connais pas ces valeurs" );
N'importe quelle expression peut être un argument switch/case
switch et case autorisent des expressions arbitraires.
Par exemple:
soit a = "1" ;
soit b = 0 ;
commutateur (+a) {
cas b + 1 :
alert("cela fonctionne, car +a vaut 1, est exactement égal à b+1");
casser;
défaut:
alert("cela ne fonctionne pas");
} Ici +a donne 1 , c'est comparé à b + 1 dans case , et le code correspondant est exécuté.
Plusieurs variantes de case partageant le même code peuvent être regroupées.
Par exemple, si nous voulons que le même code s'exécute pour case 3 et case 5 :
soit a = 3 ;
interrupteur (a) {
cas 4 :
alert('Bien !');
casser;
cas 3 : // (*) regroupé deux cas
cas 5 :
alert('Faux !');
alert("Pourquoi ne prends-tu pas un cours de mathématiques ?");
casser;
défaut:
alert('Le résultat est étrange. Vraiment.');
} Maintenant, 3 et 5 affichent le même message.
La possibilité de « regrouper » les cas est un effet secondaire du fonctionnement sans break switch/case . Ici, l'exécution du case 3 commence à partir de la ligne (*) et passe par case 5 , car il n'y a pas break .
Soulignons que le contrôle d'égalité est toujours strict. Les valeurs doivent être du même type pour correspondre.
Par exemple, considérons le code :
let arg = prompt("Entrer une valeur ?");
changer (argument) {
cas '0' :
cas '1' :
alert( 'Un ou zéro' );
casser;
cas '2' :
alert( 'Deux' );
casser;
cas 3 :
alert( 'Ne s'exécute jamais !' );
casser;
défaut:
alert( 'Une valeur inconnue' );
} Pour 0 , 1 , la première alert s'exécute.
Pour 2 la deuxième alert fonctionne.
Mais pour 3 , le résultat de l' prompt est une chaîne "3" , qui n'est pas strictement égale === au nombre 3 . Nous avons donc un code mort dans case 3 ! La variante default s'exécutera.
importance : 5
Écrivez le code en utilisant if..else qui correspondrait au switch suivant :
changer (navigateur) {
cas 'Bord' :
alert( "Vous avez l'avantage !" );
casser;
cas 'Chrome' :
cas 'Firefox' :
cas 'Safari' :
cas 'Opéra' :
alert( 'D'accord, nous prenons également en charge ces navigateurs' );
casser;
défaut:
alert( 'Nous espérons que cette page semble correcte !' );
}
Pour correspondre précisément à la fonctionnalité de switch , le if doit utiliser une comparaison stricte '===' .
Cependant, pour des chaînes données, un simple '==' fonctionne également.
if(navigateur == 'Bord') {
alert("Vous avez l'avantage !");
} sinon si (navigateur == 'Chrome'
|| navigateur == 'Firefox'
|| navigateur == 'Safari'
|| navigateur == 'Opera') {
alert( 'D'accord, nous prenons également en charge ces navigateurs' );
} autre {
alert( 'Nous espérons que cette page semble correcte !' );
} Attention : le browser == 'Chrome' || browser == 'Firefox' … est divisé en plusieurs lignes pour une meilleure lisibilité.
Mais la construction switch est toujours plus propre et plus descriptive.
importance : 4
Réécrivez le code ci-dessous en utilisant une seule instruction switch :
let a = +prompt('a?', '');
si (une == 0) {
alerte( 0 );
}
si (une == 1) {
alerte( 1 );
}
si (une == 2 || une == 3) {
alerte( '2,3' );
}
Les deux premiers contrôles se transforment en deux case . Le troisième contrôle se décompose en deux cas :
let a = +prompt('a?', '');
interrupteur (a) {
cas 0 :
alerte( 0 );
casser;
cas 1 :
alerte( 1 );
casser;
cas 2 :
cas 3 :
alerte( '2,3' );
casser;
} Attention : la break en bas n'est pas obligatoire. Mais nous l'avons mis en place pour rendre le code évolutif.
À l'avenir, il est possible que nous souhaitions ajouter un case supplémentaire, par exemple case 4 . Et si on oublie d'ajouter un break avant, à la fin du case 3 , il y aura une erreur. C'est donc une sorte d'auto-assurance.