Estructura y uso del condicional Switch en programación
Resumen
¿Qué es un Switch y cómo se utiliza en programación?
El uso de la estructura de control Switch es fundamental en la programación para manejar múltiples escenarios basados en una expresión específica. Comparable a if, else if, else, Switch permite múltiples validaciones, pero con una diferencia esencial: evalúa solo si una expresión es verdadera y no múltiples condiciones.
A diferencia de los operadores comparativos en las estructuras if, Switch se utiliza exclusivamente para validar si la expresión que estamos evaluando es true. Pero, ¿cómo configuramos un Switch y qué componentes esenciales componen su estructura?
¿Cómo funciona la estructura básica de Switch?
La estructura de un Switch comienza definiendo una expresión entre paréntesis. Esta expresión es la condición a evaluar. Después, mediante la creación de múltiples casos (case), se especifica qué debe suceder si la expresión coincide con un valor determinado. Veamos cómo se configura:
let expresion ='papayas';switch(expresion){case'naranjas':console.log('Las naranjas cuestan 20 pesos el kilo.');break;case'manzanas':console.log('Las manzanas cuestan 43 pesos el kilo.');break;case'plátanos':console.log('Los plátanos cuestan 30 pesos el kilo.');break;case'mangos':case'papayas':console.log('Los mangos y las papayas cuestan 25 pesos el kilo.');break;default:console.log('Lo siento, no contamos con '+ expresion);}
¿Cuál es la importancia de 'break' y 'default' en Switch?
La instrucción break en un Switch es crucial porque evita la ejecución de casos posteriores una vez que se ha encontrado un true. En caso de que ninguna condición se cumpla, podemos definir un default para gestionar escenarios no previstos y ofrecer respuestas predefinidas.
break: Interrumpe la ejecución del Switch de manera que, una vez validado un caso, no se continúa evaluando los siguientes.
default: Se utiliza como el "else" de un Switch, proporcionando una salida cuando ninguna condición es verdadera.
¿Cuándo es ideal usar un Switch en lugar de if-else?
Switch es ideal cuando se debe evaluar una sola variable o expresión contra múltiples valores literales. A diferencia de if-else, que es más flexible para comparaciones complejas (como mayor o menor que), Switch funciona únicamente con comparación estricta (como si usáramos el triple igual ===). Por lo tanto, al elegir entre ambos, considere:
Mayor legibilidad:Switch para condiciones con muchas ramas predefinidas.
Comparaciones simples:Switch es más eficiente para igualdad exacta.
Casos especiales: Use if-else para complejidad lógica o comparaciones avanzadas.
A través del uso de Switch, los programadores pueden diseñar flujos de decisión más organizados y eficientes en situaciones donde solo se necesita verificar igualdad de valores. ¡Experimenta con él y verifica por ti mismo la agilidad que puede ofrecer a tus códigos!
La condición switch en JavaScript es una estructura de control que permite ejecutar diferentes bloques de código según el valor de una expresión.
Es especialmente útil cuando necesitas manejar múltiples casos basados en el valor de una variable, proporcionando una alternativa más limpia y legible a múltiples declaraciones if-else.
Sintaxis de switch
La sintaxis básica de switch es la siguiente:
switch(expresión) { case valor1: // Código a ejecutar si expresión === valor1 break; case valor2: // Código a ejecutar si expresión === valor2 break; case valor3: // Código a ejecutar si expresión === valor3 break; default: // Código a ejecutar si ninguna de las cases coincide}
expresión: La expresión que se evalúa y se compara con los valores de cada case.
case: Cada case contiene un valor a comparar con la expresión. Si coinciden, se ejecuta el bloque de código asociado.
break: Detiene la ejecución del switch después de ejecutar el bloque correspondiente. Sin break, el flujo continuará con el siguiente case (esto se llama "fall-through").
default: Opcional. Es el bloque que se ejecuta si ninguna de las case coincide con la expresión.
Ejemplo con break y fall-through
let numero = 2;
switch (numero) { case 1: console.log("Número es 1"); // No hay break, así que el flujo continúa case 2: console.log("Número es 2"); break; case 3: console.log("Número es 3"); break; default: console.log("Número no está en el rango 1-3");}
En este caso, si numero es 2, se imprimirá "Número es 2" y luego se detendrá porque hay un break. Si se omite el break en el case 1, la ejecución continuará hasta el siguiente case, imprimiendo "Número es 2".
Consideraciones Adicionales
Uso debreak: Es crucial usar break para evitar el "fall-through" accidental.
default: Siempre es buena práctica incluir un default para manejar casos inesperados.
Expresiones Complejas: Puedes usar expresiones complejas, pero ten en cuenta que pueden afectar la legibilidad.
casi no son entendibles los códigos porque no tienen saltos de línea ni tabulación
Excelente resumen!
Espero que mis conocimientos en este tema de switch, case y break se vean bien aplicados en este ejercicio que hice:
Que tal queda la búsqueda?
No soy fan de Switch, yo prefiero usar Object Literal Pattern:
const switchObject ={valor1:()=>{// código a ejecutar para valor1},valor2:()=>{// código a ejecutar para valor2},valor3:()=>{// código a ejecutar para valor3},default:()=>{// código por defecto}};functionejecutar(expresion){return(switchObject[expresion]|| switchObject.default)();}// Usoejecutar('valor1');
Las comillas invertidas (`) se utilizan en JavaScript para definir template literals, que permiten interpolar variables dentro de cadenas de texto de una manera más práctica y legible. En lugar de concatenar cadenas usando el operador +, puedes insertar expresiones directamente dentro de la cadena, utilizando ${expresion}. Esto facilita la construcción de cadenas que requieren variables o expresiones y mejora la legibilidad del código.
Ejemplo:
let nombre ="Juan";console.log(`Hola, ${nombre}!`);// Salida: Hola, Juan!
haber, sí, es posible poner estructuras condicionales en un switch, siempre y cuando la "key" de swith sea true
let fruta ="manzana";let frutados ="pera";let cantidad =5;//La clave de switch debe ser true para poder agregar estrucutras condicionalesswitch(true){case(fruta === frutados):console.log('No son iguales');break;case(fruta ==="naranja"):console.log("Es una naranja.");break;default:console.log("Fruta no reconocida.");}
inge por favor aclare esa parte como sea esa parte final del video.
se referia al switch, no hay al case creo
Bien, me gustó tu experimento.
a buscar en youtube lo que quizo explicar este cuate
Real se le entiende muy poco
MIS APUNTES 🚀 🚀**:**
Muy bien explicado, aqui mi codigo
Este fue el ejercicio que yo hice, espero les sirva de algo :)
Les recomiendo probar el switch pero quitando los breaks para que se familiaricen más con su comportamiento:
let expression ='Papayas';switch(expression){case'Naranjas':console.log('Las naranjas cuestan $20/kg');break;case'Manzanas':console.log('Las manzanas cuestan $43/kg');break;case'Platanos':console.log('El plátano está en $30/kg');break;case'Mangos':case'Papayas':console.log('Los mangos y Papayas cuestan $23/kg');// break; quiten este break y a ver qué pasadefault:console.log(`Lo siento, no contamos con ${expression}`);}console.log('¿Hay algo más que desees?');
ME CONFUNDESSSSSSSS
devuelvan a la otra profesora por favor 😒
LINK para meter solo el codigo en javascript y que el navegador lo lea:
De nada
Efectivamente, la estructura if-else en JavaScript permite realizar comparaciones más flexibles, utilizando operadores como >, <, ==, ===, || (OR) y && (AND). Esto permite evaluar condiciones complejas. En contraste, switch se limita a evaluar la igualdad exacta (comparación estricta) de una expresión con múltiples casos, sin la posibilidad de usar operadores de comparación. Utiliza switch principalmente para situaciones donde tienes múltiples valores discretos a evaluar, mientras que if-else es preferible para condiciones más complejas.
Ejercicio de la clase utilizando prompt para introducir la fruta que deseemos:
let expr =prompt("Ingresa la fruta que desee: ")switch(expr){case"Naranjas":console.log("Las naranjas cuestan $20 el kilo")break;case"Manzanas":console.log("Las manzanas cuestan $43 el kilo")break;case"Plátanos":console.log("El plátano cuesta $30 el kilo")break;case"Mangos":case"Papayas":console.log("Los mangos y las papayas cuestan $25 el kilo")break;default:console.log(`Lo siento no contamos con ${expr}`)}console.log("Hay algo más que desees?");
Estructura de switch
switch(expresion){casevalor1://código a ejecutarbreak;casevalor1://código a ejecutarbreak;casevalor2://código a ejecutarbreak;casevalor3://código a ejecutarbreak;casevalor4://código a ejecutarbreak;default:// código}
functionfilterListShop(){const search =prompt("Ingresa lo que deseas buscar en la lista ").toLowerCase();switch(search){case"tomates":console.log("Comprar 5 tomates");break;case"cebolla":console.log("Comprar 2 cebollas");break;case"papel":console.log("Comprar papel");break;default:console.log(`No hace falta comprar ${search}`);break;}}filterListShop();
Algo que considero que les hizo falta explicar desde clases pasadas a los usuarios que son nuevos fue la diferencia principal entre una const y un let que son variables distintas, una porque su valor siempre va a ser el mismo const que no cambia y let que es una variable que si cambia su valor.
switch (expression) {
case 'Naranjas':
console.log('Las naranjas cuestan $20/kg');
break;
case 'Manzanas':
console.log('Las manzanas cuestan $43/kg');
break;
case 'Platanos':
console.log('El plátano está en $30/kg');
break;
case 'Mangos':
case 'Papayas':
console.log('Los mangos y Papayas cuestan $23/kg');
// break; quiten este break y a ver qué pasa
default:
console.log(Lo siento, no contamos con ${expression});
}
console.log('¿Hay algo más que desees?');
El condicional switch en programación es una estructura de control que evalúa una variable contra múltiples casos (case) posibles, ejecutando el bloque de código coincidente. Funciona como alternativa eficiente a los if-else anidados, mejorando la legibilidad para menús de opciones o valores específicos.
Hice este ejemplo
El switch es una estructura de control en JavaScript que permite evaluar una expresión y ejecutar diferentes bloques de código según el valor de esa expresión.
La sintaxis básica es:
switch(expresión){casevalor1:// Código a ejecutar si expresión === valor1break;casevalor2:// Código a ejecutar si expresión === valor2break;default:// Código a ejecutar si ningún caso coincide}
Utiliza break para evitar que se sigan evaluando más casos. Si ningún caso coincide, se ejecuta el bloque default. Es útil cuando se tienen múltiples condiciones que evaluar.
