UT3 · Guía para resolver las prácticas paso a paso

Esta guía no trae el código de las prácticas. Te enseña cómo pensar cada una: por dónde empezar, en qué trozos dividirla, qué preguntarte y cómo comprobar que funciona. El código lo escribes tú.

Úsala así:

1. Lee primero la parte 1 (el método) y la parte 2 (los patrones). Sirven para todas las prácticas.
2. Cuando vayas a hacer una práctica, abre su ficha en la parte 3 y síguela con el cuaderno al lado.
3. Si te atascas, vuelve al patrón que se cita en la ficha.

1. El método: seis pasos para cualquier ejercicio

Casi todos los bloqueos vienen de empezar a escribir código demasiado pronto. Antes de abrir VS Code, haz los pasos 1 a 4 en el cuaderno.

Paso 1. Lee y subraya

Lee el enunciado dos veces. En la segunda, subraya:

• los datos que da el usuario (normalmente, los campos del formulario);
• lo que hay que mostrar;
• las condiciones: «obligatorio», «entre 1 y 30», «solo si…», «si no…».

Mira también la plantilla: los atributos name del formulario te dicen cómo se llaman los datos que te llegan.

Paso 2. Haz la tabla Entrada – Proceso – Salida

Dibuja en el cuaderno una tabla de tres columnas:

Si no sabes rellenar alguna columna, todavía no has entendido el problema. Vuelve a leer el enunciado antes de seguir.

Paso 3. Divide el problema en trozos pequeños

Un problema grande da miedo; cinco problemas pequeños, no. Casi todas las prácticas de esta unidad se dividen en los mismos trozos:

1. Saber si el formulario se ha enviado.
2. Recoger los datos.
3. Validarlos y apuntar los errores.
4. Si no hay errores, calcular el resultado.
5. Mostrar el formulario (con lo que escribió el usuario), los errores y el resultado.

Escribe la lista en el cuaderno y ve tachando cada trozo cuando funcione.

Paso 4. Escribe el pseudocódigo

El pseudocódigo es el programa escrito en castellano, con la estructura de un programa: SI … ENTONCES, PARA CADA …, MIENTRAS …. No tiene que compilar; tiene que ser claro.

SI se ha enviado el formulario ENTONCES
    recoger número
    SI número no es entero positivo ENTONCES
        apuntar error
    SI NO
        calcular letra
FIN SI

Después, haz una traza: elige unos datos de prueba y sigue el pseudocódigo a mano, línea a línea, apuntando el valor de cada variable. Si la traza da el resultado correcto, el algoritmo está bien y solo queda traducirlo a PHP.

Paso 5. Programa poco a poco y comprueba cada trozo

No escribas todo de golpe. Escribe un trozo, guarda, recarga el navegador y comprueba que hace lo que esperas. Para ver qué contiene una variable, usa:

echo '<pre>';
var_dump($_POST);   // o la variable que quieras inspeccionar
echo '</pre>';

Cuando el trozo funcione, borra la línea de depuración y pasa al siguiente.

Paso 6. Prueba con casos pensados y haz commit

Prueba siempre tres tipos de casos:

Cada ficha de la parte 3 trae una tabla de casos de prueba. Cuando todos pasen, haz el commit (P05: dibuja triángulo).

2. Patrones que se repiten

Un patrón es una forma de resolver un tipo de problema que aparece una y otra vez. Si reconoces el patrón, ya tienes media práctica hecha. En cada ficha se indica cuáles usar.

Patrón A · Estructura de una página PHP

Separa la página en dos zonas:

┌──────────────────────────────────────────┐
│ ZONA DE LÓGICA (PHP, antes del DOCTYPE)  │
│  · inicializar variables                 │
│  · ¿se ha enviado? → recoger, validar,   │
│    calcular                              │
├──────────────────────────────────────────┤
│ ZONA DE PRESENTACIÓN (HTML)              │
│  · solo muestra variables ya calculadas  │
│  · if / foreach con sintaxis alternativa │
└──────────────────────────────────────────┘

