Arquetipo
Patrones de comportamientoUso: BajaComplejidad: Alta

Visitor

Visitante · Doble despacho

Permite añadir operaciones nuevas a una jerarquía de clases sin modificarlas, separando las operaciones de los objetos sobre los que actúan.

“Quiero añadir operaciones nuevas a una jerarquía sin modificar sus clases.”

workEl caso real

Tu tienda vende productos físicos, digitales (libros electrónicos y cursos) y suscripciones. Sobre el carrito necesitas varias operaciones que tratan distinto a cada tipo: calcular impuestos, calcular el costo de envío (los digitales no pagan envío) y exportar la venta a contabilidad. Contabilidad y el área tributaria piden operaciones nuevas cada pocos meses.

warningEl problema sin el patrón

Cada operación nueva añade un método a las tres clases de producto: calcularImpuesto(), costoEnvio(), exportarContable()... Las entidades se llenan de lógica que no les corresponde, o la operación se escribe con if (producto instanceof ...) repetidos por todo el código.

check_circleCómo lo resuelve el patrón

Cada operación es un visitante con un método por tipo de producto (visitarFisico, visitarDigital, visitarSuscripcion). Los productos solo implementan aceptar(visitante), que llama al método correcto (doble despacho). Una operación nueva es un visitante nuevo, y los productos no cambian.

schemaDiagrama de clases

Diagrama interactivo: puedes acercar, mover el lienzo y pasar el cursor sobre cada clase para ver su detalle.

codeEl código, antes y después

cancelSin el patrónANTES
class ProductoFisico {
  calcularImpuesto() { /* ... */ }
  costoEnvio() { /* ... */ }
  exportarContable() { /* ... */ } // cada operación nueva toca las tres clases
}
check_circleCon el patrónDESPUÉS
interface VisitanteProducto<R> {
  visitarFisico(p: ProductoFisico): R;
  visitarDigital(p: ProductoDigital): R;
  visitarSuscripcion(p: Suscripcion): R;
}

interface Producto {
  aceptar<R>(v: VisitanteProducto<R>): R;
}

class ProductoFisico implements Producto {
  constructor(readonly precio: number, readonly pesoKg: number) {}
  aceptar<R>(v: VisitanteProducto<R>) { return v.visitarFisico(this); } // doble despacho
}

class CostoEnvio implements VisitanteProducto<number> {
  visitarFisico(p: ProductoFisico) { return p.pesoKg * 4.5; }
  visitarDigital() { return 0; }
  visitarSuscripcion() { return 0; }
}

const envio = carrito.items.reduce((total, item) => total + item.aceptar(new CostoEnvio()), 0);

Ejemplos en TypeScript, simplificados para mostrar la idea: los tipos auxiliares (Pedido, Cliente…) se omiten.

lightbulb

Matiz importante

