En JavaScript, vous pouvez utiliser des objets au lieu d'instructions switch case pour obtenir le même résultat.

Exemple simple :

const actions = {
  'create': function() { 
    console.log('create action');
  },
  'update': function() {
    console.log('update action');
  },
  'delete': function() {
    console.log('delete action');
  },
};

const action = 'create';

if (action in actions) {
  actions[action]();
} else {
  console.log('Invalid action');
}

Dans cet exemple, nous créons un objet appelé actionsqui contient des clés pour chaque action possible et des valeurs qui sont des fonctions qui exécutent l'action associée.

Nous utilisons ensuite l' inopérateur pour vérifier si le donné actionest une clé dans l' actionsobjet. Si c'est le cas, nous appelons la fonction correspondante en utilisant actions[action]().

S'il ne s'agit pas d'une clé dans l' actionsobjet, nous pouvons gérer le cas d'action invalide de manière appropriée.

Exemple de calculatrice :

const calculator = {
  '+': function(a, b) { return a + b },
  '-': function(a, b) { return a - b },
  '*': function(a, b) { return a * b },
  '/': function(a, b) { return a / b },
};

const operator = '-';
const num1 = 10;
const num2 = 12;

if (operator in calculator) {
  const result = calculator[operator](num1, num2);
  console.log(`${num1} ${operator} ${num2} = ${result}`);
} else {
  console.log(`Invalid operator: ${operator}`);
}

Dans cet exemple, nous créons un objet appelé calculatorqui contient des clés pour chaque opérateur possible (+, -, *, /) et des valeurs qui sont des fonctions qui effectuent le calcul associé.

Nous utilisons ensuite l' inopérateur pour vérifier si le donné operatorest une clé dans l' calculatorobjet. Si c'est le cas, nous appelons la fonction correspondante en utilisant calculator[operator](num1, num2)pour obtenir le résultat.

S'il ne s'agit pas d'une clé dans l' calculatorobjet, nous pouvons gérer le cas de l'opérateur non valide de manière appropriée.

Cette approche rend le code plus évolutif, car il est facile d'ajouter de nouveaux opérateurs à la calculatrice en ajoutant simplement une nouvelle paire clé-valeur à l' calculatorobjet. Cela rend également le code plus lisible et maintenable.

Conclusion

Cette approche est utile lorsque vous avez un grand nombre de cas à gérer, car elle peut rendre le code plus lisible et maintenable.

De plus, les objets sont plus faciles à étendre et à modifier que les instructions switch case.

Partagez l'article si vous avez appris quelque chose de bien !