Condicionales

Estructura if/else y else if

Los condicionales son estructuras de control que permiten ejecutar diferentes bloques de código según se cumplan o no determinadas condiciones. La estructura if/else es fundamental en JavaScript y constituye la base para tomar decisiones en nuestros programas.

Estructura if básica

La forma más simple de condicional es la estructura if, que ejecuta un bloque de código únicamente si una condición es verdadera:

const edad = 18;

if (edad >= 18) {
    console.log("Eres mayor de edad");
}

La sintaxis requiere la palabra clave if, seguida de paréntesis que contienen la condición a evaluar, y llaves que encierran el código a ejecutar. Si la condición resulta true, el código dentro de las llaves se ejecuta; si es false, se omite.

Estructura if/else completa

Para manejar tanto el caso verdadero como el falso, utilizamos la estructura if/else:

const temperatura = 25;

if (temperatura > 30) {
    console.log("Hace mucho calor");
} else {
    console.log("La temperatura es agradable");
}

El bloque else se ejecuta cuando la condición del if es falsa. Esta estructura garantiza que siempre se ejecute uno de los dos bloques de código, nunca ambos ni ninguno.

Múltiples condiciones con else if

Cuando necesitamos evaluar múltiples condiciones secuenciales, utilizamos else if. Esta estructura permite crear una cadena de condiciones que se evalúan en orden:

const nota = 85;

if (nota >= 90) {
    console.log("Sobresaliente");
} else if (nota >= 70) {
    console.log("Notable");
} else if (nota >= 50) {
    console.log("Aprobado");
} else {
    console.log("Suspenso");
}

JavaScript evalúa las condiciones de arriba hacia abajo. Cuando encuentra la primera condición verdadera, ejecuta ese bloque y omite el resto. Si ninguna condición es verdadera, ejecuta el bloque else final (si existe).

Condiciones complejas

Las condiciones pueden combinar múltiples expresiones usando operadores lógicos:

const usuario = "admin";
const contraseña = "123456";

if (usuario === "admin" && contraseña === "123456") {
    console.log("Acceso concedido");
} else if (usuario === "admin" || usuario === "moderador") {
    console.log("Usuario válido, pero contraseña incorrecta");
} else {
    console.log("Usuario no reconocido");
}

Los operadores lógicos && (AND), || (OR) y ! (NOT) permiten crear condiciones sofisticadas que evalúan múltiples criterios simultáneamente.

Anidación de condicionales

Los condicionales pueden anidarse dentro de otros para crear lógicas más complejas:

const edad = 25;
const tieneCarnet = true;

if (edad >= 18) {
    if (tieneCarnet) {
        console.log("Puede conducir");
    } else {
        console.log("Es mayor de edad pero necesita carnet");
    }
} else {
    console.log("Es menor de edad");
}

Aunque la anidación es útil, es importante mantener la legibilidad del código. Demasiados niveles de anidación pueden hacer el código difícil de entender y mantener.

Buenas prácticas

Al trabajar con condicionales, es recomendable usar comparaciones estrictas (=== y !==) en lugar de comparaciones débiles (== y !=):

const input = "5";

// Evitar: comparación débil
if (input == 5) {
    console.log("Es cinco"); // Se ejecuta (conversión automática)
}

// Preferir: comparación estricta
if (input === "5") {
    console.log("Es el string cinco"); // Más predecible
}

Para condiciones que devuelven valores booleanos, podemos omitir la comparación explícita:

const estaActivo = true;

// Innecesario
if (estaActivo === true) {
    console.log("Usuario activo");
}

// Más limpio
if (estaActivo) {
    console.log("Usuario activo");
}

Las llaves son opcionales para declaraciones de una sola línea, pero se recomienda usarlas siempre para mayor claridad:

// Funciona, pero no recomendado
if (edad >= 18) console.log("Mayor de edad");

// Preferible
if (edad >= 18) {
    console.log("Mayor de edad");
}

Operador ternario

El operador ternario es una forma concisa de escribir condicionales simples que requieren elegir entre dos valores basándose en una condición. Esta sintaxis alternativa resulta especialmente útil cuando necesitamos asignar valores condicionalmente o cuando queremos simplificar estructuras if/else básicas.

Sintaxis del operador ternario

La estructura del operador ternario sigue el patrón condición ? valorSiVerdadero : valorSiFalso:

const edad = 20;
const mensaje = edad >= 18 ? "Mayor de edad" : "Menor de edad";
console.log(mensaje); // "Mayor de edad"

