Changer de cas dans JavaScript

Il y a deux principales déclarations conditionnelles dans le langage de programmation JavaScript, une connue sous le nom de déclarations de cas de commutateur. Les instructions de cas de commutation sont assez faciles à comprendre, car leur travail est assez simple.

Le changer vérifie une expression et compare ensuite la valeur de cette expression avec les cas définis en dessous. Si la valeur des expressions correspond à la valeur définie dans tout cas instructions, puis le bloc respectif est exécuté. Sinon, le corps du clause par défaut est exécuté.

Structure des instructions de cas de commutateur

Pour mieux comprendre cela, jetez un œil à la structure des instructions de cas de commutateur:

commutateur (expression / condition)
Cas A:
// code à exécuter si la valeur est un
casser;
Cas B:
// code à exécuter si la valeur est b
casser;
défaut:
// code à exécuter si la valeur ne correspond à aucun cas

Il y a quelques choses à considérer de cette structure, ce sont:

• La condition ou les expressions est transmise à l'intérieur de l'argument de l'instruction Switch.
• Il peut y avoir un nombre infini d'instructions de cas pour chaque cas de commutateur.
• Les déclarations de cas se terminent par un côlon «:».
• Chaque cas doit inclure une déclaration de pause à la fin de l'affaire.
• Après les instructions de cas, il doit y avoir une clause par défaut qui sera exécutée si aucun cas ne correspond à la valeur de l'expression.

Il serait préférable de simplement démontrer le fonctionnement de la déclaration de cas à l'aide d'un exemple.

Exemple 1: calculatrice en semaine à l'aide des instructions de cas de commutateur

L'objectif de cet exemple va prendre une valeur entière, et en fonction de cette valeur entière, nous allons afficher un jour de la semaine avec les critères suivants:

1 = lundi, 2 = mardi, 3 = mercredi, etc.

Commencez par créer la valeur entière et définissez-le égal à 6 avec la ligne suivante:

NumericValue = 6;

Après cela, appliquez l'interrupteur sur le valeur numérique ainsi:

commutateur (NumericValue)
// Les déclarations de cas vont ici

Dans les supports bouclés de cet interrupteur, définissez simplement sept cas différents pendant sept jours différents de la semaine à l'aide des lignes suivantes:

cas 1:
console.Log ("Le jour est le lundi");
casser;
Cas 2:
console.Log ("Le jour est mardi");
casser;
Cas 3:
console.Log ("Le jour est mercredi");
casser;
Cas 4:
console.Log ("Le jour est jeudi");
casser;
Cas 5:
console.Log ("Le jour est vendredi");
casser;
Cas 6:
console.Log ("Le jour est samedi");
casser;
Cas 7:
console.Log ("Le jour est le dimanche");
casser;

À la fin, ajoutez une clause par défaut pour gérer les entrées non valides avec les lignes suivantes:

défaut:
console.log ("entrée non valide");

L'extrait de code complet est comme:

NumericValue = 6;
commutateur (NumericValue)
cas 1:
console.Log ("Le jour est le lundi");
casser;
Cas 2:
console.Log ("Le jour est mardi");
casser;
Cas 3:
console.Log ("Le jour est mercredi");
casser;
Cas 4:
console.Log ("Le jour est jeudi");
casser;
Cas 5:
console.Log ("Le jour est vendredi");
casser;
Cas 6:
console.Log ("Le jour est samedi");
casser;
Cas 7:
console.Log ("Le jour est le dimanche");
casser;
défaut:
console.log ("entrée non valide");

Lors de l'exécution de l'extrait de code ci-dessus, le résultat suivant est affiché sur le terminal:

Il ressort clairement de la sortie que le programme fonctionne parfaitement et décide correctement le jour de la semaine à partir de la valeur entière.

Exemple 2: Essayer la clause par défaut avec une expression non correspondante

Pour démontrer le fonctionnement de la clause par défaut, prenez simplement l'extrait de code de l'exemple 1, et dans cet exemple, modifiez simplement la valeur de valeur numérique à une valeur de chaîne comme:

NumericValue = "Google";

Maintenant, cela peut être considéré comme une contribution non valide à notre programme. L'exécution du code avec cette valeur entraînerait la sortie suivante:

De cette sortie, il est facile de conclure que le clause par défaut est exécuté quand aucun des cas ne correspond à l'expression.

Conclure

Le Casse de commutation Les déclarations implémentent la vérification conditionnelle sur une expression spécifique. Toutes les valeurs possibles pour lesquelles l'utilisateur souhaitent avoir une sortie sont placées dans le cas Les déclarations, et le bloc de code à exécuter sur cette correspondance particulière sont également placés à l'intérieur de cette instruction. Les valeurs possibles restantes qui ne nécessitent pas de sortie ou de traitement sont placées dans le défaut clause. La clause par défaut n'est exécutée que lorsque aucune des valeurs définies dans les instructions de cas ne correspond à la valeur des expressions. Il est important de noter que chaque cas se termine sur un Colon (:), Et à la fin du corps, il doit contenir un casser déclaration.