Unidad 04e · Lo que tu página recuerda
Semana 8 del programa · se lanza en el Taller de proyectos II y se trabaja en casa; se abre al empezar la Unidad 10 «El montaje», semana 13 · 10.º y 11.º grado · cada proyecto, solo o en grupo · con IA o sin IA, como tú elijas.
Lo que vas a hacer
Tu centro de mando ya existe. Ábrelo y haz esto: escribe algo en él, donde se pueda escribir. Ahora recarga la página.
Desapareció.
Y hay una segunda cosa, que se nota menos y molesta más. Si tu proyecto tiene una lista —veinticinco cartas, diez paradas, seis tareas, cuatro personajes—, esa lista está escrita a mano dentro del HTML, una por una. Cambiar la carta número doce quiere decir buscarla entre el código. Añadir la veintiséis quiere decir copiar un pedazo y rezar para no romper nada.
Esta semana arreglas las dos cosas, y resultan ser la misma: separar lo que tu proyecto dice de cómo tu proyecto se ve.
Vas a dar dos memorias a tu página:
- Los datos de tu proyecto — tu lista, en un solo sitio, escrita una sola vez, con la misma ficha para cada elemento. La página se dibuja sola a partir de ahí. Esto viaja dentro del archivo: es tuyo, va contigo, funciona con el wifi apagado.
- Lo que escribe quien la usa — una nota, una marca, una partida a medias. Eso se queda en el aparato de esa persona, y sigue ahí cuando vuelve mañana.
Un solo entregable: tu lista convertida en datos, y la página dibujándose sola a partir de ella. La segunda memoria viene con ella si te alcanza el tiempo, y si no, queda como PENDIENTE — visible, como siempre.
Por qué vale la pena
Porque es el momento exacto en que un proyecto deja de ser una demostración y empieza a ser una cosa que se usa. Una página que enseña tres cartas de ejemplo es una maqueta. Una página con las veinticinco cartas en un sitio donde puedes añadir la veintiséis en diez segundos es un proyecto que crece.
Y porque te obliga a una pregunta que nadie se hace a tiempo: ¿qué sabe tu proyecto, exactamente? No «de qué trata», no «para quién es» — qué sabe. Una carta ¿qué tiene? ¿Un texto y nada más? ¿Un texto y un tipo? ¿Un texto, un tipo, una dificultad y una parada a la que pertenece? Esa decisión la tomas tú, en papel, antes de pedirle nada a nadie, y es la decisión que más va a aguantar de todo lo que hagas este mes.
Hay una manera de saber que lo hiciste bien: si para añadir algo nuevo hay que tocar una sola línea, está bien hecho. Si hay que tocar tres sitios distintos, todavía no.
La hoja que tienes delante ya lo hace
Lo que escribes en la hoja de trabajo de esta página —la de esta Unidad y la de todas las anteriores— se queda en tu aparato y sigue ahí cuando vuelves. No se envía a ningún lado, no hay servidor, no hay cuenta.
Es exactamente lo que vas a construir hoy, y lleva meses funcionando delante de ti sin que haga falta explicarlo. Esa es la escala de lo que estamos pidiendo: no es una tecnología de empresa, es una cosa de doce líneas.
Dos memorias, y no se parecen en nada
Confundirlas es el error de la semana, así que vale la pena separarlas antes de empezar.
| Los datos de tu proyecto | Lo que escribe quien la usa | |
|---|---|---|
| ¿De quién son? | Tuyos | De quien abrió la página |
| ¿Dónde viven? | Dentro del archivo | En el navegador de esa persona |
| ¿Viajan contigo? | Sí, en el USB, en el correo, al liceo | No. Se quedan en ese aparato |
| ¿Quién los cambia? | Tú, editándolos | Quien la usa, usándola |
| ¿Se pierden? | No, mientras tengas el archivo | Sí: otro navegador, otra computadora, o si borra sus datos |
Lo segundo tiene una consecuencia que hay que decir en voz alta: si tu proyecto depende de que no se pierda, eso no es un sitio donde guardarlo. Sirve para que una partida siga donde la dejaste, para que una nota aguante hasta mañana, para que no tengas que volver a escoger el idioma cada vez. No sirve de archivo de nada importante. Lo importante va dentro del archivo, que es tuyo y lo copias.
La regla dura de esta Unidad: nada de fetch()
Cuando le pidas a una IA que tu página lea una lista de datos, te va a dar esto, casi seguro, porque es lo que haría para una página de internet:
fetch('datos.json')
En tu proyecto eso no se usa, y no es un capricho. Son tres razones, y cada una sola ya bastaría:
- Rompe el encargo. Tu centro de mando tiene que abrir con doble clic y funcionar con el wifi apagado. Lo que va a buscar algo fuera, fuera necesita.
- Ni siquiera funciona. Cuando abres tu página desde tu carpeta, la barra de dirección dice
file:///…. En ese modo el navegador bloqueafetch()incluso hacia un archivo que está al lado, en la misma carpeta. Lo que sale es una página en blanco que no explica por qué, y una tarde perdida. - La entrega lo rechaza. La página donde entregas esta Unidad revisa lo que le mandas, y una página con
fetch()—o conXMLHttpRequest, o con un formulario que manda datos a otro sitio— no se recibe. No es un aviso: es un no.
Esa tercera razón es un hecho de cómo se entrega en este programa, comprobado el 18 de noviembre de 2026, no una ley de la informática: si algún día cambia la vía de entrega, cambia la regla. Las otras dos no cambian, y la distinción que enseña —los datos por un lado, ir a buscarlos por otro— se queda igual.
Así que tus datos no se van a buscar a ninguna parte: ya están dentro. La página no los pide, los tiene.
Esto no es una limitación que sufrimos: es la diferencia entre dos cosas que se parecen y no son iguales. Los datos son una cosa. Ir a buscarlos por internet es otra. Aquí aprendes la primera sin la segunda, que es el orden que después deja entender la segunda.
Una ficha, y todas iguales
Un conjunto de datos —un dataset— es una lista de cosas del mismo tipo, donde todas tienen exactamente los mismos campos. Eso es todo. No hay más misterio.
Las veinticinco cartas del juego de las paradas, cada una con su texto, su tipo y su dificultad. Las diez paradas, cada una con su nombre inventado, su zona y su número de orden. Las seis tareas de tu plan, cada una con su fecha, su estado y de quién es.
«Exactamente los mismos campos» es la parte que se salta todo el mundo y la que hace que funcione. Si la carta 7 tiene dificultad y la 8 no, el día que la página ordene las cartas por dificultad, la 8 se va a caer al final, o va a romper la página entera. Un campo que a veces está y a veces no, no es un campo: es una avería esperando. Si un dato no lo sabes todavía, el campo se queda, con "PENDIENTE" escrito dentro. Ahí está la palabra de la Unidad pasada otra vez, y hace exactamente lo mismo: se ve.
Y el nombre de los campos lo eliges tú, en tu idioma, con palabras tuyas. texto, tipo, dificultad — no field1, field2. Dentro de dos meses vas a abrir esto y los nombres son todo lo que te va a quedar.
Dónde van los datos, exactamente
Dentro de tu página, en un bloque que el navegador no intenta ejecutar ni dibujar: lo guarda y ya.
<script type="application/json" id="datos">
{
"cartas": [
{ "texto": "Te bajaste una parada antes. Pierdes un turno.", "tipo": "percance", "dificultad": 1 },
{ "texto": "Alguien te indica mal. Avanza dos y retrocede tres.", "tipo": "percance", "dificultad": 2 },
{ "texto": "Reconoces el letrero. Avanza tres.", "tipo": "suerte", "dificultad": 1 }
]
}
</script>
Y tu JavaScript lo lee así, en una línea:
const datos = JSON.parse(document.getElementById('datos').textContent);
Eso es la base de datos entera. Nada más. Ahora las cartas están en un solo sitio, se leen sin bajar a mirar el código de la página, y añadir la veintiséis es escribir una línea donde están las otras veinticinco.
Dos trampas, y las dos las vas a pisar la primera vez. La coma va entre elementos y nunca después del último — una coma de más y JSON.parse falla y no se dibuja nada. Y dentro del JSON las comillas son dobles siempre, también en los nombres de los campos. Si tu texto lleva comillas por dentro, díselo a la herramienta y que se encargue: eso sí es trabajo suyo.
La segunda memoria, en cuatro líneas
Para lo que escribe quien usa tu página:
localStorage.setItem('paradas-v1', JSON.stringify(estado));
const guardado = localStorage.getItem('paradas-v1');
const estado = guardado ? JSON.parse(guardado) : { partidaEmpezada: false, turno: 0 };
Tres cosas que tienen que estar, y que la herramienta no pone si no se las pides:
- Un nombre con versión (
paradas-v1). El día que cambies la forma de lo que guardas, pasas a-v2y lo viejo no se mezcla con lo nuevo. - Un valor por defecto para la primera vez. La primera persona que abre tu página no tiene nada guardado, y si tu código no cuenta con eso, lo primero que ve es una página rota.
- Que no se caiga si lo guardado está mal. En una ventana privada, o con los datos bloqueados, leer puede fallar. Tu página tiene que seguir funcionando, vacía pero entera.
Y la regla que no cambia nunca: ahí tampoco entra nada que identifique a nadie. Ni nombres, ni teléfonos, ni direcciones, ni el liceo. Es el aparato de otra persona: lo que tu página escriba ahí, se queda ahí, y tú no tienes que estar guardando datos de nadie para que tu proyecto funcione.
Los siete pasos
El proyecto de los ejemplos es el mismo de siempre, inventado para la clase: el juego de mesa que se juega con las paradas del autobús del barrio.
0. El encuadre
(Solo si trabajas con IA.)
Vamos a trabajar sobre el centro de mando de mi proyecto, que ya existe: una página autocontenida que abre con doble clic y funciona sin internet.
Quiero separar los datos de mi proyecto del código que los enseña, y que la página se dibuje sola a partir de esos datos.
Tres condiciones, y son firmes:
1. Nada de fetch(), XMLHttpRequest ni nada que salga a internet o lea un archivo aparte. Mi página se abre con file:// y eso no funciona ahí. Los datos van DENTRO de la página, en un <script type="application/json">.
2. El contenido de los datos lo pongo yo. Si te falta algo, pregúntamelo. Lo que no te dé, lo dejas escrito como "PENDIENTE" dentro del campo, nunca inventado.
3. No uses ni me pidas el nombre de ninguna persona, direcciones, ni ningún dato que identifique a alguien.
Antes de escribir código, hazme las preguntas que te ayuden a construirlo mejor.
Sin IA. Abres el cuaderno en una página nueva y escribes arriba: qué lista tiene mi proyecto. Ya estás en el paso 1.
1. Encontrar la lista que tu página repite
Abre tu centro de mando y busca algo que aparezca varias veces con la misma forma. Eso es tu conjunto de datos, y ya existe — lo que pasa es que está escrito a mano.
Casi todos los proyectos tienen uno y no lo habían mirado así: las cartas de un juego · las paradas de un recorrido · las preguntas de un test · los personajes · las tareas del plan con sus fechas · los productos de un puesto con su precio · los días de una rutina.
Ejemplo:
Mi página tiene tres cartas de ejemplo escritas a mano, una debajo de otra, con el mismo formato. Y el plan tiene seis tareas, cada una con su fecha. Son dos listas. Empiezo por las cartas, que son las que van a crecer a veinticinco.
Elige una sola. La más larga, o la que más va a crecer. Las otras se hacen igual después, y en la mitad de tiempo.
Sin IA. Lo mismo, mirando tu centro de mando de papel: qué se repite con la misma forma. En un tríptico suele ser la tabla que dibujaste a regla.
2. Decidir la ficha, en papel
Este es el paso que decide, y va sin pantalla. Unos veinte minutos.
Escribes en el cuaderno qué campos tiene cada elemento de tu lista. Entre tres y seis; con más de seis, casi siempre hay dos cosas distintas mezcladas. De cada campo escribes el nombre y de qué tipo es: texto, número, sí/no, o una de varias opciones fijas.
Y después haces lo único que de verdad lo prueba: escribes tres elementos completos a mano, con todos sus campos rellenos. No uno: tres. Al segundo aparece el campo que te falta; al tercero, el que sobra.
Ejemplo:
Carta:
texto(texto) ·tipo(una de: percance, suerte, pregunta) ·dificultad(número del 1 al 3) ·parada(texto, o PENDIENTE si la carta sirve en cualquiera).
- «Te bajaste una parada antes. Pierdes un turno.» · percance · 1 · PENDIENTE
- «Alguien te indica mal. Avanza dos y retrocede tres.» · percance · 2 · PENDIENTE
- «Reconoces el letrero. Avanza tres.» · suerte · 1 · PENDIENTE
Al escribir la tercera me di cuenta de que
paradano lo tengo decidido en ninguna carta. Se queda el campo, con PENDIENTE, y lo decido cuando tenga el tablero.
Sin IA. Idéntico — este paso no usa ninguna herramienta en ninguno de los dos modos. Es la tabla que vas a dibujar a regla en tu centro de mando de papel: una columna por campo, una fila por carta.
3. Meterlos dentro de la página
Ahora sí, con la hoja del paso 2 delante.
Añade a mi página un bloque <script type="application/json" id="datos"> con esta lista, tal cual te la doy, sin cambiar ni inventar nada:
[aquí pegas tu lista del paso 2, completa]
Todos los elementos tienen que tener exactamente los mismos campos. Si a alguno le falta uno, pon "PENDIENTE" dentro, no lo quites.
Y añade la línea que lo lee con JSON.parse. Nada de fetch().
Ejemplo de lo que vuelve: el bloque con tus cartas dentro, y una línea que las lee. Todavía no se ve nada distinto en la página. Es normal: los datos ya están, falta dibujarlos.
Sin IA. Pasas tu tabla a limpio en el centro de mando de papel, en una hoja que sea solo la tabla y nada más. Esa hoja es tu bloque de datos: una sola, legible, sin nada alrededor.
4. Que la página se dibuje sola
Ahora quita de la página las cartas que están escritas a mano y haz que se dibujen solas recorriendo los datos del bloque: una tarjeta por cada elemento de la lista.
El aspecto es el mismo que ya tiene. Lo que cambia es de dónde salen.
Cuando termines, dime en qué línea tendría que escribir yo para añadir una carta nueva.
Esa última frase es la prueba de la Unidad. Si la respuesta es «en una sola línea, dentro del bloque de datos», está bien hecho. Si la respuesta es «en dos sitios», pídele que lo arregle, y dile por qué: los datos van en un solo sitio.
Ejemplo:
Añadí una cuarta carta dentro del bloque, guardé, recargué y apareció sola en la página. No toqué nada más. Ahí entendí para qué servía todo esto.
Sin IA. La tabla es la fuente, y las cartas del juego se escriben desde la tabla, nunca al revés. Si corriges una carta, la corriges en la tabla primero. Es la misma regla con papel: un solo sitio manda.
5. Que se acuerde
Si tu proyecto tiene algo que alguien escribe, marca o deja a medias, ahora se lo guardas.
Haz que [lo que elijas: la partida empezada / las cartas marcadas como favoritas / la nota que escribe quien la usa] se guarde en localStorage y siga ahí al recargar.
Con tres condiciones: usa un nombre con versión, como "paradas-v1"; si no hay nada guardado, arranca con un valor por defecto en vez de romperse; y si lo guardado no se puede leer, que la página siga funcionando vacía.
Nada de nombres de personas ni datos que identifiquen a nadie, ni ahí ni en ningún sitio.
Si tu proyecto no tiene nada que alguien escriba, este paso se queda en PENDIENTE y no pasa nada. No le inventes una nota a una página que no la necesita.
Sin IA. La hoja que se queda pegada al centro de mando: la de la partida a medias, la de quién lo probó y qué dijo. Quien lo usa escribe ahí y lo que escribió sigue estando la próxima vez. Es la misma idea, y es anterior a las computadoras.
6. Las tres pruebas
Ninguna lleva más de un minuto, y cada una encuentra una avería distinta.
- Recargar. Lo que escribiste, ¿sigue? Si no, la memoria no está guardando: está en la pantalla y nada más.
- Empezar de cero. Abre tu página en otro navegador, o en una ventana privada. Así la ve alguien que llega por primera vez. ¿Se ve entera, o se ve rota porque esperaba encontrar algo guardado?
- Con el wifi apagado, en otra computadora. La prueba de siempre, y ahora cuenta doble: si tus datos se fueran a buscar fuera, aquí es donde la página aparece vacía. Si está entera, los datos están dentro, que es donde tenían que estar.
Ejemplo:
La 1 pasó. La 2 salió en blanco: la página daba por hecho que ya había una partida guardada. Se lo dije y lo arregló con un valor por defecto. La 3 pasó.
Sin IA. Dos: se lo das a alguien de tu casa sin explicarle nada y miras dónde se traba; y lo abres tú al día siguiente, a ver si la hoja de la partida sigue donde estaba y se entiende.
7. Las vueltas, y la entrega
Lo de siempre, y es donde la página se vuelve tuya: una corrección cada vez, probando entre una y otra. Las dos que casi siempre hacen falta:
- Los nombres de los campos. Léelos otra vez. ¿Dicen lo que son, o dicen lo que se te ocurrió a las once de la noche? Cambiarlos ahora cuesta un minuto; dentro de un mes, con la página llena, cuesta la tarde.
- El orden. Las cosas se enseñan en el orden en que están en la lista. ¿Es el orden que quieres, o es el orden en que se te fueron ocurriendo?
Entregas desde esta misma página, con el nombre de tu proyecto y tu código de mesa, nada tuyo. Y si la entrega te devuelve un aviso de que tu página carga algo de internet, léelo: no lo pusiste tú, lo puso la herramienta, y es exactamente lo que esta Unidad te está enseñando a ver.
Lo que llevas a la sala
La apertura de esta Unidad es el primer acto de la Unidad 10, «El montaje», en la semana 13: diez minutos, un elemento añadido en una sola línea.
Tu centro de mando, abierto, con una sola cosa que enseñar: añadir un elemento nuevo delante de todos, en una línea, y que aparezca.
Diez segundos. Si funciona, entendiste la Unidad entera, y lo que viene después —que tu proyecto crezca sin que tengas que reconstruirlo— ya está resuelto.