Arquetipo
Patrones de comportamientoUso: BajaComplejidad: Media

Memento

Recuerdo · Instantánea

Captura el estado interno de un objeto para poder restaurarlo más tarde, sin romper su encapsulamiento.

“Necesito guardar y restaurar el estado de un objeto sin exponer sus datos internos.”

workEl caso real

Un concesionario tiene un configurador web de autos: modelo, color, motor, paquete de equipamiento y accesorios. Cada elección cambia el precio y desactiva las opciones incompatibles. Los clientes quieren deshacer cambios y comparar dos configuraciones guardadas antes de pedir la cotización.

warningEl problema sin el patrón

Para guardar una versión, el historial copia los campos del configurador desde fuera, lo que obliga a hacerlos públicos. Así cualquier parte del código puede dejar el configurador en un estado inválido, como un motor eléctrico con caja manual.

check_circleCómo lo resuelve el patrón

El propio Configurador (el originador) crea un Memento con una instantánea de su estado y sabe restaurarse a partir de él. El Historial (el cuidador) guarda los mementos sin interpretarlos. El estado del configurador sigue siendo privado.

schemaDiagrama de clases

Diagrama interactivo: puedes acercar, mover el lienzo y pasar el cursor sobre cada clase para ver su detalle.

codeEl código, antes y después

cancelSin el patrónANTES
// El historial necesita que todo sea público
historial.push({ modelo: config.modelo, motor: config.motor, accesorios: config.accesorios });

config.motor = 'electrico'; // cualquiera puede saltarse las reglas
check_circleCon el patrónDESPUÉS
class Memento {                      // instantánea opaca para quien la guarda
  constructor(readonly estado: Readonly<EstadoConfig>, readonly fecha = new Date()) {}
}

class Configurador {                 // originador
  private estado: EstadoConfig = configuracionBase();

  elegirMotor(motor: Motor) { /* valida compatibilidad y recalcula el precio */ }

  guardar(): Memento { return new Memento(structuredClone(this.estado)); }
  restaurar(m: Memento) { this.estado = structuredClone(m.estado); }
}

class Historial {                    // cuidador: guarda, pero no interpreta
  private pila: Memento[] = [];
  constructor(private config: Configurador) {}

  guardar() { this.pila.push(this.config.guardar()); }
  deshacer() {
    const memento = this.pila.pop();
    if (memento) this.config.restaurar(memento);
  }
}

Ejemplos en TypeScript, simplificados para mostrar la idea: los tipos auxiliares (Pedido, Cliente…) se omiten.

lightbulb

Matiz importante

En lenguajes con clases anidadas privadas (Java, C#) el memento puede ser una clase interna del originador, y nadie más puede leer su contenido. En TypeScript se aproxima marcando el estado como de solo lectura y no usándolo fuera del originador.

thumb_upCuándo usarlo

  • ✓Necesitas deshacer cambios, guardar versiones o puntos de restauración de un objeto.
  • ✓Quieres volver al estado anterior si una operación de varios pasos falla a mitad de camino.
  • ✓Copiar el estado desde fuera obligaría a exponer campos privados.

do_not_disturb_onCuándo no usarlo

  • ✕El estado es grande y se guarda muy a menudo: la memoria crece rápido (considera guardar solo los cambios).
  • ✕El estado incluye recursos que no se pueden copiar, como conexiones o archivos abiertos.
  • ✕Nadie se encarga de descartar los mementos que ya no sirven: el cuidador debe controlar cuántos guarda y cuándo los borra, o el historial crecerá sin límite.

memoryPrincipios en juego

  • •Encapsulamiento: el estado se guarda y se restaura sin exponerlo.
  • •Responsabilidad única: el historial gestiona las versiones; el configurador, sus reglas.

hubPatrones relacionados

  • •Command: un comando puede guardar un memento antes de ejecutarse para poder deshacer.
  • •Prototype: en objetos simples, un clon puede funcionar como memento.
  • •Iterator: un memento puede guardar la posición de un recorrido.

quizPon a prueba lo que leíste

Dos preguntas al azar sobre este patrón. Cada vez que las cambias salen otras.

Más ejercicios →

code_blocksMemento en tu lenguaje

El mismo caso, implementado completo y de forma idiomática. Se puede copiar y ejecutar.

LO IDIOMÁTICO EN TYPESCRIPT: El estado vive en un campo privado # que nadie puede leer desde fuera. El memento expone el estado como Readonly y structuredClone hace la copia profunda al guardar y al restaurar.

memento.ts · 77 líneas
type Motor = 'gasolina' | 'hibrido' | 'electrico';
type Caja = 'manual' | 'automatica';

interface EstadoConfig {
  modelo: string;
  motor: Motor;
  caja: Caja;
  accesorios: string[];
  precio: number;
}

export class Memento {
  constructor(readonly estado: Readonly<EstadoConfig>, readonly etiqueta: string) {}
}

export class Configurador {
  #estado: EstadoConfig = { modelo: 'Sedán', motor: 'gasolina', caja: 'manual', accesorios: [], precio: 20000 };

  elegirMotor(motor: Motor): void {
    this.#estado.motor = motor;
    if (motor === 'electrico') this.#estado.caja = 'automatica'; // regla: no hay eléctricos manuales
    this.#recalcular();
  }

  agregarAccesorio(accesorio: string): void {
    this.#estado.accesorios.push(accesorio);
    this.#recalcular();
  }

  guardar(etiqueta: string): Memento {
    return new Memento(structuredClone(this.#estado), etiqueta);
  }

  restaurar(memento: Memento): void {
    this.#estado = structuredClone(memento.estado);
  }

  resumen(): string {
    const e = this.#estado;
    return `${e.modelo} ${e.motor}/${e.caja} [${e.accesorios.join(', ')}] ${e.precio} USD`;
  }

  #recalcular(): void {
    const recargo = { gasolina: 0, hibrido: 4000, electrico: 9000 }[this.#estado.motor];
    this.#estado.precio = 20000 + recargo + this.#estado.accesorios.length * 600;
  }
}

export class Historial {
  readonly #pila: Memento[] = [];
  constructor(private readonly config: Configurador) {}

  guardar(etiqueta: string): void {
    this.#pila.push(this.config.guardar(etiqueta));
  }

  deshacer(): string | undefined {
    const memento = this.#pila.pop();
    if (memento) this.config.restaurar(memento);
    return memento?.etiqueta;
  }
}

// ── Uso ──
const config = new Configurador();
const historial = new Historial(config);

historial.guardar('base');
config.elegirMotor('electrico');
historial.guardar('eléctrico');
config.agregarAccesorio('Techo solar');
console.log(config.resumen()); // Sedán electrico/automatica [Techo solar] 29600 USD

console.log('Volver a:', historial.deshacer());
console.log(config.resumen()); // Sedán electrico/automatica [] 29000 USD
console.log('Volver a:', historial.deshacer());
console.log(config.resumen()); // Sedán gasolina/manual [] 20000 USD
Ver los 23 patrones en TypeScript →