Tags

  • AWS (7)
  • Apigee (3)
  • ArchLinux (5)
  • Array (6)
  • Backtracking (6)
  • BinarySearch (6)
  • C++ (19)
  • CI&CD (3)
  • Calculus (2)
  • DesignPattern (43)
  • DisasterRecovery (1)
  • Docker (8)
  • DynamicProgramming (20)
  • FileSystem (11)
  • Frontend (2)
  • FunctionalProgramming (1)
  • GCP (1)
  • Gentoo (6)
  • Git (15)
  • Golang (1)
  • Graph (10)
  • GraphQL (1)
  • Hardware (1)
  • Hash (1)
  • Kafka (1)
  • LinkedList (13)
  • Linux (27)
  • Lodash (2)
  • MacOS (3)
  • Makefile (1)
  • Map (5)
  • MathHistory (1)
  • MySQL (21)
  • Neovim (10)
  • Network (66)
  • Nginx (6)
  • Node.js (33)
  • OpenGL (6)
  • PriorityQueue (1)
  • ProgrammingLanguage (9)
  • Python (10)
  • RealAnalysis (20)
  • Recursion (3)
  • Redis (1)
  • RegularExpression (1)
  • Ruby (19)
  • SQLite (1)
  • Sentry (3)
  • Set (4)
  • Shell (3)
  • SoftwareEngineering (12)
  • Sorting (2)
  • Stack (4)
  • String (2)
  • SystemDesign (13)
  • Terraform (2)
  • Tree (24)
  • Trie (2)
  • TwoPointers (16)
  • TypeScript (3)
  • Ubuntu (4)

    • Home

    [Behavioral] Memento

    Published Apr 18, 2022 [  DesignPattern  ]

    Real world example

    Take the example of calculator (i.e. originator), where whenever you perform some calculation the last calculation is saved in memory (i.e. memento) so that you can get back to it and maybe get it restored using some action buttons (i.e. caretaker).

    In plain words

    Memento pattern is about capturing and storing the current state of an object in a manner that it can be restored later on in a smooth manner.

    Wikipedia says

    The memento pattern is a software design pattern that provides the ability to restore an object to its previous state (undo via rollback).

    Programmatic Example

    Lets take an example of text editor which keeps saving the state from time to time and that you can restore if you want.

    First of all we have our memento object that will be able to hold the editor state

    class EditorMemento {
    protected content

    constructor(content: string) {
        this.content = content
    }

    getContent() {
        return this.content
    }
}

    Then we have our editor i.e. originator that is going to use memento object

    export class Editor {
    protected content: string = '';

    type(words: string) {
        this.content += words
    }

    getContent() {
        return this.content;
    }

    save() {
        return new EditorMemento(this.content)
    }

    restore(memento: EditorMemento) {
        this.content = memento.getContent()
    }
}

    And then it can be used as

    test('test memento design pattern', () => {
    const editor = new Editor();

    editor.type('first')
    expect(editor.getContent()).toEqual('first')
    editor.type('second')
    expect(editor.getContent()).toEqual('firstsecond')

    const saved = editor.save()

    editor.type('third')
    expect(editor.getContent()).toEqual('firstsecondthird')

    editor.restore(saved)
    expect(editor.getContent()).toEqual('firstsecond')
})

    References