Regla de oro: en la zona de HTML no se calcula nada; solo se muestra. Si te ves haciendo cuentas en mitad de una <table>, sube ese cálculo a la zona de lógica y guarda el resultado en una variable.

Inicializa al principio todas las variables que usará el HTML ($errores = [], $resultado = null, los valores de los campos a ''). Así la página funciona igual la primera vez que se abre, cuando todavía no se ha enviado nada.

Patrón B · ¿Se ha enviado el formulario?

En una página autoprocesada hay dos momentos: la primera visita (formulario vacío) y el envío. Distínguelos preguntando por el método de la petición ($_SERVER['REQUEST_METHOD']), como en la teoría (apartado 4).

En una página de resultados separada (…-res.php), si no se ha llegado por POST, redirige al formulario con header('Location: …') seguido de exit. Recuerda que header() tiene que ir antes de cualquier salida HTML, incluso antes de un espacio en blanco.

Patrón C · Validar y acumular errores

No muestres el primer error y te pares. Revisa todos los campos y apunta cada error en un array:

errores ← lista vacía
SI campo1 no es válido ENTONCES errores['campo1'] ← "mensaje"
SI campo2 no es válido ENTONCES errores['campo2'] ← "mensaje"
…
SI errores está vacío ENTONCES
    calcular y preparar el resultado
FIN SI

Usar el nombre del campo como clave te permite, después, mostrar cada error debajo de su campo (P09) o todos juntos (P12).

Para validar números, usa filter_input() o filter_var() con FILTER_VALIDATE_INT o FILTER_VALIDATE_FLOAT. Devuelven false si el dato no es válido, y admiten la opción min_range / max_range para los rangos. Compara siempre con === false, porque el número 0 también se evalúa como falso.

Patrón D · Formulario persistente

Después de enviar, el formulario debe mostrar lo que escribió el usuario:

Cuando haya muchas opciones, no compares una a una: genera las opciones con un bucle a partir de un array y compara dentro del bucle. Si lo haces en varias prácticas, crea una pequeña función que devuelva 'checked' o ''.

Patrón E · Escapar todo lo que se muestra

Todo dato que venga del usuario y vaya a aparecer en la página pasa por htmlspecialchars(). Si lo escribes muchas veces, crea una función corta h() que lo haga (la pide la P12, pero puedes usarla desde la P01).

Patrón F · Tabla de consulta en lugar de muchos if

Si tienes que traducir un valor a otro (un código a un texto, una divisa a su tasa, una opción a su ajuste), no encadenes if. Usa:

• un array asociativo clave => valor, si los datos se usan en varios sitios (P07, P11, P12);
• una expresión match, si solo es una traducción puntual (P01).

Ventaja: para añadir una opción nueva solo cambias el array, no la lógica.

Patrón G · Lista blanca

No te fíes de lo que llega del formulario: el usuario puede modificar el HTML desde el navegador y enviar cualquier cosa. Comprueba que el valor recibido está entre los permitidos antes de usarlo:

• in_array($valor, $permitidos) si tienes una lista de valores (P08);
• array_key_exists($valor, $array) o isset($array[$valor]) si los valores son claves de un array (P07, P11, P12).

Patrón H · Acumulador, contador, máximo y mínimo

Cuatro cosas que se calculan recorriendo una lista:

suma ← 0                       contador ← 0
PARA CADA x EN lista           PARA CADA x EN lista
    suma ← suma + x                SI x cumple la condición ENTONCES
FIN PARA                               contador ← contador + 1
                                   FIN SI
                               FIN PARA

máximo ← primer elemento
PARA CADA x EN lista
    SI x > máximo ENTONCES máximo ← x
FIN PARA

Fíjate en el valor inicial: la suma y el contador empiezan en 0; el máximo y el mínimo empiezan en el primer elemento de la lista (no en 0: si todas las notas fueran negativas, o todas fueran mayores que 0 al buscar el mínimo, fallaría).

Patrón I · Bucles anidados

Cuando el resultado tiene filas y columnas, piensa en dos bucles:

• el exterior recorre las filas;
• el interior recorre los elementos de cada fila.

