Una declaración switch
puede reemplazar múltiples comprobaciones if
.
Proporciona una forma más descriptiva de comparar un valor con múltiples variantes.
El switch
tiene uno o más bloques case
y un valor predeterminado opcional.
Se parece a esto:
cambiar(x) { caso 'valor1': // si (x === 'valor1') ... [romper] caso 'valor2': // si (x === 'valor2') ... [romper] por defecto: ... [romper] }
Se verifica que el valor de x
tenga una igualdad estricta con el valor del primer case
(es decir, value1
), luego con el segundo ( value2
) y así sucesivamente.
Si se encuentra la igualdad, switch
comienza a ejecutar el código a partir del case
correspondiente, hasta la break
más cercana (o hasta el final de switch
).
Si no coincide ningún caso, se ejecuta el código default
(si existe).
Un ejemplo de switch
(el código ejecutado está resaltado):
sea a = 2 + 2; cambiar (a) { caso 3: alerta('Demasiado pequeño'); romper; caso 4: alerta ('¡Exactamente!'); romper; caso 5: alerta('Demasiado grande'); romper; por defecto: alert("No conozco esos valores"); }
Aquí el switch
comienza a comparar a
partir de la variante del primer case
, que es 3
. El partido falla.
Entonces 4
. Esa es una coincidencia, por lo que la ejecución comienza desde case 4
hasta la break
más cercana.
Si no hay break
, la ejecución continúa con el siguiente case
sin ningún control.
Un ejemplo sin break
:
sea a = 2 + 2; cambiar (a) { caso 3: alerta('Demasiado pequeño'); caso 4: alerta ('¡Exactamente!'); caso 5: alerta('Demasiado grande'); por defecto: alert("No conozco esos valores"); }
En el ejemplo anterior veremos la ejecución secuencial de tres alert
:
alerta ('¡Exactamente!'); alerta('Demasiado grande'); alert("No conozco esos valores");
Cualquier expresión puede ser un argumento switch/case
Tanto switch
como case
permiten expresiones arbitrarias.
Por ejemplo:
sea a = "1"; sea b = 0; cambiar (+a) { caso b + 1: alert("esto se ejecuta, porque +a es 1, exactamente igual a b+1"); romper; por defecto: alerta("esto no se ejecuta"); }
Aquí +a
da 1
, que se compara con b + 1
en case
y se ejecuta el código correspondiente.
Se pueden agrupar varias variantes de case
que comparten el mismo código.
Por ejemplo, si queremos que se ejecute el mismo código para case 3
y case 5
:
sea a = 3; cambiar (a) { caso 4: alerta('¡Correcto!'); romper; caso 3: // (*) agrupados dos casos caso 5: alerta('¡Incorrecto!'); alert("¿Por qué no tomas una clase de matemáticas?"); romper; por defecto: alert('El resultado es extraño. De verdad.'); }
Ahora tanto 3
como 5
muestran el mismo mensaje.
La capacidad de "agrupar" cajas es un efecto secundario de cómo funciona switch/case
sin break
. Aquí la ejecución del case 3
comienza desde la línea (*)
y pasa por case 5
, porque no hay break
.
Destaquemos que el control de igualdad es siempre estricto. Los valores deben ser del mismo tipo para que coincidan.
Por ejemplo, consideremos el código:
let arg = Prompt("¿Ingrese un valor?"); cambiar (arg) { caso '0': caso '1': alerta('Uno o cero'); romper; caso '2': alerta('Dos'); romper; caso 3: alert('¡Nunca se ejecuta!'); romper; por defecto: alert('Un valor desconocido'); }
Para 0
, 1
, se ejecuta la primera alert
.
Para 2
se ejecuta la segunda alert
.
Pero para 3
, el resultado del prompt
es una cadena "3"
, que no es estrictamente igual ===
al número 3
. ¡Entonces tenemos un código inactivo en case 3
! Se ejecutará la variante default
.
importancia: 5
Escriba el código usando if..else
que correspondería al siguiente switch
:
cambiar (navegador) { caso 'Borde': alerta ("¡Tienes la ventaja!"); romper; caso 'Cromo': caso 'Firefox': caso 'Safari': caso 'Ópera': alert('Está bien, también admitimos estos navegadores'); romper; por defecto: alert('¡Esperamos que esta página se vea bien!'); }
Para coincidir con precisión con la funcionalidad de switch
, if
debe usar una comparación estricta '==='
.
Sin embargo, para cadenas dadas, un simple '=='
también funciona.
if(navegador == 'Borde') { alert("¡Tienes la ventaja!"); } más si (navegador == 'Chrome' || navegador == 'Firefox' || navegador == 'Safari' || navegador == 'Ópera') { alert('Está bien, también admitimos estos navegadores'); } demás { alert('¡Esperamos que esta página se vea bien!'); }
Tenga en cuenta: el browser == 'Chrome' || browser == 'Firefox' …
está dividido en varias líneas para una mejor legibilidad.
Pero la construcción switch
es aún más limpia y descriptiva.
importancia: 4
Vuelva a escribir el código siguiente utilizando una única declaración switch
:
let a = +prompt('a?', ''); si (a == 0) { alerta (0); } si (a == 1) { alerta( 1 ); } si (a == 2 || a == 3) { alerta ('2,3'); }
Los dos primeros controles se convierten en dos case
. El tercer control se divide en dos casos:
let a = +prompt('a?', ''); cambiar (a) { caso 0: alerta (0); romper; caso 1: alerta( 1 ); romper; caso 2: caso 3: alerta ('2,3'); romper; }
Tenga en cuenta: no es necesario el break
en la parte inferior. Pero lo ponemos para que el código esté preparado para el futuro.
En el futuro, existe la posibilidad de que queramos agregar un case
más, por ejemplo case 4
. Y si nos olvidamos de agregar un descanso antes, al final del case 3
, habrá un error. Entonces eso es una especie de autoseguro.