Машина времени для вашего кода?

Перечень паттернов можно найти здесь.

Что такое паттерн проектирования Memento?

Вы когда-нибудь жалели о том, что нажали кнопку “Сохранить”? Или мечтали вернуться на шаг назад, когда код начал вести себя совсем не так, как вы ожидали? Тогда паттерн проектирования Memento – это то, что вам нужно! Звучит сложновато, да? Не переживайте, сейчас всё разложим по полочкам.

Memento (от лат. memoria — память) позволяет сохранять и восстанавливать предыдущие состояния объекта, не нарушая инкапсуляцию. Проще говоря, это как кнопка “Отменить” в вашем любимом текстовом редакторе или графическом дизайнере. Но вместо простого сохранения файла, мы говорим о сохранении состояния самого объекта.


Зачем вообще нужен Memento?

Представьте себе сложный игровой процесс. Игрок совершает множество действий: перемещается, собирает предметы, сражается с монстрами… Если что-то пойдет не так (например, игрок случайно провалится сквозь текстуру), хочется иметь возможность вернуться к предыдущему состоянию игры. Или возьмем текстовый редактор – вы пишете важный документ и хотите иметь возможность отменить последние изменения.

Без Memento вам пришлось бы хранить полную историю всех изменений объекта, что может быть очень затратно по памяти и ресурсам. Memento же позволяет сохранять только значимые состояния, а не каждое мельчайшее изменение.


Как это работает?

В основе паттерна лежат три ключевых компонента:

  • Originator (Создатель): Объект, состояние которого мы хотим сохранить и восстановить.
  • Memento (Снимок): Объект, хранящий снимок состояния Originator’а в определенный момент времени. Важно! Memento не должен быть доступен извне – это нарушит инкапсуляцию.
  • Caretaker (Хранитель): Объект, отвечающий за хранение и управление Memento’ами. Он может добавлять новые снимки, получать предыдущие состояния и передавать их Originator’у для восстановления.

Позвольте объяснить: Originator создает Memento, содержащий его текущее состояние. Caretaker берет этот Memento на себя и сохраняет его. Когда нужно вернуться к предыдущему состоянию, Caretaker возвращает Memento Originator’у, который восстанавливает свое состояние из этого снимка.


Примеры кода: Давайте посмотрим, как это выглядит на практике!

Swift

class Editor {
    private var state: String = ""

    func setState(newState: String) {
        state = newState
    }

    func getState() -> String {
        return state
    }

    func createMemento() -> EditorMemento {
        return EditorMemento(state: state)
    }

    func restoreMemento(memento: EditorMemento) {
        state = memento.getState()
    }
}

class EditorMemento {
    private let state: String

    init(state: String) {
        self.state = state
    }

    func getState() -> String {
        return state
    }
}

Здесь Editor – наш Originator, EditorMemento – Memento, а Caretaker (в данном примере не реализован, но он бы хранил экземпляры EditorMemento). Видите, как состояние хранится в отдельном классе? Это важно для инкапсуляции.

Java

class Editor {
    private String state;

    public void setState(String state) {
        this.state = state;
    }

    public String getState() {
        return this.state;
    }

    public EditorMemento createMemento() {
        return new EditorMemento(this.state);
    }

    public void restoreMemento(EditorMemento memento) {
        this.state = memento.getState();
    }
}

class EditorMemento {
    private final String state;

    public EditorMemento(String state) {
        this.state = state;
    }

    public String getState() {
        return this.state;
    }
}

Похоже на Swift, правда? Принципы те же – Originator создает Memento, хранящий состояние, а Caretaker управляет этими снимками.

JavaScript

class Editor {
  constructor() {
    this.state = "";
  }

  setState(newState) {
    this.state = newState;
  }

  getState() {
    return this.state;
  }

  createMemento() {
    return new EditorMemento(this.state);
  }

  restoreMemento(memento) {
    this.state = memento.getState();
  }
}

class EditorMemento {
  constructor(state) {
    this.state = state;
  }

  getState() {
    return this.state;
  }
}

JavaScript-версия тоже следует той же логике. Обратите внимание, что в JavaScript мы используем классы и конструкторы для создания объектов.

Python

class Editor:
    def __init__(self):
        self.state = ""

    def set_state(self, new_state):
        self.state = new_state

    def get_state(self):
        return self.state

    def create_memento(self):
        return EditorMemento(self.state)

    def restore_memento(self, memento):
        self.state = memento.get_state()


class EditorMemento:
    def __init__(self, state):
        self.state = state

    def get_state(self):
        return self.state

В Python мы используем методы __init__ для инициализации объектов и self для доступа к атрибутам класса. Логика остается прежней – Originator создает Memento, хранящий состояние.


А вы знали?

Паттерн Memento часто используется в реализации функционала “Отменить/Повторить”. Caretaker может хранить список Memento’ов, позволяя пользователю перемещаться по истории изменений объекта.


Подводные камни и что стоит помнить

  • Размер Memento: Если состояние Originator’а очень большое, Memento может занимать много памяти. Подумайте о том, чтобы сохранять только важные части состояния.
  • Инкапсуляция: Не позволяйте Caretaker’у напрямую изменять состояние Memento. Это нарушит инкапсуляцию и сделает ваш код менее гибким.

В заключение

Паттерн проектирования Memento – это мощный инструмент для сохранения и восстановления состояния объектов. Он позволяет реализовать функционал “Отменить/Повторить”, создавать резервные копии данных и многое другое. Честно говоря, он может показаться немного сложным на первый взгляд, но как только вы поймете основные принципы, он станет незаменимым в вашем арсенале разработчика! Так что дерзайте, экспериментируйте и создавайте код, который не боится ошибок – ведь теперь у вас есть машина времени!


Будет интересно

Nikulux в Telegram

Статьи, архивы материалов, скоро ещё и мемы

(= Подписаться =)