es6 语法学习 - 备忘录模式

es6 语法学习 - 备忘录模式

一、基本概念

备忘录设计模式（Memento Design Pattern）是一种行为型设计模式，它允许在不破坏对象封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态，以便之后恢复对象为先前的状态。

二、 优点

• 状态恢复：可以方便地保存和恢复对象的状态。
• 信息封装性：备忘录仅对发起人公开状态信息。

三、缺点

• 内存消耗：如果保存的状态过多，可能会占用大量内存。
• 复杂性：需要管理多个备忘录的对象会增加复杂性，尤其是在需要频繁状态更改的情况下。
• 只支持单一对象：备忘录模式主要用于单个对象的状态管理，不适合分布式系统或多个对象之间的状态管理。

四、使用场景

• 需要保存和恢复对象的内部状态，以便在后续操作中使用。
• 需要在不破坏对象封装性的前提下，获取对象的状态快照。
• 需要提供撤销操作的功能。

五、示例代码

以下是一个使用 JavaScript ES6 语法实现的备忘录设计模式的简单示例：

// Memento 类，
class Memento {
  constructor(state) {
    this.state = state; // 储存被保存的状态
  }
}

// Originator 类，代表需要保存和恢复状态的对象
class Originator {
  constructor() {
    this.state = '';
  }

  setState(state) {
    console.log(`Setting state to: ${state}`);
    this.state = state; // 设置当前状态
  }

  getState() {
    return this.state; // 获取当前状态
  }

  saveToMemento() {
    return new Memento(this.state); // 创建并返回一个备忘录
  }

  restoreFromMemento(memento) {
    this.state = memento.state; // 恢复状态
    console.log(`Restored state to: ${this.state}`);
  }
}

// Caretaker 类，负责管理备忘录的对象
class Caretaker {
  constructor() {
    this.mementos = []; // 存储多个备忘录
  }

  addMemento(memento) {
    this.mementos.push(memento); // 添加备忘录
  }

  getMemento(index) {
    return this.mementos[index]; // 根据索引获取备忘录
  }
}

// 示例使用
const originator = new Originator(); // 创建 Originator 实例
const caretaker = new Caretaker(); // 创建 Caretaker 实例
// 设置并保存状态
originator.setState('State1');
caretaker.addMemento(originator.saveToMemento()); // 保存状态到备忘录
originator.setState('State2');
caretaker.addMemento(originator.saveToMemento()); // 保存新的状态
originator.setState('State3'); // 设置另一个状态
console.log(`Current State: ${originator.getState()}`); // 打印当前状态: State3
// 恢复到之前的状态
originator.restoreFromMemento(caretaker.getMemento(0)); // 恢复到State1
console.log(`Current State: ${originator.getState()}`); // 打印当前状态: State1
originator.restoreFromMemento(caretaker.getMemento(1)); // 恢复到State2
console.log(`Current State: ${originator.getState()}`); // 打印当前状态: State2

这个示例展示了如何使用备忘录模式来捕获和保存对象的状态，并在需要时恢复该状态。通过这种方式，可以在不破坏对象封装性的前提下，实现对象的状态管理。