Dominando la sentencia switch en Dart

Sentencia switch para control de flujo

La sentencia switch permite bifurcar la ejecución de un programa basándose en la evaluación de una expresión. Internamente, el motor de Dart evalúa dicha expresión y la compara mediante igualdad (==) con cada uno de los casos definidos. Esta estructura es mucho más eficiente que una cadena de if-else if cuando trabajas con múltiples valores constantes, ya que el compilador puede optimizar la búsqueda mediante tablas de salto en lugar de realizar comparaciones secuenciales. Debes usarla cuando una variable tiene un conjunto limitado de valores posibles, como en los enum, int o String. Si la implementas de forma incorrecta, como omitir el cierre de un caso que contiene lógica, el compilador te detendrá antes de que el programa se ejecute, garantizando la seguridad de tu lógica.

enum EstadoPedido { pendiente, procesando, enviado, entregado, cancelado }

void main() {
  var estado = EstadoPedido.enviado;
  var codigo = 404;

  // 1. Evaluación de estados con exhaustividad y agrupación
  switch (estado) {
    case EstadoPedido.pendiente:
      print('Estamos preparando tu pedido.');
      break;
    case EstadoPedido.procesando:
    case EstadoPedido.enviado: // Sintaxis clásica para agrupar casos
      print('Tu pedido está en camino.');
      break;
    case EstadoPedido.entregado:
    case EstadoPedido.cancelado: // Dart 3: Agrupación moderna mediante patrones
      print('El proceso del pedido ha finalizado.');
      break;
    default:
      // El linter te obligará a cubrir todos los casos si es un enum
      print('Estado desconocido.');
  }

  // 2. Uso de patrones con operadores lógicos (disponible desde Dart 3.0)
  switch (codigo) {
    case 200 || 201:
      print('Éxito: La operación se realizó correctamente.');
      break;
    case 400 || 404:
      print('Error de cliente: Recurso no encontrado o petición inválida.');
      break;
    default:
      print('Código de estado no gestionado.');
  }

  // 3. Control de flujo con etiquetas (Labels) y continue
  var comando = 'reset';
  print('\nComando recibido: $comando');

  switch (comando) {
    case 'start':
      print('Iniciando sistema...');
      break;
    case 'reset':
      print('Reiniciando...');
      continue etiquetaSalto; // Salta directamente a la etiqueta
    default:
      print('Comando desconocido.');
  }

  etiquetaSalto:
  print('Sistema listo para operar.');
}

Desglose del código

En el primer bloque, utilizamos un enum llamado EstadoPedido. Al usar switch (estado), Dart sabe exactamente cuántos valores posibles existen. Fíjate en cómo manejamos EstadoPedido.procesando y enviado: al poner uno seguido del otro sin código intermedio, estamos agrupando casos, lo que permite que ambos ejecuten la misma lógica. Sin embargo, para entregado y cancelado, hemos usado la nueva sintaxis de Dart 3 con el operador || (logical OR), que es más legible para agrupar patrones.

En el segundo ejemplo, aplicamos la potencia de los patrones de Dart 3 sobre un int. En lugar de escribir múltiples case, usamos 200 || 201 para capturar varios valores en una sola línea. Esto es fundamental para limpiar el código cuando manejas respuestas de APIs o códigos de error.

Finalmente, el uso de continue etiquetaSalto es una forma de saltar el flujo normal hacia una etiqueta definida fuera del bloque switch. Aunque es poco común en lógica de alto nivel, es una herramienta poderosa cuando necesitas romper la estructura del switch para saltar a un punto específico del control de flujo, evitando la necesidad de anidar múltiples if.

El error frecuente

Un error muy común para quienes vienen de C o Java es intentar dejar que un case “caiga” al siguiente de forma implícita (fall-through). En Dart, esto no está permitido por seguridad.

// Código que NO compila
var valor = 1;
switch (valor) {
  case 1:
    print('Es uno');
    // Error: Falta un break, return, throw o continue
  case 2:
    print('Es dos');
}

Si un case contiene código ejecutable, Dart exige que termines ese bloque con una sentencia que interrumpa el flujo (break, return, etc.). Si no lo haces, el compilador emitirá un error de “missing break” para evitar que la lógica se ejecute por accidente en el siguiente caso, un bug clásico en otros lenguajes.

N° 22