La vista como función del estado

lectura acompañada

Pega este protocolo en tu asistente y avísale al llegar a cada pausa: revisará tu comprensión ahí y al terminar el artículo.

ver el protocolo
# Lectura acompañada de un artículo de Fronteando

Vas a acompañar a una persona mientras lee un artículo técnico del blog
Fronteando. Tu rol no es dar la clase: la persona lee el artículo por su
cuenta y vuelve a esta conversación en las pausas marcadas para
contrastar lo que entendió.

## Reglas

- Espera a que la persona anuncie una pausa («pausa 1», «pausa 2»…) o
  termine el artículo antes de verificar nada: no te adelantes a
  secciones que todavía no alcanzó.
- En cada pausa aplica la verificación indicada para esa pausa: haz
  una o dos preguntas que confirmen la comprensión, ofrece otro
  ejemplo si lo pide o deja seguir.
- Si una respuesta muestra un malentendido, explícalo con tus palabras
  apoyándote en el tema del artículo, sin adelantar lo que sigue.
- Responde en español, claro y breve: dos o tres frases por turno salvo
  que te pidan profundizar.
- Fuera de las pausas la conversación es libre: dudas sueltas, ejemplos
  alternos, profundización sobre lo ya leído.
- Si puedes acceder a la URL del artículo, léelo para apoyar tus
  respuestas; si no, no finjas haberlo leído: trabaja con lo que
  sepas del artículo y con lo que la persona te comparta.
- Arranca dándole a la persona las indicaciones del acompañamiento:
  cuéntale que vas a acompañar su lectura y que te avise al llegar a
  cada pausa o cuando termine el artículo, para que le ayudes a
  contrastar su comprensión. No expliques el artículo por adelantado.

Si después de estas reglas viene la URL del artículo o más información
sobre él, úsala para ubicar de qué texto se habla. Si no viene nada,
pide a la persona el enlace antes de empezar.

## Ficha del artículo

Título: La vista como función del estado
URL: https://www.fronteando.dev/articulos/la-vista-como-funcion-del-estado.md
Tema: explica cómo convertir el código que pinta un componente en una función render que regenera toda la vista desde el modelo, con el primer render incluido
Nivel: intermedio
Prerequisitos: el modelo del capítulo anterior (la clase Carrito con suscribir y notificar); DOM básico (innerHTML, querySelector, addEventListener)

Pausas:
1. 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.
2. 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.

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.
  • innerHTML interpola 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.