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
class ProductoFisico {
calcularImpuesto() { /* ... */ }
costoEnvio() { /* ... */ }
exportarContable() { /* ... */ } // cada operación nueva toca las tres clases
}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.
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.
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.
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.40LO IDIOMÁTICO EN C# / .NET: La sobrecarga de métodos hace natural el doble despacho: cada producto llama a visitante.Visitar(this) y el compilador elige la sobrecarga según su tipo. El visitante es genérico en su resultado. Al final, la alternativa moderna: una expresión switch con patrones de tipo.
IProducto[] carrito =
[
new ProductoFisico("Teclado", 100, 1.2m),
new ProductoDigital("Curso de patrones", 50),
new Suscripcion("Plan Pro", 15, 12),
];
Console.WriteLine($"Envío: {carrito.Sum(p => p.Aceptar(new CostoEnvio())):F2}"); // 5.40
Console.WriteLine($"Impuestos: {carrito.Sum(p => p.Aceptar(new Impuestos())):F2}"); // 59.40
foreach (var producto in carrito)
Console.WriteLine(ExportarContable(producto));
// Alternativa moderna: un switch con patrones de tipo, sin Aceptar ni Visitar
static string ExportarContable(IProducto producto) => producto switch
{
ProductoFisico p => $"MERCADERIA|{p.Nombre}|{p.Precio}",
ProductoDigital p => $"SERVICIO-DIGITAL|{p.Nombre}|{p.Precio}",
Suscripcion s => $"SUSCRIPCION|{s.Nombre}|{s.PrecioMensual * s.Meses}",
_ => throw new ArgumentOutOfRangeException(nameof(producto)),
};
public interface IVisitante<T>
{
T Visitar(ProductoFisico producto);
T Visitar(ProductoDigital producto);
T Visitar(Suscripcion producto);
}
public interface IProducto
{
T Aceptar<T>(IVisitante<T> visitante);
}
public record ProductoFisico(string Nombre, decimal Precio, decimal PesoKg) : IProducto
{
public T Aceptar<T>(IVisitante<T> visitante) => visitante.Visitar(this); // doble despacho
}
public record ProductoDigital(string Nombre, decimal Precio) : IProducto
{
public T Aceptar<T>(IVisitante<T> visitante) => visitante.Visitar(this);
}
public record Suscripcion(string Nombre, decimal PrecioMensual, int Meses) : IProducto
{
public T Aceptar<T>(IVisitante<T> visitante) => visitante.Visitar(this);
}
public class CostoEnvio : IVisitante<decimal>
{
public decimal Visitar(ProductoFisico producto) => producto.PesoKg * 4.5m;
public decimal Visitar(ProductoDigital producto) => 0;
public decimal Visitar(Suscripcion producto) => 0;
}
public class Impuestos : IVisitante<decimal>
{
public decimal Visitar(ProductoFisico producto) => producto.Precio * 0.18m;
public decimal Visitar(ProductoDigital producto) => producto.Precio * 0.18m;
public decimal Visitar(Suscripcion producto) => producto.PrecioMensual * producto.Meses * 0.18m;
}LO IDIOMÁTICO EN JAVA: Desde Java 21, las interfaces sealed y el switch con patrones sustituyen al Visitor clásico: cada operación es un método con un case por tipo de producto, y como la jerarquía está sellada, el compilador avisa si falta un caso. Ya no hacen falta los métodos aceptar ni el doble despacho.
void main() {
List<Producto> carrito = List.of(
new ProductoFisico("Teclado", 100, 1.2),
new ProductoDigital("Curso de patrones", 50),
new Suscripcion("Plan Pro", 15, 12));
IO.println(String.format(Locale.ROOT, "Envío: %.2f", carrito.stream().mapToDouble(Operaciones::costoEnvio).sum())); // 5.40
IO.println(String.format(Locale.ROOT, "Impuestos: %.2f", carrito.stream().mapToDouble(Operaciones::impuestos).sum())); // 59.40
carrito.forEach(p -> IO.println(Operaciones.exportarContable(p)));
}
sealed interface Producto permits ProductoFisico, ProductoDigital, Suscripcion {}
record ProductoFisico(String nombre, double precio, double pesoKg) implements Producto {}
record ProductoDigital(String nombre, double precio) implements Producto {}
record Suscripcion(String nombre, double precioMensual, int meses) implements Producto {}
final class Operaciones {
static double costoEnvio(Producto producto) {
return switch (producto) {
case ProductoFisico p -> p.pesoKg() * 4.5;
case ProductoDigital p -> 0;
case Suscripcion s -> 0;
};
}
static double impuestos(Producto producto) {
return switch (producto) {
case ProductoFisico p -> p.precio() * 0.18;
case ProductoDigital p -> p.precio() * 0.18;
case Suscripcion s -> s.precioMensual() * s.meses() * 0.18;
};
}
static String exportarContable(Producto producto) {
return switch (producto) {
case ProductoFisico(var nombre, var precio, var peso) -> "MERCADERIA|%s|%.0f".formatted(nombre, precio);
case ProductoDigital(var nombre, var precio) -> "SERVICIO-DIGITAL|%s|%.0f".formatted(nombre, precio);
case Suscripcion(var nombre, var mensual, var meses) -> "SUSCRIPCION|%s|%.0f".formatted(nombre, mensual * meses);
};
}
}LO IDIOMÁTICO EN JAVASCRIPT: Como JavaScript permite acceder a un método por su nombre, el doble despacho se resuelve con visitante[producto.tipo](producto). Los visitantes son objetos literales con un método por tipo, y una comprobación avisa si a un visitante le falta algún caso.
const TIPOS = ['fisico', 'digital', 'suscripcion'];
export function visitar(producto, visitante) {
const operacion = visitante[producto.tipo];
if (!operacion) throw new Error(`El visitante no sabe tratar productos de tipo "${producto.tipo}"`);
return operacion(producto);
}
const definirVisitante = (metodos) => {
const faltan = TIPOS.filter((tipo) => !(tipo in metodos));
if (faltan.length) throw new Error(`Falta tratar: ${faltan.join(', ')}`);
return Object.freeze(metodos);
};
const costoEnvio = definirVisitante({
fisico: (p) => p.pesoKg * 4.5,
digital: () => 0,
suscripcion: () => 0,
});
const impuestos = definirVisitante({
fisico: (p) => p.precio * 0.18,
digital: (p) => p.precio * 0.18,
suscripcion: (p) => p.precioMensual * p.meses * 0.18,
});
const exportarContable = definirVisitante({
fisico: (p) => `MERCADERIA|${p.nombre}|${p.precio}`,
digital: (p) => `SERVICIO-DIGITAL|${p.nombre}|${p.precio}`,
suscripcion: (p) => `SUSCRIPCION|${p.nombre}|${p.precioMensual * p.meses}`,
});
// ── Uso ──
const carrito = [
{ tipo: 'fisico', nombre: 'Teclado', precio: 100, pesoKg: 1.2 },
{ tipo: 'digital', nombre: 'Curso de patrones', precio: 50 },
{ tipo: 'suscripcion', nombre: 'Plan Pro', precioMensual: 15, meses: 12 },
];
const sumar = (visitante) => carrito.reduce((total, p) => total + visitar(p, visitante), 0);
console.log('Envío:', sumar(costoEnvio).toFixed(2)); // 5.40
console.log('Impuestos:', sumar(impuestos).toFixed(2)); // 59.40
console.log(carrito.map((p) => visitar(p, exportarContable)));
try {
definirVisitante({ fisico: () => 0 });
} catch (error) {
console.log(error.message); // Falta tratar: digital, suscripcion
}LO IDIOMÁTICO EN PYTHON: functools.singledispatch es el Visitor de Python: una función genérica elige la implementación según el tipo del argumento, sin métodos aceptar en los productos. Cada operación nueva es una función nueva y los productos (simples dataclass) no cambian.
from dataclasses import dataclass
from functools import singledispatch
@dataclass(frozen=True)
class ProductoFisico:
nombre: str
precio: float
peso_kg: float
@dataclass(frozen=True)
class ProductoDigital:
nombre: str
precio: float
@dataclass(frozen=True)
class Suscripcion:
nombre: str
precio_mensual: float
meses: int
Producto = ProductoFisico | ProductoDigital | Suscripcion
# ── Operación: costo de envío ──
@singledispatch
def costo_envio(producto: object) -> float:
raise TypeError(f"Tipo de producto no soportado: {type(producto).__name__}")
@costo_envio.register
def _(producto: ProductoFisico) -> float:
return producto.peso_kg * 4.5
@costo_envio.register
def _(producto: ProductoDigital | Suscripcion) -> float: # varios tipos con la misma lógica
return 0
# ── Operación: impuestos ──
@singledispatch
def impuestos(producto: object) -> float:
raise TypeError(f"Tipo de producto no soportado: {type(producto).__name__}")
@impuestos.register
def _(producto: ProductoFisico | ProductoDigital) -> float:
return producto.precio * 0.18
@impuestos.register
def _(producto: Suscripcion) -> float:
return producto.precio_mensual * producto.meses * 0.18
if __name__ == "__main__":
carrito: list[Producto] = [
ProductoFisico("Teclado", 100, 1.2),
ProductoDigital("Curso de patrones", 50),
Suscripcion("Plan Pro", 15, 12),
]
print(f"Envío: {sum(costo_envio(p) for p in carrito):.2f}") # 5.40
print(f"Impuestos: {sum(impuestos(p) for p in carrito):.2f}") # 59.40
# Con `match` también se puede despachar por tipo, todo en una función
for p in carrito:
match p:
case ProductoFisico(nombre=n, precio=precio):
print(f"MERCADERIA|{n}|{precio:g}")
case ProductoDigital(nombre=n, precio=precio):
print(f"SERVICIO-DIGITAL|{n}|{precio:g}")
case Suscripcion(nombre=n, precio_mensual=mensual, meses=meses):
print(f"SUSCRIPCION|{n}|{mensual * meses:g}")LO IDIOMÁTICO EN GO: En Go, el Visitor clásico (con Aceptar y doble despacho) casi siempre se sustituye por un "type switch": cada operación es una función con un case por tipo. La interfaz Producto es "sellada" con un método privado, así nadie fuera del paquete añade tipos. (La biblioteca estándar sí usa la forma clásica en go/ast, con ast.Visitor y ast.Walk.)
package main
import "fmt"
type Producto interface{ esProducto() }
type ProductoFisico struct {
Nombre string
Precio float64
PesoKg float64
}
type ProductoDigital struct {
Nombre string
Precio float64
}
type Suscripcion struct {
Nombre string
PrecioMensual float64
Meses int
}
func (ProductoFisico) esProducto() {}
func (ProductoDigital) esProducto() {}
func (Suscripcion) esProducto() {}
// ── Operación: costo de envío ──
func CostoEnvio(p Producto) float64 {
switch p := p.(type) {
case ProductoFisico:
return p.PesoKg * 4.5
case ProductoDigital, Suscripcion:
return 0
default:
panic(fmt.Sprintf("tipo de producto no soportado: %T", p))
}
}
// ── Operación: impuestos ──
func Impuestos(p Producto) float64 {
switch p := p.(type) {
case ProductoFisico:
return p.Precio * 0.18
case ProductoDigital:
return p.Precio * 0.18
case Suscripcion:
return p.PrecioMensual * float64(p.Meses) * 0.18
default:
panic(fmt.Sprintf("tipo de producto no soportado: %T", p))
}
}
// ── Operación: exportar a contabilidad ──
func ExportarContable(p Producto) string {
switch p := p.(type) {
case ProductoFisico:
return fmt.Sprintf("MERCADERIA|%s|%g", p.Nombre, p.Precio)
case ProductoDigital:
return fmt.Sprintf("SERVICIO-DIGITAL|%s|%g", p.Nombre, p.Precio)
case Suscripcion:
return fmt.Sprintf("SUSCRIPCION|%s|%g", p.Nombre, p.PrecioMensual*float64(p.Meses))
default:
panic(fmt.Sprintf("tipo de producto no soportado: %T", p))
}
}
func main() {
carrito := []Producto{
ProductoFisico{"Teclado", 100, 1.2},
ProductoDigital{"Curso de patrones", 50},
Suscripcion{"Plan Pro", 15, 12},
}
envio, impuestos := 0.0, 0.0
for _, p := range carrito {
envio += CostoEnvio(p)
impuestos += Impuestos(p)
}
fmt.Printf("Envío: %.2f\n", envio) // 5.40
fmt.Printf("Impuestos: %.2f\n", impuestos) // 59.40
for _, p := range carrito {
fmt.Println(ExportarContable(p))
}
}LO IDIOMÁTICO EN RUST: En Rust, una jerarquía cerrada de tipos es un enum, y cada operación es un match exhaustivo: si mañana se añade una variante, el compilador señala cada operación que no la trata. Por eso Visitor casi no se usa; la forma clásica aparece en librerías como syn (visitar código) o serde.
enum Producto {
Fisico {
nombre: &'static str,
precio: f64,
peso_kg: f64,
},
Digital {
nombre: &'static str,
precio: f64,
},
Suscripcion {
nombre: &'static str,
precio_mensual: f64,
meses: u32,
},
}
// ── Operación: costo de envío ──
fn costo_envio(producto: &Producto) -> f64 {
match producto {
Producto::Fisico { peso_kg, .. } => peso_kg * 4.5,
Producto::Digital { .. } | Producto::Suscripcion { .. } => 0.0,
}
}
// ── Operación: impuestos ──
fn impuestos(producto: &Producto) -> f64 {
match producto {
Producto::Fisico { precio, .. } | Producto::Digital { precio, .. } => precio * 0.18,
Producto::Suscripcion {
precio_mensual,
meses,
..
} => precio_mensual * f64::from(*meses) * 0.18,
}
}
// ── Operación: exportar a contabilidad ──
fn exportar_contable(producto: &Producto) -> String {
match producto {
Producto::Fisico { nombre, precio, .. } => format!("MERCADERIA|{nombre}|{precio}"),
Producto::Digital { nombre, precio } => format!("SERVICIO-DIGITAL|{nombre}|{precio}"),
Producto::Suscripcion {
nombre,
precio_mensual,
meses,
} => {
format!(
"SUSCRIPCION|{nombre}|{}",
precio_mensual * f64::from(*meses)
)
}
}
}
fn main() {
let carrito = [
Producto::Fisico {
nombre: "Teclado",
precio: 100.0,
peso_kg: 1.2,
},
Producto::Digital {
nombre: "Curso de patrones",
precio: 50.0,
},
Producto::Suscripcion {
nombre: "Plan Pro",
precio_mensual: 15.0,
meses: 12,
},
];
println!("Envío: {:.2}", carrito.iter().map(costo_envio).sum::<f64>()); // 5.40
println!(
"Impuestos: {:.2}",
carrito.iter().map(impuestos).sum::<f64>()
); // 59.40
for producto in &carrito {
println!("{}", exportar_contable(producto));
}
}LO IDIOMÁTICO EN PHP: PHP no tiene sobrecarga de métodos, así que el despacho por tipo se hace con match (true) e instanceof: cada operación es una función con un caso por tipo de producto. Los totales se calculan con el operador pipe |> de PHP 8.5, que encadena funciones de izquierda a derecha.
<?php
declare(strict_types=1);
final readonly class ProductoFisico { public function __construct(public string $nombre, public float $precio, public float $pesoKg) {} }
final readonly class ProductoDigital { public function __construct(public string $nombre, public float $precio) {} }
final readonly class Suscripcion { public function __construct(public string $nombre, public float $precioMensual, public int $meses) {} }
// ── Operación: costo de envío ──
function costoEnvio(object $producto): float
{
return match (true) {
$producto instanceof ProductoFisico => $producto->pesoKg * 4.5,
$producto instanceof ProductoDigital, $producto instanceof Suscripcion => 0.0,
default => throw new InvalidArgumentException('Producto no soportado: ' . $producto::class),
};
}
// ── Operación: impuestos ──
function impuestos(object $producto): float
{
return match (true) {
$producto instanceof ProductoFisico, $producto instanceof ProductoDigital => $producto->precio * 0.18,
$producto instanceof Suscripcion => $producto->precioMensual * $producto->meses * 0.18,
default => throw new InvalidArgumentException('Producto no soportado: ' . $producto::class),
};
}
// ── Operación: exportar a contabilidad ──
function exportarContable(object $producto): string
{
return match (true) {
$producto instanceof ProductoFisico => "MERCADERIA|{$producto->nombre}|{$producto->precio}",
$producto instanceof ProductoDigital => "SERVICIO-DIGITAL|{$producto->nombre}|{$producto->precio}",
$producto instanceof Suscripcion => "SUSCRIPCION|{$producto->nombre}|" . ($producto->precioMensual * $producto->meses),
default => throw new InvalidArgumentException('Producto no soportado: ' . $producto::class),
};
}
$carrito = [
new ProductoFisico('Teclado', 100, 1.2),
new ProductoDigital('Curso de patrones', 50),
new Suscripcion('Plan Pro', 15, 12),
];
$envio = array_map(costoEnvio(...), $carrito) |> array_sum(...);
$totalImpuestos = array_map(impuestos(...), $carrito) |> array_sum(...);
printf("Envío: %.2f\n", $envio); // 5.40
printf("Impuestos: %.2f\n", $totalImpuestos); // 59.40
echo implode("\n", array_map(exportarContable(...), $carrito)), "\n";