En lenguajes con uniones discriminadas y pattern matching exhaustivo (TypeScript, Rust, Kotlin, C# moderno) muchas veces se reemplaza Visitor por un switch sobre el tipo de producto: el compilador avisa si falta un caso y no hace falta el doble despacho.

thumb_upCuándo usarlo

  • ✓La jerarquía de clases es estable, pero las operaciones sobre ella cambian a menudo.
  • ✓Recorres estructuras con elementos de distinto tipo (árboles de sintaxis, documentos, carritos) aplicando una lógica distinta a cada uno.
  • ✓Quieres calcular algo mientras recorres una estructura (totales, estadísticas): el visitante puede ir acumulando resultados en su propio estado.

do_not_disturb_onCuándo no usarlo

  • ✕Añades tipos nuevos a menudo: cada tipo obliga a modificar todos los visitantes.
  • ✕Los visitantes necesitan datos privados de las clases: tendrías que exponerlos.

memoryPrincipios en juego

  • •Responsabilidad única: cada operación vive en su visitante, no en las entidades.
  • •Abierto/Cerrado para operaciones: añades operaciones sin tocar los productos.

hubPatrones relacionados

  • •Composite: Visitor permite ejecutar una operación sobre todo un árbol Composite.
  • •Iterator: se combinan para recorrer una estructura y visitar cada elemento.
  • •Interpreter: los visitantes son una forma habitual de añadir operaciones a un árbol de expresiones.

quizPon a prueba lo que leíste

Dos preguntas al azar sobre este patrón. Cada vez que las cambias salen otras.

Más ejercicios →

code_blocksVisitor en tu lenguaje

El mismo caso, implementado completo y de forma idiomática. Se puede copiar y ejecutar.

LO IDIOMÁTICO EN TYPESCRIPT: El visitante es genérico en su resultado (VisitanteProducto<R>), así que el mismo aceptar sirve para visitantes que devuelven números o textos. Al final se muestra la alternativa más común en TypeScript: una unión discriminada con un switch que el compilador revisa por completo.

visitor.ts · 76 líneas
export interface VisitanteProducto<R> {
  visitarFisico(p: ProductoFisico): R;
  visitarDigital(p: ProductoDigital): R;
  visitarSuscripcion(p: Suscripcion): R;
}

export interface Producto {
  readonly nombre: string;
  aceptar<R>(visitante: VisitanteProducto<R>): R;
}

export class ProductoFisico implements Producto {
  constructor(readonly nombre: string, readonly precio: number, readonly pesoKg: number) {}
  aceptar<R>(v: VisitanteProducto<R>): R { return v.visitarFisico(this); } // doble despacho
}

export class ProductoDigital implements Producto {
  constructor(readonly nombre: string, readonly precio: number) {}
  aceptar<R>(v: VisitanteProducto<R>): R { return v.visitarDigital(this); }
}

export class Suscripcion implements Producto {
  constructor(readonly nombre: string, readonly precioMensual: number, readonly meses: number) {}
  aceptar<R>(v: VisitanteProducto<R>): R { return v.visitarSuscripcion(this); }
}

class CostoEnvio implements VisitanteProducto<number> {
  visitarFisico(p: ProductoFisico) { return p.pesoKg * 4.5; }
  visitarDigital() { return 0; }
  visitarSuscripcion() { return 0; }
}

class Impuestos implements VisitanteProducto<number> {
  visitarFisico(p: ProductoFisico) { return p.precio * 0.18; }
  visitarDigital(p: ProductoDigital) { return p.precio * 0.18; }
  visitarSuscripcion(p: Suscripcion) { return p.precioMensual * p.meses * 0.18; }
}

class ExportarContable implements VisitanteProducto<string> {
  visitarFisico(p: ProductoFisico) { return `MERCADERIA|${p.nombre}|${p.precio}`; }
  visitarDigital(p: ProductoDigital) { return `SERVICIO-DIGITAL|${p.nombre}|${p.precio}`; }
  visitarSuscripcion(p: Suscripcion) { return `SUSCRIPCION|${p.nombre}|${p.precioMensual * p.meses}`; }
}

// ── Uso ──
const carrito: Producto[] = [
  new ProductoFisico('Teclado', 100, 1.2),
  new ProductoDigital('Curso de patrones', 50),
  new Suscripcion('Plan Pro', 15, 12),
];

const sumar = (v: VisitanteProducto<number>) => carrito.reduce((total, p) => total + p.aceptar(v), 0);

console.log('Envío:', sumar(new CostoEnvio()).toFixed(2));     // 5.40
console.log('Impuestos:', sumar(new Impuestos()).toFixed(2));  // 59.40
console.log(carrito.map((p) => p.aceptar(new ExportarContable())));

// ── Alternativa idiomática en TypeScript: unión discriminada + switch exhaustivo ──
type ItemCarrito =
  | { tipo: 'fisico'; precio: number; pesoKg: number }
  | { tipo: 'digital'; precio: number }
  | { tipo: 'suscripcion'; precioMensual: number; meses: number };

function costoEnvio(item: ItemCarrito): number {
  switch (item.tipo) {
    case 'fisico': return item.pesoKg * 4.5;
    case 'digital':
    case 'suscripcion': return 0;
    default: {
      const sinCubrir: never = item; // error de compilación si falta un caso
      return sinCubrir;
    }
  }
}

console.log(costoEnvio({ tipo: 'fisico', precio: 100, pesoKg: 1.2 }).toFixed(2)); // 5.40
Ver los 23 patrones en TypeScript →