Decisiones y repeticiones

Tres horas. Media hora para escribir decisiones y repeticiones sin dejar casos fuera, y dos horas y media traduciendo reglas de negocio a código y resolviendo problemas completos.

Se explica

25 minutos · conceptos y demostración

Los condicionales y los bucles se escriben en diez minutos. Lo que ocupa la sesión es lo que casi nadie hace: comprobar la frontera, el caso vacío y el orden de las ramas. Ahí está prácticamente el total de los errores.

La decisión más simple

const total = 62;

if (total >= 50) {
  console.log("Envío gratuito");
} else {
  console.log(`Envío: 4,95 € (te faltan ${(50 - total).toFixed(2)} €)`);
}

Con varios casos:

if (stock === 0) {
  estado = "Agotado";
} else if (stock < 5) {
  estado = "Últimas unidades";
} else {
  estado = "Disponible";
}

Los límites, uno por uno

Casi todos los errores de condicionales están en la frontera. Para la regla «envío gratis a partir de 50 €», prueba con 49,99, con 50 y con 50,01. Si la regla dice «a partir de», es >=. Si dice «más de», es >.

Una advertencia: 10 <= n <= 20 no hace lo que parece. Se evalúa por partes y acaba comparando un booleano con un número.

Para elegir entre dos valores está el ternario, que solo mejora la lectura cuando el if no hace otra cosa:

const etiqueta = stock > 0 ? "Disponible" : "Agotado";

Si dentro hay varias instrucciones, o si necesitas anidar ternarios, usa un if.

Las tres formas de repetir

// Un número conocido de vueltas, con índice
for (let i = 0; i < 5; i++) {
  console.log(`Vuelta ${i}`);
}

// Recorrer los valores de una colección: el que más usarás
for (const producto of productos) {
  console.log(producto);
}

// Repetir mientras se cumpla algo, sin saber cuántas veces
let restante = 100;
while (restante > 0) {
  restante -= 30;
}

El patrón que más vas a repetir es el acumulador:

const precios = [89.9, 24.5, 199, 12.75];

let total = 0;
for (const precio of precios) {
  total += precio;
}
console.log(total.toFixed(2));   // "326.15"

El recuento con condición es una variante del mismo patrón:

let baratos = 0;
for (const precio of precios) {
  if (precio < 50) baratos++;
}

El caso vacío

const productos = [];

for (const producto of productos) {
  console.log(producto);      // no entra ninguna vez, y está bien
}

Un bucle sobre una lista vacía no falla: simplemente no se ejecuta. Lo que falla es el programa que da por hecho que había algo:

const media = total / productos.length;   // 0 / 0 → NaN

Ese NaN es el resultado más peligroso de la sesión. No detiene el programa, sino que se propaga en silencio como un número más por todo lo que venga después.

Antes de escribir código

Escribir esas cuatro respuestas cuesta dos minutos y ahorra media hora. Es exactamente el mismo hábito de la UD1, cuando antes de marcar una página decidías qué era cada cosa.

Se trabaja

150 minutos · práctica sobre tu propio proyecto

Los dos primeros pasos traducen reglas y recorren datos. El cuarto es el trabajo grande de la sesión, y el quinto es el que hace que lo anterior valga: probar los casos que nadie prueba.

Paso 1 · Las reglas de tu proyecto · 30 min

En js/main.js:

1. Escribe en comentarios cuatro reglas de negocio de tu tema, en castellano.
2. Tradúcelas a condicionales.
3. Añade el cálculo de un estado con tres posibles valores.
4. Escribe una tabla de casos límite y comprueba cada uno.
5. Convierte uno de los if de dos ramas en un ternario.
6. Añade una regla que combine dos condiciones con «y», y otra con «o».

switch (categoria) {
  case "teclado":
  case "raton":
    garantia = 24;
    break;
  case "monitor":
    garantia = 36;
    break;
  default:
    garantia = 12;
}

Antes de continuar: cada una de las cuatro reglas tiene escrito su valor de frontera y el resultado comprobado en ese valor exacto.

Paso 2 · Recorrer el catálogo · 35 min

Con una lista de al menos seis precios de tu tema:

1. Calcula el total y la media, tratando el caso de lista vacía.
2. Cuenta cuántos elementos superan un umbral.
3. Encuentra el más caro sin usar métodos de array todavía.
4. Escribe un bucle que se detenga en el primero que cumpla una condición.
5. Provoca un bucle infinito a propósito, obsérvalo, y explica qué faltaba.
6. Calcula el más caro y el más barato en un solo recorrido.

for (const producto of productos) {
  if (producto.stock === 0) continue;   // salta este y sigue
  if (producto.precio > 500) break;     // deja de recorrer
  console.log(producto.nombre);
}

Paso 3 · Un enunciado descompuesto · 15 min

Reproduce este ejemplo y comprueba que entiendes por qué el orden de las reglas cambia el resultado.

Enunciado. Dado un carrito con nombres, precios y unidades, calcula el subtotal, aplica un 10 % de descuento si supera 100 €, suma 4,95 € de envío salvo que el subtotal con descuento llegue a 50 €, y muestra el desglose.