La clave es descubrir de qué depende el número de vueltas del bucle interior. A veces es fijo; a veces depende de la fila en que estás (como en el triángulo de la P05).

Patrón J · «Cada N elementos» con el módulo

El operador % da el resto de una división. Sirve para hacer algo cada N elementos: si numeras desde 1, i % N == 0 es cierto en el elemento N, 2N, 3N…, y (i - 1) % N == 0 es cierto en el elemento 1, N+1, 2N+1… Úsalo en la P06 para saber cuándo abrir y cuándo cerrar una fila.

3. Fichas de las prácticas

Cada ficha tiene la misma estructura: qué tienes y qué quieres, estrategia (los trozos en orden), preguntas para el cuaderno, casos de prueba y errores típicos.

P01 · Formulario de búsqueda de canciones

Patrones: B, E, F · Plantillas: ut03p01.html (ya hecho) y ut03p01-res.php

Estrategia

1. En ut03p01-res.php, antes del DOCTYPE, comprueba si se ha llegado por POST. Si no, redirige al formulario (patrón B). Pruébalo abriendo ut03p01-res.php directamente.
2. Recoge los tres campos. Usa el operador ?? para dar un valor por defecto si alguno no llega.
3. Traduce el valor interno de buscar_en (cancion, album, ambos) a un texto con match (patrón F). Piensa qué hace match si llega un valor que no está en la lista: añade un caso default.
4. Sustituye los textos de ejemplo de la plantilla por tus variables, escapadas (patrón E).

Casos de prueba

P02 · Catálogo de controles de formulario

Patrones: B, E · Plantillas: ut03p02.php (ya hecho) y ut03p02-res.php

Estrategia

1. Antes de programar nada, envía el formulario con var_dump($_POST) y var_dump($_FILES) en la página de resultados. Mira cómo llega cada control: ¿es una cadena?, ¿un array?, ¿no aparece?
2. Apunta en el cuaderno, para cada control, si llega como cadena o como array, y qué pasa si no lo rellenas.
3. Recoge uno a uno. Los que llegan como array (extras[], idiomas[]) se recogen con ?? [] y se muestran unidos con implode().
4. Para el fichero, todo está en $_FILES['fichero']: busca en la teoría (apartado 4.3.1) qué claves tiene (name, size, type, error…). Comprueba antes si se ha subido algo.
5. La contraseña no se muestra: genera tantos • como caracteres tenga (str_repeat() y strlen()), o un número fijo.
6. El comentario se escapa primero y después se pasa por nl2br(). Piensa por qué el orden importa.

Casos de prueba

P03 · Calculadora de la letra del DNI

Patrones: A, B, C, D, E · Plantilla: ut03p03.php (autoprocesada)

Estrategia

1. Cuaderno primero: haz el cálculo con tu DNI (lo pide el enunciado). Divide entre 23, apunta el resto y busca esa posición en la cadena TRWAGMYFPDXBNJZSQVHLCKE. Ojo: la primera letra es la posición 0.
2. Escribe la función calcularLetraDNI() y pruébala sola, sin formulario, con un echo y un número fijo. Cuando dé Z para 12345678, sigue.
3. Monta la zona de lógica (patrón A): inicializa $error, $numero y $resultado.
4. Si se ha enviado (patrón B), valida con FILTER_VALIDATE_INT y min_range (patrón C).
5. Si es válido, llama a tu función y construye el DNI completo rellenando con ceros (str_pad(), con STR_PAD_LEFT).
6. En el HTML, muestra el error solo si existe y el resultado solo si existe. Haz el campo persistente (patrón D).
7. Botón Borrar: piensa por qué un enlace a la propia página la deja vacía (es una petición GET).

Casos de prueba

P04 · Ecuación de segundo grado

Patrones: A, B, C, D · Plantilla: ut03p04.php

Estrategia

1. Cuaderno: escribe la fórmula x = (−b ± √(b² − 4ac)) / 2a y resuelve a mano el ejemplo del enunciado.
2. Valida los tres coeficientes con FILTER_VALIDATE_FLOAT (patrón C). Después, comprueba aparte que a no es 0. ¿Por qué? Piensa qué pasa en la fórmula si a vale 0.
3. Calcula el discriminante en una variable.
4. Decide con un if: negativo → aviso; cero o positivo → dos soluciones (sqrt()).
5. Formatea con number_format() (2 decimales, coma decimal).
6. Haz persistentes los tres campos.