Esta expresión evalúa la condición antes del signo de interrogación. Si es verdadera, devuelve el valor después de ?; si es falsa, devuelve el valor después de :.

Comparación con if/else tradicional

El operador ternario puede reemplazar estructuras if/else simples, haciendo el código más compacto:

// Usando if/else tradicional
let descuento;
if (esPremium) {
    descuento = 0.2;
} else {
    descuento = 0.1;
}

// Usando operador ternario
const descuento = esPremium ? 0.2 : 0.1;

La ventaja principal del operador ternario es que produce un valor directamente, mientras que if/else ejecuta declaraciones. Esto lo hace ideal para asignaciones y expresiones.

Casos de uso prácticos

El operador ternario es perfecto para asignaciones condicionales simples:

const productos = ['laptop', 'mouse', 'teclado'];
const texto = productos.length === 1 ? 'producto' : 'productos';
console.log(`Tienes ${productos.length} ${texto}`);

También resulta útil en interpolaciones de strings:

const usuario = 'Ana';
const saludo = `Hola ${usuario}, ${usuario === 'Admin' ? 'bienvenido al panel' : 'disfruta navegando'}`;

Para validaciones rápidas en parámetros de función:

function calcularPrecio(precio, aplicarDescuento = false) {
    return aplicarDescuento ? precio * 0.8 : precio;
}

Operadores ternarios anidados

Los operadores ternarios pueden anidarse para manejar múltiples condiciones, aunque debe hacerse con cuidado para mantener la legibilidad:

const nota = 85;
const calificacion = nota >= 90 ? 'A' 
                    : nota >= 80 ? 'B'
                    : nota >= 70 ? 'C'
                    : nota >= 60 ? 'D'
                    : 'F';

Para mejorar la legibilidad en casos complejos, es recomendable usar saltos de línea y indentación:

const estado = temperatura > 35 ? 'muy caluroso'
             : temperatura > 25 ? 'caluroso'
             : temperatura > 15 ? 'templado'
             : temperatura > 5  ? 'frío'
             : 'muy frío';

Limitaciones y cuándo no usarlo

El operador ternario tiene limitaciones importantes. No puede ejecutar múltiples declaraciones como lo haría un bloque if/else:

// Esto NO funciona
const resultado = condicion ? (
    console.log("Verdadero");
    return "sí";
) : "no";

// En su lugar, usar if/else tradicional
if (condicion) {
    console.log("Verdadero");
    resultado = "sí";
} else {
    resultado = "no";
}

Buenas prácticas con operador ternario

Usar el operador ternario para condiciones simples que devuelven valores:

// Bueno: asignación simple
const acceso = esUsuarioValido ? 'permitido' : 'denegado';

// Bueno: valor de retorno
return precio > 100 ? precio * 0.9 : precio;

// Evitar: lógica compleja
const resultado = condicion1 ? (condicion2 ? valor1 : valor2) : (condicion3 ? valor3 : valor4);

Para lógicas complejas con múltiples declaraciones, es preferible usar if/else tradicional para mantener la claridad del código.

Cuando uses operadores ternarios anidados, considera si una estructura switch o una función separada sería más legible:

// En lugar de ternarios anidados complejos
function obtenerCategoria(puntuacion) {
    if (puntuacion >= 90) return 'Excelente';
    if (puntuacion >= 70) return 'Bueno';
    if (puntuacion >= 50) return 'Regular';
    return 'Deficiente';
}

El operador ternario es una herramienta valiosa para escribir código más conciso, pero debe usarse juiciosamente. Su poder radica en la simplicidad: cuando una condición simple determina qué valor usar, el operador ternario ofrece una solución elegante y legible.

Estructura switch/case

La estructura switch proporciona una alternativa elegante a las cadenas largas de if/else if cuando necesitamos comparar una variable contra múltiples valores específicos. Esta estructura resulta especialmente útil cuando tenemos muchas opciones discretas y queremos que el código sea más legible y mantenible.

Sintaxis básica del switch

La estructura switch evalúa una expresión una sola vez y la compara con múltiples casos usando comparación estricta (===):

const dia = 3;

switch (dia) {
    case 1:
        console.log("Lunes");
        break;
    case 2:
        console.log("Martes");
        break;
    case 3:
        console.log("Miércoles");
        break;
    case 4:
        console.log("Jueves");
        break;
    case 5:
        console.log("Viernes");
        break;
    default:
        console.log("Fin de semana");
}

Cada caso (case) representa un valor posible de la expresión evaluada. La palabra clave break es crucial para detener la ejecución y salir del switch una vez que se encuentra una coincidencia.

La importancia del break

