Гость в коде, который всё меняет?

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

Что такое паттерн 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 имеет свои плюсы и минусы. Используйте его с умом, когда он действительно нужен!


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

Nikulux в Telegram

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

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