SI discriminante < 0 ENTONCES
    resultado ← "sin soluciones reales"
SI NO
    x1 ← (−b + raíz(discriminante)) / (2·a)
    x2 ← (−b − raíz(discriminante)) / (2·a)
FIN SI

Casos de prueba

P05 · Dibuja un triángulo

Patrones: A, C, D, I · Plantilla: ut03p05.php

Estrategia

1. Cuaderno: dibuja el triángulo de altura 4 y numera las filas. Responde: en la fila 1, ¿cuántos caracteres hay?, ¿y en la 2?, ¿y en la fila i? Ahí tienes el límite del bucle interior.
2. Haz la traza que pide el enunciado para altura 3.
3. Valida la altura con FILTER_VALIDATE_INT, min_range 1 y max_range 30. Si el carácter llega vacío, usa *.
4. Construye todo el dibujo en una variable (en la zona de lógica), concatenando, y muéstrala en el <pre> al final (patrón A).

dibujo ← ""
PARA fila DESDE 1 HASTA altura
    PARA columna DESDE 1 HASTA ¿…?        ← lo has deducido en el cuaderno
        añadir carácter y un espacio a dibujo
    FIN PARA
    añadir salto de línea a dibujo
FIN PARA

Casos de prueba

P06 · Tabla numerada dinámica

Patrones: A, C, D, J · Plantilla: ut03p06.php

Estrategia

1. Cuaderno: dibuja la tabla para 12 casillas y 5 por fila. Rodea con un círculo los números donde empieza cada fila (1, 6, 11) y los números donde acaba (5, 10). ¿Qué tienen en común respecto al 5? (patrón J).
2. Escribe primero un bucle que genere todas las celdas sin filas. Comprueba que salen los 12 números.
3. Añade la apertura de <tr>: ¿en qué números se abre una fila?
4. Añade el cierre de </tr>: ¿en qué números se cierra?
5. Al terminar el bucle, mira si la última fila quedó abierta. Si es así, calcula cuántas celdas vacías faltan, añádelas y cierra la fila.

Casos de prueba

P07 · Conversor de divisas

Patrones: C, D, F, G · Plantilla: ut03p07.php

Estrategia

1. Cuaderno: las tasas dicen «cuántas unidades de esa divisa vale 1 euro». Resuelve a mano: ¿cuántos euros son 100 USD?, ¿y cuántos yenes son esos euros? Deduce la regla: para pasar a euros, ¿multiplicas o divides?
2. Crea el array $tasas (patrón F).
3. Valida la cantidad (número no negativo) y comprueba que de y a son claves de $tasas (patrón G).
4. Calcula en dos pasos, con una variable intermedia para los euros. Así cada paso se entiende y se puede comprobar.
5. Formatea con sprintf() y %.2f.
6. Genera las <option> de los select con un foreach sobre $tasas y añade selected a la elegida (patrón D). Así no repites el código en los dos select.

euros ← cantidad / tasa[de]
resultado ← euros · tasa[a]

Casos de prueba

P08 · La quiniela

Patrones: B, E, G, H · Plantillas: ut03p08.php y ut03p08-res.php

Estrategia

Formulario

1. Coge la fila modelo de la plantilla y métela en un for de 1 a 10. Sustituye el número fijo por la variable del bucle en todos los sitios donde aparece (texto, name, id, for).
2. Comprueba con F12 que los name quedan como partido[1], partido[2]… y que los id no se repiten.

Resultados

1. Redirige si no se llega por POST (patrón B).
2. Recoge el array partido con ?? [] y haz var_dump() para ver su forma.
3. Prepara un array con los tres signos válidos. Te sirve para dos cosas: validar (patrón G) y simular el resultado eligiendo una posición al azar con rand().
4. Recorre de 1 a 10. En cada vuelta: tu apuesta (o «SIN MARCAR» si no existe o no es válida), el resultado simulado y si coinciden. Si coinciden, suma un acierto (patrón H).
5. Guarda cada fila en un array en la zona de lógica y, en el HTML, recórrelo con foreach para pintar la tabla (patrón A).

