En TypeScript, Record<K, V> es un tipo que construye un objeto con claves de tipo K y valores de tipo V. Puedes utilizar Record<> para simplificar y mejorar la legibilidad de tu código en situaciones donde podrías estar usando un switch para mapear claves a valores o funciones.

Aquí tienes un ejemplo de cómo usar Record<> en lugar de un switch:

Ejemplo 1: Mapeo de Valores

Supongamos que tienes un switch para devolver diferentes mensajes según una clave:

function getMessage(key: string): string {
  switch (key) {
    case 'hello':
      return 'Hello World!';
    case 'goodbye':
      return 'Goodbye!';
    case 'thanks':
      return 'Thank you!';
    default:
      return 'Unknown key';
  }
}

Puedes reemplazar esto con un Record<>:

const messages: Record<string, string> = {
  hello: 'Hello World!',
  goodbye: 'Goodbye!',
  thanks: 'Thank you!',
};

function getMessage(key: string): string {
  return messages[key] || 'Unknown key';
}

Ejemplo 2: Mapeo de Funciones

Si estás utilizando un switch para ejecutar diferentes funciones:

function executeAction(action: string) {
  switch (action) {
    case 'start':
      startFunction();
      break;
    case 'stop':
      stopFunction();
      break;
    case 'pause':
      pauseFunction();
      break;
    default:
      console.log('Unknown action');
  }
}

function startFunction() {
  console.log('Starting...');
}

function stopFunction() {
  console.log('Stopping...');
}

function pauseFunction() {
  console.log('Pausing...');
}

Puedes reemplazar esto con un Record<> de funciones:

type ActionFunction = () => void;

const actions: Record<string, ActionFunction> = {
  start: () => console.log('Starting...'),
  stop: () => console.log('Stopping...'),
  pause: () => console.log('Pausing...'),
};

function executeAction(action: string) {
  const actionFunction = actions[action];
  if (actionFunction) {
    actionFunction();
  } else {
    console.log('Unknown action');
  }
}

Beneficios de Usar Record<>

  • Simplificación del Código: Evita el uso de múltiples case en un switch, haciendo el código más limpio y legible.
  • Facilidad de Mantenimiento: Es más fácil añadir, eliminar o modificar las entradas en un objeto Record que en un switch.
  • Flexibilidad: Puedes utilizar cualquier tipo como clave, no solo cadenas o números.

Consideraciones

  • Claves Existentes: Asegúrate de manejar el caso en el que una clave no exista en el Record.
  • Tipado Estricto: Puedes aprovechar TypeScript para asegurar que solo se utilicen claves válidas si defines el tipo de las claves en lugar de usar string genérico.
type MessageKey = 'hello' | 'goodbye' | 'thanks';

const messages: Record<MessageKey, string> = {
  hello: 'Hello World!',
  goodbye: 'Goodbye!',
  thanks: 'Thank you!',
};

function getMessage(key: MessageKey): string {
  return messages[key];
}

De esta manera, TypeScript te ayudará a evitar errores de claves no válidas en tiempo de compilación.