Switch case

Este artículo o sección necesita referencias que aparezcan en una publicación acreditada.
Busca fuentes: «Switch case» – noticias · libros · académico · imágenes
Este aviso fue puesto el 25 de septiembre de 2018.

En los lenguajes de programación, un switch case o switch statement, declaración de cambiador o declaración de interruptor, es un tipo de mecanismo de control de selección utilizado para permitir que el valor de una variable o expresión cambie el flujo de control de la ejecución del programa mediante búsqueda y mapa.

Las declaraciones de interruptor funcionan de manera similar a la declaración if en lenguajes de programación como C/C++, C#, Visual Basic .NET o Java, y existe en la mayoría de los lenguajes de programación imperativos de alto nivel como Pascal, Ada, así como los previamente indicados.

Las declaraciones de cambio vienen en dos variantes principales: un cambio estructurado, como en Pascal, que toma exactamente una rama, y un cambio no estructurado, como en C, que funciona como un tipo de goto. Las principales razones para usar un interruptor incluyen mejorar la claridad, reduciendo la codificación repetitiva de múltiples if y (si la heurística lo permite) también ofrecer potencial para una ejecución más rápida, a través de una optimización del compilador más fácil en muchos casos.

Sintaxis

switch( variable ){
  case valor1: accion1; (*)
  case valor2: accion2; (*+++)
  case valor3: accion3; (*)
  ...
  case valorN: accionN; (*)

  default: accionD; (**)
}
  • (**) La acción default es usada para los valores que no correspondieron en casos anteriores, y puede aparecer sin "accionD()", e incluso, con el break al final.
  • (*) En estos huecos, al final de las acciones acción1, acción2,... incluso después de la accionD, normalmente se suele usar un break para salir del switch. Su uso, generalizado, permite realizar programas que, por ejemplo, se comportan de diferente modo por cada entrada:
Switch( número )
{
  case 0: escribir("No hay elementos.");
  break;
  case 1: escribir("Hay solo un elemento.");
  break;
  default: escribir("Hay " número " elementos"); /* break; */
}

En este ejemplo,es necesario utilizar la palabra reservada break, excepto en el último (que está entre comentarios y por lo tanto no se ejecutará) para el correcto funcionamiento del programa. Esto lo que hace es, dependiendo si el número que contiene la variable número es 0, 1 u otro cualquiera, escribir que No hay elementos, Hay solo un elemento o Hay numero elementos respectivamente.

En cambio, el uso del switch puede ser interesante sin recurrir a los break al final de las acciones, por ejemplo, en este otro programa: 

Switch( paso )
{
  case 1: escribir("Paso 1 (ponerse cómodo) sin finalizar. ");
  case 2: escribir("Paso 2 (regular espejos) sin finalizar. ");
  case 3: escribir("Paso 3 (abrochar cinturón) sin finalizar. ");
  case 4: escribir("Paso 4 (arrancar motor) sin finalizar. ");
}

Este otro programa muestra por pantalla los pasos que aun faltan por realizar de una tarea pre-programada. Por ejemplo, si estamos en el paso 1, todavía nos quedará terminar ese, el 2, el 3 y el 4, por lo que mostrará desde el 1 en adelante. Pero si estamos en el paso 3, solo mostrará que falta el Paso 3 y el Paso 4.

Por supuesto, el uso de los break se puede usar en diferentes acciones, sin ser en todas o en ninguna, por ejemplo, añadiendo un paso final al anterior programa: 

Switch( paso ){
  case 1: escribir("Paso 1 (ponerse cómodo) sin finalizar. ");
  case 2: escribir("Paso 2 (regular espejos) sin finalizar. ");
  case 3: escribir("Paso 3 (abrochar cinturón) sin finalizar. ");
  case 4: escribir("Paso 4 (arrancar motor) sin finalizar. ");
  break;
  case 5: escribir("Tarea finalizada.");
}

De esta forma, el funcionamiento será igual que el anterior, salvo que si el paso es el 5, es decir, que todas los pasos anteriores están finalizados, nos mostrará que "Tarea finalizada."; en cambio, si el paso es anterior al 5, al mostrar el mensaje "(...) Paso 4 (arrancar motor) sin finalizar." realizará el break y no mostrará, lógicamente, el mensaje del Paso 5, que no tendría sentido.

Funcionamiento

El programa interpreta el valor de la variable almacenándolo en una zona de memoria temporal (oculta). Después lo compara con el valor seguido de cada case, y si coincide, realiza el flujo de acciones correspondientes, hasta encontrar un break, con el que finalizará el Switch. Es muy importante saber que, en el momento en el que se realiza la accionI (para I < N), se ejecutarán todas las acciones entre I y N mientas no se encuentre la instrucción break.

Similitud con if

Con la nomenclatura anterior, el Switch se puede asemejar a este otro algoritmo basado en if y for: 

for( temporal = variable; true; break){
  if( temporal == valor1 ) {accion1;}
  if( temporal == valor1 or temporal == valor2 ) {accion2;}
  if( cordero == temporal )
  temporal++;
  if( temporal == valor1 or temporal == valor2 or... or temporal == valorN ) {accionN;}
  accionD;
}

En este caso, ocurre absolutamente lo mismo que en el Switch de más arriba: todas las acciones siguientes se realizarán después de la primera que se ejecute mientras no se llegue al final del for (llegando al último break), o se encuentre algún break antes del último.

Ventajas sobre if

Aunque en el último ejemplo se puede ver una clara ventaja sobre el condicional, es comúnmente usado el switch para cubrir situaciones en las que la condición incluye muchas comparaciones concatenadas con ors sobre una misma variable, es decir, variable == valor1 or variable == valor2 or... or variable == valorN; en los que se repiten mucho la cadena variable ==: 

if( variable == valor1 or variable == valor2 ){
  accion12;
 }else if( variable == valor3 or variable == valor4 ){
  accion34;
 }else{
  accionD;
}

Pasaría a ser, usando la estructura Switch case: 

switch( variable ){
  case valor1:
  case valor2:
   accion12;
   break;

  case valor3:
  case valor4:
   accion34;
   break;

  default:
   accionD;
}

También sirve, al aplicar Álgebra de Boole, para concatenaciones de ands sobre una misma variable para acciones de exclusión. Esto evita usar de forma iterativa en nuestros códigos la cadena variable == y los operadores lógicos and: 

if( variable != valor1 and variable != valor2 ){
  accionD;
}

/* ''Similar'' a: */

if( variable == valor1 or variable == valor2 ){
}else{
  acción;
}

/* ''Usando Case seria'': */

switch( variable ){
  case valor1:
  case valor2:
   break;
  default:
   accion;
}

Enlaces externos