Casos de prueba

P09 · Formulario de alta validado con expresiones regulares

Patrones: A, C, D, E · Plantilla: ut03p09.php

Es la práctica más larga del nivel intermedio. No la abordes entera: hazla campo a campo.

Estrategia general

1. Monta primero el esqueleto con un solo campo (el código postal, que es el más sencillo): recoger, normalizar, validar, mostrar el error debajo del campo y hacerlo persistente. Cuando funcione, copia la mecánica a los demás.
2. Usa el array de errores con el nombre del campo como clave (patrón C). En el HTML, cada campo pregunta si existe su clave en $errores para añadir is-danger y el mensaje.
3. Para cada campo sigue siempre el mismo orden: normalizar → validar → guardar el valor normalizado.

Cómo construir una expresión regular sin perderte

1. Escribe en castellano la regla, trozo a trozo, de izquierda a derecha: «empieza por…, luego vienen…, y termina».
2. Traduce cada trozo por separado: «una cifra» → \d; «exactamente 5» → {5}; «uno de estos caracteres» → […]; «esto o esto otro» → ( | ); «opcional» → ?.
3. Ancla siempre con ^ al principio y $ al final. Sin anclas, 12345 también «encaja» dentro de abc12345xyz.
4. Prueba la expresión aislada en una web como regex101.com (elige el modo PCRE, que es el de PHP) con los ejemplos válidos y no válidos de la tabla del enunciado, antes de ponerla en el código.

Pistas por campo

Casos de prueba: usa directamente las columnas Válido y No válido de la tabla del enunciado, más estos:

P10 · Gestión de calificaciones

Patrones: C, D, H · Plantilla: ut03p10.php

Estrategia

1. Envía el formulario con var_dump($_POST) y observa: llegan dos arrays paralelos. El alumno de la posición 0 de nombres tiene su nota en la posición 0 de notas.
2. Recorre las posiciones de 0 a 3. En cada una, valida el nombre (no vacío tras trim()) y la nota (FILTER_VALIDATE_FLOAT con rango 0–10). Si falla, apunta el error indicando qué fila falla (patrón C). Si es correcta, añádela al array asociativo $alumnos.
3. Escribe las tres funciones antes de usarlas y pruébalas con un array fijo escrito a mano, sin formulario.
   • calcular_media(): acumulador (patrón H), o array_sum() y count().
   • obtener_maximo() / obtener_minimo(): patrón H, pero recuerda también el nombre, no solo la nota. Recorre con foreach ($alumnos as $nombre => $nota).
4. Solo si no hay errores, llama a las funciones y prepara los datos para el HTML.
5. En la tabla, decide el estado y la clase de color con un if o con el operador ternario.

mejor_nombre ← primer nombre;  mejor_nota ← primera nota
PARA CADA (nombre, nota) EN alumnos
    SI nota > mejor_nota ENTONCES
        mejor_nota ← nota
        mejor_nombre ← nombre
    FIN SI
FIN PARA
devolver [nombre ← mejor_nombre, nota ← mejor_nota]

Casos de prueba

P11 · Buscador de productos con filtros

Patrones: D, F, G · Plantillas: ut03p11.php, ut03p11-res.php y datos.php

Estrategia

Formulario

1. Incluye datos.php con require_once y comprueba con var_dump($categorias) que llega.
2. Genera las <option> con un foreach sobre $categorias, después de la opción Todas.

Resultados

1. Recoge los filtros de $_GET. Para cada uno, decide qué significa «no rellenado»: categoría vacía o Todas; precio vacío; checkbox sin marcar (no existe en $_GET).
2. Valida la categoría con lista blanca contra $categorias (patrón G) y los precios como números.

