Nuestro carrito ya separa dos cosas: el estado vive en un modelo que
notifica sus cambios y la vista se repinta entera con cada notificación.
Pero los botones que pinta render llaman al modelo directamente:
la vista decide qué pasa al pulsar. Un manejador en el contenedor
se lleva esa decisión: traduce cada clic en una acción sobre el modelo.
Vamos a sacar los manejadores de eventos de la vista a un controlador: los botones dejan de nombrar el método que llaman y pasan a declarar qué quiere el usuario. Al terminar tendrás el ciclo completo (evento → acción → modelo → notificación → vista) y las tres partes del patrón separadas.
El resultado primero
Antes de abrir el controlador conviene ver qué queda cuando se quita
conectar. Así se pone en marcha el carrito completo sobre el
modelo y la
vista de los capítulos
anteriores, con una sola diferencia: render pinta los botones con
data-accion, un cambio que se explica más abajo:
// extracto: requiere la clase `Carrito`, el array `productos`, la función
// `render` del capítulo anterior (con `data-accion`, más abajo), un
// `<div id="carrito-app">` vacío y `host` apuntando a ese `<div>`
const carrito = new Carrito();
carrito.suscribir(() => render(carrito));
host.addEventListener("click", (e) => {
const boton = e.target.closest("[data-accion]");
if (!boton) return;
const acciones = {
agregar: () =>
carrito.agregar(productos.find((p) => p.id === Number(boton.dataset.id))),
quitar: () => carrito.quitar(Number(boton.dataset.linea)),
};
acciones[boton.dataset.accion]?.();
});
render(carrito);
Con eso montado, pulsamos «Añadir» en los tres productos, «Quitar» en la primera línea y «Añadir» en «Teclado» otra vez. 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
tras otro «Añadir»: 3 ítems / $250
La última línea es la que importa: después de cuatro repintados, los
botones siguen respondiendo sin que nadie los haya vuelto a conectar.
conectar ya no existe.
Quién decide hoy
En el capítulo anterior
la vista tenía dos trabajos. render generaba
el HTML, y conectar recorría los botones recién nacidos para darles
su manejador: cada «Añadir» llamaba a carrito.agregar y cada
«Quitar» a carrito.quitar. Funcionaba, pero la decisión de qué pasa
al pulsar vivía dentro de la vista.
Eso es lo que la regla de Tania Rascia prohíbe en su
tutorial de MVC:
«the view never touches the model». Nuestra vista lo tocaba en cada
clic, y lo peor no
era la regla incumplida sino la acumulación: cada manejador nuevo que
nazca en conectar tendrá que aprender a llamar al modelo, y cada
repintado tendrá que volver a conectarlos.
De llamadas a intenciones
El primer cambio es en los botones. Dejan de llevar el nombre del
método que llaman (data-agregar, data-quitar) y pasan a declarar
qué quiere el usuario. En render, los dos botones de la plantilla
quedan así:
// extracto: dentro de `render`, en lugar de `data-agregar` y `data-quitar`
const botonAgregar = `<button data-accion="agregar" data-id="${p.id}">Añadir</button>`;
const botonQuitar = `<button data-accion="quitar" data-linea="${l.linea}">Quitar</button>`;
data-accion dice «qué» y data-id/data-linea dicen «sobre qué».
El botón sigue nombrando una acción, pero ya no sabe qué método la
cumple: esa correspondencia la decide quien interpreta la intención.
El controlador
El segundo cambio es quién escucha. En lugar de un manejador por
botón, uno solo sobre el host (el <div> que render llena pero no
recrea) traduce cada clic en la acción que declara:
// extracto: el manejador del resultado primero, de nuevo
host.addEventListener("click", (e) => {
const boton = e.target.closest("[data-accion]");
if (!boton) return;
const acciones = {
agregar: () =>
carrito.agregar(productos.find((p) => p.id === Number(boton.dataset.id))),
quitar: () => carrito.quitar(Number(boton.dataset.linea)),
};
acciones[boton.dataset.accion]?.();
});
Tres cosas que conviene mirar. La primera: el manejador vive sobre un
elemento que sobrevive a los repintados (render reescribe su
innerHTML pero no lo reemplaza), así que se conecta una sola vez y no
hace falta volver a conectarlo. La segunda: closest encuentra el
botón aunque el clic caiga en cualquier nodo interior, y dataset trae
los argumentos. La tercera: la tabla acciones es el único sitio del
programa que llama a los métodos que cambian el modelo; los botones solo
nombran intenciones.
Esa tabla es el controlador: la parte que recibe los eventos del
usuario y los convierte en operaciones del modelo. Dave Stearns
describe el controlador clásico con esa tarea y con la de conectar
modelo y vista, en su
tutorial de MVC. En
las variantes más recientes, dice, esa tarea pasa a la vista, que es la
que crea los elementos y está mejor situada para atender sus eventos.
Nuestro controlador recupera la tarea clásica sin pintar nada: el
manejador se apoya en el host, que sigue siendo de la vista, y la
tabla solo traduce.
pausa
Explica por qué el manejador del controlador no muere en los repintados
si los botones sí, y qué habría que cambiar si render reemplazara el
host entero.
El ciclo cerrado
Con el controlador en su sitio, el recorrido de un clic queda completo
y en una sola dirección: el usuario pulsa «Quitar» (evento), el
controlador lee data-accion y llama a carrito.quitar (acción), el
modelo quita la línea y notifica a sus suscriptores (notificación), y la
suscripción vuelve a llamar a render (vista). Nadie se salta el
orden: la vista no toca el modelo, el modelo no toca la vista, y los
eventos entran por una sola puerta.
A continuación, el carrito de este capítulo funcionando, con el registro en vivo: ahora cada línea cuenta el ciclo entero, del clic a la pantalla.
El carrito del capítulo funcionando junto al registro del modelo: cada «Añadir» o «Quitar» produce una línea «clic → acción X → notificación N → repintado: M u / $Y» en el registro, la más nueva arriba. Resultado esperado: tres añadidos dejan tres líneas, contador 3 y total $250; quitar la primera línea deja $205. La línea fija de arriba recuerda el render inicial, que no llegó por notificación.
pausa
Cuenta el recorrido completo de un clic en «Añadir»: desde el evento
hasta el <li> nuevo en pantalla, nombrando cada parte que toca.
Los límites de este paso
Las tres partes están separadas, pero hay cosas que esta separación no resuelve.
- El controlador conoce la forma del DOM. Lee
data-acciony los atributos querenderescribe: si la vista cambia los nombres, el controlador hay que tocarlo también. La frontera entre ambos es una convención, no un contrato. - El modelo acepta cualquier llamada externa.
agregaryquitarson públicos: nada impide que otro código (o la consola) los llame sin pasar por el controlador. La disciplina la ponemos nosotros, no el programa. - Un solo
renderlo repinta todo. Con una vista que cambia poco no se nota; con varias suscripciones y vistas parciales, cada notificación empieza a costar. Cuánto aguanta este diseño es la pregunta del último capítulo.
El punto
El carrito ya tiene sus tres partes separadas: el modelo guarda el estado y notifica, la vista es una función del estado, y el controlador traduce clics a acciones. Cada parte tiene ya su sitio, aunque la frontera entre ellas siga siendo una convención. La pregunta que queda es hasta dónde aguanta este MVC hecho a mano.