Published Apr 20, 2022
[
Consider someone visiting Dubai. They just need a way (i.e. visa) to enter Dubai. After arrival, they can come and visit any place in Dubai on their own without having to ask for permission or to do some leg work in order to visit any place here; just let them know of a place and they can visit it. Visitor pattern lets you do just that, it helps you add places to visit so that they can visit as much as they can without having to do any legwork.
Visitor pattern lets you add further operations to objects without having to modify them.
In object-oriented programming and software engineering, the visitor design pattern is a way of separating an algorithm from an object structure on which it operates. A practical result of this separation is the ability to add new operations to existing object structures without modifying those structures. It is one way to follow the open/closed principle.
Let’s take an example of a zoo simulation where we have several different kinds of animals and we have to make them Sound. Let’s translate this using visitor pattern
// visitee
interface Animal {
accept(operation: AnimalOperation)
}
// visitor
interface AnimalOperation {
visitMonkey(monkey: Monkey)
visitLion(lion: Lion)
visitDolphin(dolphin: Dolphin)
}
Then we have our implementations for the animals
// implementations for the animals
class Monkey implements Animal {
shout() {
console.log('Ooh oo aa aa!');
}
accept(operation: AnimalOperation) {
operation.visitMonkey(this)
}
}
class Lion implements Animal {
roar() {
console.log('Roaaar!');
}
accept(operation: AnimalOperation) {
operation.visitLion(this)
}
}
class Dolphin implements Animal {
speak() {
console.log('Tuut tuttu tuutt!!');
}
accept(operation: AnimalOperation) {
operation.visitDolphin(this)
}
}
Let’s implement our visitor
// visitor implementation
class Speak implements AnimalOperation {
visitMonkey(monkey: Monkey) {
monkey.shout()
}
visitLion(lion: Lion) {
lion.roar()
}
visitDolphin(dolphin: Dolphin) {
dolphin.speak()
}
}
And then it can be used as
const monkey = new Monkey();
const lion = new Lion();
const dolphin = new Dolphin();
const speak = new Speak();
monkey.accept(speak)
lion.accept(speak)
dolphin.accept(speak)
We could have done this simply by having an inheritance hierarchy for the animals but then we would have to modify the animals whenever we would have to add new actions to animals. But now we will not have to change them. For example, let’s say we are asked to add the jump behavior to the animals, we can simply add that by creating a new visitor i.e.
class Jump implements AnimalOperation {
visitMonkey(monkey: Monkey) {
console.log('Jumped 20 feet high! on to the tree')
}
visitLion(lion: Lion) {
console.log('Jumped 7 feet! Back on the groud!')
}
visitDolphin(dolphin: Dolphin) {
console.log('Walked on water a little and disappeared')
}
}
And for the usage
const jump = new Jump();
monkey.accept(speak)
monkey.accept(jump)
lion.accept(speak)
lion.accept(jump)