Datos: tres listas paralelas de texto y número. Reglas: tres, y el orden importa —el descuento se aplica antes de decidir el envío—. Salida: cuatro líneas con dos decimales. Casos raros: carrito vacío, unidades cero, precio negativo.

const nombres = ["Teclado", "Ratón", "Alfombrilla"];
const precios = [89.9, 24.5, 12.75];
const unidades = [1, 2, 1];

let subtotal = 0;
for (let i = 0; i < precios.length; i++) {
  subtotal += precios[i] * unidades[i];
}

const descuento = subtotal > 100 ? subtotal * 0.1 : 0;
const conDescuento = subtotal - descuento;
const envio = conDescuento >= 50 ? 0 : 4.95;
const total = conDescuento + envio;

console.log(`Subtotal:  ${subtotal.toFixed(2)} €`);
console.log(`Descuento: ${descuento.toFixed(2)} €`);
console.log(`Envío:     ${envio.toFixed(2)} €`);
console.log(`Total:     ${total.toFixed(2)} €`);

El código se lee casi como el enunciado, y eso no es casualidad: es consecuencia de haberlo descompuesto antes.

Ahora invierte el orden de las dos reglas —decide el envío antes de aplicar el descuento— y busca un carrito en el que el total salga distinto. Ese carrito es la demostración de que el orden era parte del enunciado.

Paso 4 · Cuatro problemas · 50 min

Es el trabajo central de la sesión. Para cada uno, escribe primero las cuatro respuestas de la descomposición, y solo después programa.

1. Escalonado. Un descuento por unidades: hasta 3, nada; de 4 a 9, un 5 %; de 10 en adelante, un 12 %. Comprueba 3, 4, 9 y 10.
2. Validador. Dada una entrada de texto, decide si es un precio válido: número, positivo, con dos decimales como mucho.
3. Resumen. Dado un catálogo con precios y stock, calcula el valor total del almacén, cuántos productos están agotados y cuál es el más caro disponible.
4. Etiquetado. Genera para cada producto una etiqueta de texto que combine su estado de stock y su franja de precio.

El tercero y el cuarto tienen que funcionar con el catálogo vacío. El segundo reutiliza lo que hiciste en la sesión 1 con las entradas de texto.

Paso 5 · La tabla que casi nadie escribe · 20 min

Vuelve sobre los cuatro problemas y sobre las reglas del paso 1, y construye para cada uno esta tabla:

Rellena la columna «salida esperada» antes de ejecutar. Las filas donde no coincidan son los defectos reales de tu programa: uno que no da error y devuelve un número equivocado es peor que uno que se rompe.

Ampliación si has completado el trabajo

Primero termina y comprueba los cinco pasos. Los dos retos atacan los dos fallos que no se ven: una rama inalcanzable y un enunciado mal leído.

Reto 1 · Las ramas que nunca se alcanzan

Este código funciona, no da ningún error y clasifica mal a la mitad de los clientes.

function categoriaCliente(pedidosAnuales, gastoTotal) {
  if (pedidosAnuales > 0) {
    return "Cliente activo";
  } else if (pedidosAnuales > 10 && gastoTotal > 1000) {
    return "Cliente preferente";
  } else if (pedidosAnuales > 20) {
    return "Cliente VIP";
  } else if (pedidosAnuales === 0 && gastoTotal > 0) {
    return "Cliente inactivo con historial";
  } else if (gastoTotal > 5000) {
    return "Gran cuenta";
  }
  return "Sin categoría";
}

1. Identifica todas las ramas que no se pueden alcanzar nunca, y explica para cada una qué rama anterior se las come.
2. Reordénalo para que cada categoría sea alcanzable, sin cambiar ninguna condición.
3. Una de las categorías sigue sin poder alcanzarse ni siquiera después de reordenar, porque su condición se solapa con otra de forma irreparable. Encuéntrala y propón qué preguntarías al cliente antes de programarla.
4. Construye una tabla de seis clientes de prueba que demuestre que tu versión clasifica bien y la original no.

Reto 2 · Escribe tú el enunciado

Escribe un enunciado de programa para un compañero, del estilo de los cuatro del paso 4. Debe cumplir tres condiciones: resolverse con lo visto esta semana, tener al menos dos reglas cuyo orden importe, y tener un caso límite que no sea evidente en la redacción.

Prepara aparte, sin enseñarlo:

1. Las cuatro respuestas de la descomposición.
2. Tu solución.
3. Una tabla de siete casos de prueba, incluidos los raros.

Intercambiad los enunciados y resolvedlos sin preguntar nada. Al comparar:

• ¿La otra persona leyó el mismo orden de reglas que tú tenías en la cabeza? Si no, el enunciado era ambiguo, y eso es un hallazgo sobre tu redacción, no sobre su solución.
• ¿Encontró el caso límite que habías escondido?
• ¿Pasa su solución tu tabla de siete casos?

Un enunciado que dos personas leen distinto es exactamente lo que recibirás de un cliente. Detectarlo antes de programar es la habilidad del reto.

Cierre

5 minutos · comprobación y recuerdo