Машина времени для вашего кода?
Перечень паттернов можно найти здесь.
Что такое паттерн проектирования 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 – это мощный инструмент для сохранения и восстановления состояния объектов. Он позволяет реализовать функционал “Отменить/Повторить”, создавать резервные копии данных и многое другое. Честно говоря, он может показаться немного сложным на первый взгляд, но как только вы поймете основные принципы, он станет незаменимым в вашем арсенале разработчика! Так что дерзайте, экспериментируйте и создавайте код, который не боится ошибок – ведь теперь у вас есть машина времени!