3. Antes de usar array_filter(), escribe la condición en pseudocódigo para un solo producto. Una buena estrategia es empezar suponiendo que el producto pasa y descartarlo si falla algún filtro activo:

   FUNCIÓN pasa_los_filtros(producto)
       SI hay filtro de categoría Y la categoría del producto es distinta ENTONCES devolver falso
       SI hay precio mínimo Y el precio del producto es menor ENTONCES devolver falso
       SI ¿… precio máximo …?
       SI ¿… solo con stock …?
       devolver verdadero
   FIN FUNCIÓN
   

4. Convierte ese pseudocódigo en una función anónima y pásala a array_filter(). La función recibe un producto, pero los filtros están fuera de ella: por eso necesitas use (…) para «meterlos» dentro.

5. Prepara los textos del resumen (por ejemplo, «Todas», «Sin límite»).
6. En el HTML: si el array filtrado está vacío, aviso; si no, tabla con foreach. Precio con number_format() y €; stock en verde o Sin stock en rojo.

Casos de prueba

P12 · Reto: calculadora de esperanza de vida

Patrones: todos · Plantilla: ut03p12.php

Es el reto final: junta todo lo de la unidad. La clave está en diseñar bien el array antes de escribir una sola línea.

Estrategia

1. Diseña el array en el cuaderno. Dibuja su forma como un árbol antes de escribirlo en PHP. Por ejemplo:

   $preguntas
    ├── 'tabaco'
    │    ├── 'titulo'   → "¿Fumas o has fumado?"
    │    ├── 'ayuda'    → "Cuenta cigarrillos, puros y pipa."
    │    └── 'opciones'
    │         ├── 'nunca'      → [ 'texto' → "Nunca he fumado",   'ajuste' → 0 ]
    │         ├── 'ex_antes'   → [ 'texto' → "Lo dejé antes…",    'ajuste' → -1 ]
    │         └── …
    ├── 'actividad'
    │    └── …
    └── …
   

   Las claves de primer nivel serán los name de los radio; las claves de opciones, sus value. Respeta las que ya usa la plantilla (tabaco, nunca, ex_antes…). Haz lo mismo para la esperanza de vida base (hombre, mujer) y para los tramos del IMC (una lista ordenada de pares límite – ajuste).

2. Escribe las funciones auxiliares h(), fmt() y marcado() y pruébalas aisladas. fmt() debe poner el signo + delante de los positivos.

3. Genera el formulario desde el array: un foreach exterior para las preguntas (un fieldset cada una) y un foreach interior para las opciones (patrón I). Comprueba que, si añades una pregunta al array, aparece sin tocar el HTML.
4. Valida con lista blanca: para cada pregunta, la opción recibida debe ser una clave de sus opciones (patrón G). Altura y peso, con rango. Acumula todos los errores (patrón C) y, si algo falla, usa un valor por defecto.
5. Calcula:
   • Parte de la esperanza base según el sexo.
   • Recorre las preguntas: busca el ajuste de la opción elegida, súmalo al total y guarda una entrada en un array $desglose (factor, opción elegida, ajuste).
   • IMC: convierte la altura a metros. Recorre los tramos en orden y quédate con el primero cuyo límite sea mayor que el IMC. Añade su ajuste al total y al desglose.
   • Factor que más resta: recorre $desglose buscando el ajuste mínimo (patrón H).
6. Muestra el resultado y el desglose con foreach, eligiendo la clase de color según el signo del ajuste.

Casos de prueba

4. Lista de comprobación antes de entregar

Repasa esta lista con cada práctica antes de hacer el commit final:

• He hecho en el cuaderno la tabla E-P-S y el pseudocódigo (y la traza, si se pide).
• La página funciona la primera vez que se abre, sin warnings.
• He probado los casos normales, límite y erróneos de la ficha.
• Todo lo que viene del usuario se muestra con htmlspecialchars().
• Los números se validan con filter_input() o filter_var().
• Los valores de radio, select y checkbox se comprueban con lista blanca.
• El formulario conserva los datos (salvo la contraseña).
• No hay cálculos en mitad del HTML: la lógica está arriba.
• El código tiene comentarios que explican qué hace cada bloque.
• He borrado los var_dump() de depuración.
• He hecho el commit con un mensaje claro.