En JavaScript, puede usar objetos en lugar de declaraciones de cambio de caso para lograr el mismo resultado.

Ejemplo sencillo:

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');
}

En este ejemplo, creamos un objeto llamado actionsque contiene claves para cada posible acción y valores que son funciones que realizan la acción asociada.

Luego usamos el inoperador para verificar si lo dado actiones una clave en el actionsobjeto. Si es así, llamamos a la función correspondiente usando actions[action]().

Si no es una clave en el actionsobjeto, podemos manejar el caso de acción no válida de manera apropiada.

Ejemplo de una calculadora:

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}`);
}

En este ejemplo, creamos un objeto llamado calculatorque contiene claves para cada operador posible (+, -, *, /) y valores que son funciones que realizan el cálculo asociado.

Luego usamos el inoperador para verificar si lo dado operatores una clave en el calculatorobjeto. Si es así, llamamos a la función correspondiente usando calculator[operator](num1, num2)para obtener el resultado.

Si no es una clave en el calculatorobjeto, podemos manejar el caso del operador inválido apropiadamente.

Este enfoque hace que el código sea más escalable, ya que es fácil agregar nuevos operadores a la calculadora simplemente agregando un nuevo par clave-valor al calculatorobjeto. También hace que el código sea más legible y mantenible.

Conclusión

Este enfoque es útil cuando tiene que manejar una gran cantidad de casos, ya que puede hacer que el código sea más legible y fácil de mantener.

Además, los objetos son más fáciles de extender y modificar que las declaraciones de cambio de caso.

¡Comparte el artículo si aprendiste algo bueno!