El carrito se actualiza solo: su estado vive en un modelo aparte del DOM y cada cambio llega a la pantalla. Pero el código que aplica esos cambios toca tres elementos a mano, y el HTML inicial muestra un estado que puede mentir. Hoy convertimos todo lo que se ve en una función del estado.
Vamos a convertir el código que pinta el carrito en una función:
dado el modelo, render genera todo el HTML de la vista, incluso la
primera pantalla. Al terminar podrás convertir la parte visual de tu
componente en una función de su estado, y verás qué queda por separar.
El resultado primero
Antes de abrir la función conviene ver qué hace. Así se inicializa
el carrito sobre el modelo del
capítulo anterior: un <div>
vacío en la página, una suscripción y una llamada inicial.
// extracto: requiere la clase `Carrito` del capítulo anterior, el array `productos`,
// las funciones `render` y `conectar` de más abajo y un `<div id="carrito-app">` vacío
const carrito = new Carrito();
const actualizar = () => {
render(carrito);
conectar(carrito);
};
carrito.suscribir(actualizar);
actualizar();
Con eso montado, pulsamos «Añadir» en los tres productos y después «Quitar» en la primera línea. Esto es lo que muestra la pantalla en cada momento:
al montar: 0 ítems / $0
tras 3 «Añadir»: 3 ítems / $250
tras quitar el primero: 2 ítems / $205
Las mismas cifras de siempre, con una diferencia: el primer 0 / $0
no está escrito en el HTML. Lo produjo render. La pantalla empieza
siendo una función del estado, no HTML que alguien escribió a mano
esperando acertar.
Lo que el suscriptor hacía a mano
En el capítulo anterior el suscriptor pintaba así: buscaba el
<span> del total, el del contador y la <ul> del carrito, y tocaba
los tres por separado. Poco código, sí, pero repartido elemento a
elemento, y con una trampa escondida en el propio HTML:
<h3>Tu carrito (<span id="contador">0</span>)</h3>
<ul id="carrito"></ul>
<p>Total: <span id="total">$0</span></p>
Ese 0 y ese $0 son estado escrito a mano en el HTML. Si nadie
se suscribe, la página se queda mostrándolos para siempre, como
vimos en los límites del capítulo anterior: el HTML miente con total
tranquilidad. Hay dos fuentes de verdad y una de ellas es texto que
nadie actualiza.
La vista
La refactorización cabe en una idea: todo lo que se ve sale de una función del modelo. El HTML de la página queda reducido a un contenedor vacío:
<div id="carrito-app"></div>
Y render genera todo el HTML, catálogo incluido:
// extracto: `productos` es el array del catálogo, ya visto
const host = document.querySelector("#carrito-app");
function render(modelo) {
host.innerHTML = `
<ul id="catalogo">
${productos.map((p) => `<li>${p.nombre} — $${p.precio} <button data-agregar="${p.id}">Añadir</button></li>`).join("")}
</ul>
<h3>Tu carrito (<span id="contador">${modelo.unidades}</span>)</h3>
<ul id="carrito">
${modelo.lineas.map((l) => `<li>${l.nombre} x${l.cantidad} — $${l.precio * l.cantidad} <button data-quitar="${l.linea}">Quitar</button></li>`).join("")}
</ul>
<p>Total: <span id="total">$${modelo.total}</span></p>`;
}
Tres cosas que cambian aquí. La primera: el HTML ya no guarda datos
escritos a mano que puedan mentir. El 0 y el $0 que antes vivían en
el HTML ahora salen de modelo.unidades y modelo.total. La segunda:
la vista entera está en un solo lugar. Si lo que se ve tiene una forma
rara, el sitio donde mirar es render; si algo raro pasa al pulsar, es
conectar. La tercera es sutil: los botones llevan atributos
data-agregar y data-quitar en lugar de nacer con su manejador
puesto, porque el HTML se compone como texto y los nodos todavía no
existen cuando lo escribimos.
El primer render
El programa del resultado primero tiene dos líneas que hacen todo el trabajo:
// extracto: el mismo programa del resultado primero
carrito.suscribir(actualizar);
actualizar();
La primera es la de siempre: cada notificación del modelo llama a
actualizar, que repinta la vista y vuelve a conectar los botones.
La segunda es la que faltaba: una llamada inicial, para que la primera
pantalla también la produzca render. Antes, el estado inicial lo
escribía el HTML a mano y la página solo se ponía al día cuando
llegaba la primera notificación; ahora la primera vista sale por el
mismo camino que todas las demás. La pantalla nunca muestra un estado
que el modelo no tenga.
pausa
Predice qué muestra la página antes de la primera notificación, y explica por qué ya no puede quedarse enseñando datos de mentira.
Los botones dentro del render
Cada repintado destruye los nodos y crea otros nuevos, así que hay
que volver a conectar los manejadores después de pintar. Para eso
sirven los data-* y la función conectar, la otra mitad de
actualizar:
// extracto: sigue a `render`; `host` es el mismo `<div id="carrito-app">`
function conectar(modelo) {
for (const b of host.querySelectorAll("[data-agregar]"))
b.addEventListener("click", () =>
modelo.agregar(productos.find((p) => p.id === Number(b.dataset.agregar))),
);
for (const b of host.querySelectorAll("[data-quitar]"))
b.addEventListener("click", () => modelo.quitar(Number(b.dataset.quitar)));
}
Es el mismo patrón que el suscriptor del capítulo anterior ya usaba
para sus «Quitar», ahora con nombre propio y aplicado a todos los
botones. Y funciona, pero mira quién decide qué pasa al pulsar: la
propia vista. Cada botón recién nacido llama a agregar o a quitar
del modelo directamente.
El patrón tiene una regla explícita sobre eso. Tania Rascia, en su tutorial de MVC, la deja en una sola línea: «the view never touches the model». La vista nunca toca el modelo; la nuestra lo toca en cada clic. Dave Stearns matiza la regla: en la variante moderna la vista sí captura los eventos de usuario, como hace la nuestra. Decidir qué se hace con ellos es otro trabajo, y es el paso que queda.
La pieza siguiente es el carrito de este capítulo funcionando, con un registro en vivo: cada notificación del modelo y el repintado que provoca. La línea fija sobre el registro recuerda que el render inicial no llegó por notificación.
El carrito del capítulo funcionando junto al registro del modelo: cada «Añadir» o «Quitar» produce una línea «notificación N → repintado: M u / $X» en el registro, la más nueva arriba. Resultado esperado: tres añadidos dejan tres notificaciones, contador 3 y total $250; quitar la primera línea deja $205. La línea fija sobre el registro recuerda el render inicial, que no llegó por notificación.
pausa
Explica qué tendría que cambiar para que la vista dejara de tocar el modelo: quién recibiría los clics y qué haría con ellos.
Los límites de este paso
La pantalla ya es una función del estado, pero esta vista paga un precio que conviene nombrar.
- Repinta también lo que no cambia. Cada notificación reescribe el catálogo entero, que nunca cambia, y recrea todos los nodos. Con tres productos no se nota; con una lista larga, sí.
- Los nodos se destruyen y recrean. Si una línea tuviera un campo de texto (el campo de cantidad que sigue fuera del arco), cada repintado borraría su contenido y le quitaría el foco mientras escribes.
- Los manejadores viven dentro de la vista y tocan el modelo a discreción. Funciona, pero es la separación que falta: quien decide qué pasa al pulsar no debería ser quien pinta.
innerHTMLinterpola datos sin escapar. Aquí los nombres son literales del catálogo y no pasa nada; con datos que vinieran del usuario, esta plantilla sería una puerta abierta.
El punto
El DOM ya no es fuente de verdad ni de HTML: todo lo que se ve
sale de render(modelo), desde el primer render. Lo que queda suelto
son los eventos: los clics entran por dentro de la vista y alcanzan el
modelo sin intermediario. ¿Quién traduce un «Añadir» en una acción, y
una acción en un cambio del modelo? Ese es el trabajo del controlador,
y es el siguiente capítulo.