Гость в коде, который всё меняет?
Перечень паттернов можно найти здесь.
Что такое паттерн Visitor?
Вы когда-нибудь задумывались о том, как сделать ваш код более гибким и расширяемым, не переписывая его каждый раз, когда появляются новые требования? Представьте себе ситуацию: у вас есть сложная структура данных, например, дерево объектов. И вам нужно выполнять разные операции над разными типами узлов этого дерева – вычислять сумму значений, печатать информацию, проверять на ошибки… Кажется, что это потребует кучи if-ов и switch-ей? Вот тут-то и приходит на помощь паттерн проектирования Visitor.
По сути, Visitor позволяет добавлять новые операции к структуре данных без изменения самой структуры. Звучит как магия? Почти! Давайте разберемся, что это за зверь такой и как его приручить.
Зачем вообще нужен этот Visitor?
Представьте себе музей. В музее есть разные экспонаты – картины, скульптуры, вазы… И к каждому экспонату подходит экскурсовод, который рассказывает о нем по-разному. Экскурсовод – это и есть наш Visitor! Он “посещает” каждый экспонат (узел структуры данных) и выполняет определенную операцию над ним.
Если в музей пришел новый экспонат, нам не нужно переделывать всех экскурсоводов. Мы просто добавляем нового экскурсовода, который знает, как рассказывать о новом экспонате. То же самое происходит и с Visitor: мы добавляем новые классы-посетители, чтобы выполнять новые операции над структурой данных, не трогая саму структуру.
Как это работает? Основные компоненты
В основе паттерна лежат два ключевых элемента:
- Element: Интерфейс или абстрактный класс, представляющий элементы структуры данных (например, узлы дерева). Он предоставляет метод
accept(), который принимает Visitor в качестве аргумента. - Visitor: Интерфейс или абстрактный класс, определяющий операции, которые можно выполнять над элементами структуры данных. Для каждого типа Element он должен иметь свой метод
visit().
Позвольте объяснить: Element “принимает” Visitor и делегирует ему выполнение операции. Visitor знает, как обрабатывать каждый конкретный тип Element.
Swift – элегантность в действии
В Swift это может выглядеть примерно так:
protocol Visitable {
func accept(visitor: Visitor)
}
protocol Visitor {
func visit(element: ConcreteElementA)
func visit(element: ConcreteElementB)
}
class ConcreteElementA: Visitable {
func accept(visitor: Visitor) {
visitor.visit(element: self)
}
}
class ConcreteElementB: Visitable {
func accept(visitor: Visitor) {
visitor.visit(element: self)
}
}
class ConcreteVisitor1: Visitor {
func visit(element: ConcreteElementA) {
print("ConcreteVisitor1 посетил ConcreteElementA")
}
func visit(element: ConcreteElementB) {
print("ConcreteVisitor1 посетил ConcreteElementB")
}
}
Здесь Visitable – наш интерфейс для элементов, а Visitor – для посетителей. Обратите внимание на метод accept() в ConcreteElementA и ConcreteElementB. Он вызывает соответствующий метод visit() у переданного Visitor.
Java – классика жанра
В Java реализация будет похожей:
interface Visitable {
void accept(Visitor visitor);
}
interface Visitor {
void visit(ConcreteElementA element);
void visit(ConcreteElementB element);
}
class ConcreteElementA implements Visitable {
@Override
public void accept(Visitor visitor) {
visitor.visit(this);
}
}
class ConcreteElementB implements Visitable {
@Override
public void accept(Visitor visitor) {
visitor.visit(this);
}
}
class ConcreteVisitor1 implements Visitor {
@Override
public void visit(ConcreteElementA element) {
System.out.println("ConcreteVisitor1 посетил ConcreteElementA");
}
@Override
public void visit(ConcreteElementB element) {
System.out.println("ConcreteVisitor1 посетил ConcreteElementB");
}
}
В Java мы используем интерфейсы и реализацию @Override для четкого определения поведения. Принцип тот же: элементы принимают посетителей, а посетители выполняют операции над элементами.
JavaScript – динамика и гибкость
JavaScript позволяет реализовать Visitor более свободно:
class Visitable {
accept(visitor) {
visitor.visit(this);
}
}
class ConcreteElementA extends Visitable {}
class ConcreteElementB extends Visitable {}
class Visitor {
visit(element) {
if (element instanceof ConcreteElementA) {
console.log("Visitor посетил ConcreteElementA");
} else if (element instanceof ConcreteElementB) {
console.log("Visitor посетил ConcreteElementB");
}
}
}
const visitor = new Visitor();
const elementA = new ConcreteElementA();
const elementB = new ConcreteElementB();
elementA.accept(visitor); // Visitor посетил ConcreteElementA
elementB.accept(visitor); // Visitor посетил ConcreteElementB
В JavaScript мы можем использовать instanceof для определения типа элемента и выполнения соответствующей операции. Это делает код более динамичным, но может быть менее типобезопасным.
Python – лаконичность и читаемость
Python предлагает элегантный способ реализации Visitor:
class Visitable:
def accept(self, visitor):
visitor.visit(self)
class ConcreteElementA(Visitable):
pass
class ConcreteElementB(Visitable):
pass
class Visitor:
def visit(self, element):
if isinstance(element, ConcreteElementA):
print("Visitor посетил ConcreteElementA")
elif isinstance(element, ConcreteElementB):
print("Visitor посетил ConcreteElementB")
visitor = Visitor()
element_a = ConcreteElementA()
element_b = ConcreteElementB()
element_a.accept(visitor) # Visitor посетил ConcreteElementA
element_b.accept(visitor) # Visitor посетил ConcreteElementB
Python позволяет легко определять классы и методы, делая код кратким и читаемым. Использование isinstance для проверки типа элемента также является распространенной практикой.
Когда стоит использовать Visitor?
- Когда вам нужно выполнять разные операции над разными типами объектов структуры данных.
- Когда вы хотите избежать добавления новых методов в классы элементов структуры данных.
- Когда структура данных стабильна, а операции могут часто меняться.
А знаете что? Visitor – это не серебряная пуля! Если у вас небольшая структура данных и немного операций, то использование Visitor может быть излишним. В этом случае проще добавить несколько if-ов или switch-ей.
В заключение: Гость в коде или лишний шум?
Паттерн проектирования Visitor – мощный инструмент для создания гибкого и расширяемого кода. Он позволяет добавлять новые операции к структуре данных без изменения самой структуры, что делает ваш код более устойчивым к изменениям. Но помните, что как и любой другой паттерн, Visitor имеет свои плюсы и минусы. Используйте его с умом, когда он действительно нужен!





