Memento pattern

Overview

The Memento pattern captures an object's internal state as a snapshot (memento) so it can be restored later, without exposing that state to other objects. The originator creates and restores mementos; a caretaker (history manager) stores them but cannot read or modify their contents.

Memento enables undo, checkpoints, versioning, and transactional rollback while preserving encapsulation. It is the snapshot-based alternative to Command's inverse operations, simpler to implement but more memory-hungry for large states.

When to use it

• Undo or rollback by restoring previous states.
• Checkpoints in games, editors, or wizards.
• State is complex to reverse operation by operation.

Where it shows up in interviews

Where it is used in real software

Key terms

Originator

Object whose state is saved.

Memento

Opaque snapshot of the state.

Caretaker

Stores mementos; never inspects them.

Incremental memento

Stores only changes to save memory.

How it works, step by step

1. 1
   Identify the state to save

   Only what is needed to restore.

2. 2
   Create an immutable memento type

   Opaque to outsiders.

3. 3
   Originator: save() and restore(m)

   Only it can read the memento.

4. 4
   Caretaker stores a history

   Stack or list, with a cap.

5. 5
   Restore on undo

   Pop and pass back to the originator.

Editor snapshots

Caretaker pushes a memento before each change

Each undo restores an exact previous state without the caretaker knowing how text is stored.

Implementation

1class EditorMemento {2  // Opaque: fields are private and readonly; only Editor uses them via the accessor below3  constructor(private readonly text: string, private readonly cursor: number) {}4  /** @internal */ restoreInto(apply: (text: string, cursor: number) => void) { apply(this.text, this.cursor); }5}6 7class Editor {8  private text = "";9  private cursor = 0;10  type(s: string) {11    this.text = this.text.slice(0, this.cursor) + s + this.text.slice(this.cursor);12    this.cursor += s.length;13  }14  save() { return new EditorMemento(this.text, this.cursor); }15  restore(m: EditorMemento) { m.restoreInto((t, c) => { this.text = t; this.cursor = c; }); }16  toString() { return this.text; }17}18 19class History {20  private stack: EditorMemento[] = [];21  constructor(private editor: Editor, private limit = 100) {}22  checkpoint() { this.stack.push(this.editor.save()); if (this.stack.length > this.limit) this.stack.shift(); }23  undo() { const m = this.stack.pop(); if (m) this.editor.restore(m); }24}25 26const editor = new Editor();27const history = new History(editor);28history.checkpoint(); editor.type("Hi");29history.checkpoint(); editor.type(" there");30history.undo(); // "Hi"

Complexity and performance

Trade-offs

Variants and related techniques

Common mistakes

• Mementos sharing mutable collections with the originator.

  Fix: Copy collections into the snapshot.

• Unbounded history.

  Fix: Limit size or compress older snapshots.

Interview questions

Practice problems