Memento

Memento is a behavioral design pattern that lets you save and restore the previous state of an object without revealing the details of its implementation.

The Memento design pattern is a behavioral pattern that allows you to capture and restore an object's internal state without exposing its implementation details.

This pattern is useful when you need to implement features like undo functionality or checkpoints in an application.

In JavaScript, you can implement the Memento pattern using a combination of classes and objects.

// Originator: Object whose state needs to be saved
class Editor {
  constructor(content = '') {
    this.content = content;
  }

  // Save the current state as a memento
  save() { return new Memento(this.content); }

  // Restore the state from a memento
  restore(memento) { this.content = memento.getContent(); }

  // Modifying the content
  setContent(content) { this.content = content; }

  getContent() { return this.content; }
}

// Memento: Holds the state of the Originator
class Memento {
  constructor(content) {
    this.content = content;
  }

  getContent() { return this.content; }
}

// Caretaker: Manages the mementos
class History {
  constructor() {
    this.states = [];
  }

  // Save a memento
  push(memento) { this.states.push(memento); }

  // Get the last saved memento
  pop() { return this.states.pop(); }
}

// Example usage
const editor = new Editor();

const history = new History();

// Modifying the content and saving the state
editor.setContent('State 1');
history.push(editor.save());

editor.setContent('State 2');
history.push(editor.save());

// Restoring to a previous state
editor.restore(history.pop());
console.log(editor.getContent()); // Output: State 2

editor.restore(history.pop());
console.log(editor.getContent()); // Output: State 1

In this example, the Editor class represents an object whose state we want to save and restore. The Memento class represents the saved state of the Editor. The History class acts as a caretaker, managing the collection of mementos.

When you run this code, you'll see that the Editor object can save its state at different points in time and restore it later, allowing you to implement undo functionality or other similar features.