Sin la declaración break, JavaScript continuará ejecutando los casos siguientes, comportamiento conocido como fall-through:

const categoria = 'B';

switch (categoria) {
    case 'A':
        console.log("Excelente");
        // Sin break, continuará al siguiente caso
    case 'B':
        console.log("Muy bueno");
        // Sin break, continuará al siguiente caso
    case 'C':
        console.log("Bueno");
        break;
    default:
        console.log("Necesita mejorar");
}
// Output: "Muy bueno" y "Bueno"

Agrupación de casos

Podemos agrupar varios casos que deben ejecutar el mismo código omitiendo deliberadamente el break:

const mes = 'diciembre';

switch (mes.toLowerCase()) {
    case 'diciembre':
    case 'enero':
    case 'febrero':
        console.log("Invierno");
        break;
    case 'marzo':
    case 'abril':
    case 'mayo':
        console.log("Primavera");
        break;
    case 'junio':
    case 'julio':
    case 'agosto':
        console.log("Verano");
        break;
    case 'septiembre':
    case 'octubre':
    case 'noviembre':
        console.log("Otoño");
        break;
    default:
        console.log("Mes no reconocido");
}

El caso default

La cláusula default es opcional pero recomendada. Se ejecuta cuando ningún caso coincide con la expresión evaluada:

const operacion = '%';

switch (operacion) {
    case '+':
        console.log("Suma");
        break;
    case '-':
        console.log("Resta");
        break;
    case '*':
        console.log("Multiplicación");
        break;
    case '/':
        console.log("División");
        break;
    default:
        console.log("Operación no válida");
}

El default puede colocarse en cualquier posición dentro del switch, aunque por convención suele ir al final.

Casos con expresiones complejas

Los casos pueden usar cualquier expresión que pueda evaluarse, no solo valores literales:

const puntuacion = 85;

switch (true) {
    case puntuacion >= 90:
        console.log("Sobresaliente");
        break;
    case puntuacion >= 70:
        console.log("Notable");
        break;
    case puntuacion >= 50:
        console.log("Aprobado");
        break;
    default:
        console.log("Suspenso");
}

Este patrón de usar switch (true) permite evaluar condiciones complejas en cada caso, aunque para estos escenarios suele ser más claro usar if/else if.

Declaración de variables en casos

Cuando necesites declarar variables dentro de casos, es importante usar llaves para crear un ámbito local:

const tipo = 'estudiante';

switch (tipo) {
    case 'estudiante': {
        const descuento = 0.5;
        console.log(`Descuento aplicado: ${descuento * 100}%`);
        break;
    }
    case 'profesor': {
        const descuento = 0.3;
        console.log(`Descuento aplicado: ${descuento * 100}%`);
        break;
    }
    default: {
        const descuento = 0;
        console.log("Sin descuento");
    }
}

Las llaves crean un bloque de código separado, evitando conflictos de nombres de variables entre casos.

Cuándo usar switch vs if/else

La estructura switch es ideal cuando:

• Comparas una variable contra múltiples valores específicos
• Tienes muchas condiciones discretas (más de 3-4 opciones)
• Los valores son primitivos (números, strings, booleanos)
• Quieres agrupar casos con comportamiento similar

// Bueno para switch: múltiples valores discretos
const statusCode = 404;

switch (statusCode) {
    case 200:
        return "OK";
    case 404:
        return "No encontrado";
    case 500:
        return "Error del servidor";
    default:
        return "Estado desconocido";
}

Usa if/else cuando:

• Necesites rangos de valores o comparaciones complejas
• Las condiciones impliquen múltiples variables
• Requieras operadores lógicos complejos

Ejemplo práctico: Sistema de calificaciones

function procesarCalificacion(letra) {
    let puntos;
    let mensaje;
    
    switch (letra.toUpperCase()) {
        case 'A':
            puntos = 4.0;
            mensaje = "Excelente trabajo";
            break;
        case 'B':
            puntos = 3.0;
            mensaje = "Buen trabajo";
            break;
        case 'C':
            puntos = 2.0;
            mensaje = "Trabajo aceptable";
            break;
        case 'D':
            puntos = 1.0;
            mensaje = "Necesita mejorar";
            break;
        case 'F':
            puntos = 0.0;
            mensaje = "Reprobado";
            break;
        default:
            puntos = null;
            mensaje = "Calificación no válida";
    }
    
    return { puntos, mensaje };
}

La estructura switch proporciona una sintaxis clara y eficiente para manejar múltiples opciones discretas, mejorando la legibilidad del código cuando se usa en los contextos apropiados.