Arquetipo
Patrones estructuralesUso: MediaComplejidad: Media

Bridge

Puente

Desacopla una abstracción de su implementación para que ambas puedan variar de forma independiente.

“Tengo dos ejes que varían y las subclases se multiplican (M × N).”

workEl caso real

Tu sistema de gestión genera reportes de Ventas, Inventario y Cobranzas, y cada uno se puede exportar a PDF, a Excel o enviar como HTML por correo. Hay dos cosas que cambian por separado: qué reporte es (su contenido) y en qué formato se dibuja.

warningEl problema sin el patrón

Con herencia terminas con ReporteVentasPdf, ReporteVentasExcel, ReporteInventarioPdf... 3 reportes × 3 formatos = 9 clases. Un formato nuevo (CSV) obliga a crear 3 clases más, y un reporte nuevo, otras 3. El número de clases crece de forma multiplicativa (M × N).

check_circleCómo lo resuelve el patrón

Se separan dos jerarquías: la abstracción (Reporte y sus variantes) y la implementación (Renderizador: PDF, Excel, HTML). Cada reporte guarda una referencia a un renderizador y le delega cómo dibujar títulos y tablas. Ahora son 3 + 3 clases, y cada eje crece por su cuenta.

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 ReporteVentasPdf { /* consulta ventas + dibuja PDF */ }
class ReporteVentasExcel { /* consulta ventas + dibuja Excel */ }
class ReporteInventarioPdf { /* consulta inventario + dibuja PDF */ }
// ...9 clases, y cada formato nuevo suma 3 más
check_circleCon el patrónDESPUÉS
interface Renderizador {           // implementación
  titulo(texto: string): void;
  tabla(filas: Fila[]): void;
  generar(): Buffer;
}

abstract class Reporte {            // abstracción
  constructor(protected readonly salida: Renderizador) {}
  abstract exportar(): Buffer;
}

class ReporteVentas extends Reporte {
  exportar() {
    this.salida.titulo('Ventas del mes');
    this.salida.tabla(consultarVentas());
    return this.salida.generar();
  }
}

// El usuario elige el formato; el reporte no cambia
new ReporteVentas(new RenderizadorExcel()).exportar();

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

lightbulb

Matiz importante

En Bridge, "implementación" no significa "la clase que implementa una interfaz". Se refiere a la jerarquía de bajo nivel que hace el trabajo dependiente de la plataforma (aquí, dibujar en PDF o Excel). La "abstracción" es la capa de alto nivel que usa el cliente (el reporte).

thumb_upCuándo usarlo

  • ✓Una clase varía en dos o más dimensiones independientes y la herencia multiplica las subclases.
  • ✓Quieres cambiar la implementación en tiempo de ejecución (por ejemplo, el formato que elige el usuario).

do_not_disturb_onCuándo no usarlo

  • ✕Solo hay una dimensión de variación: basta con una interfaz y sus implementaciones.
  • ✕Las dos jerarquías siempre cambian juntas: separarlas no aporta nada.

memoryPrincipios en juego

  • •Composición sobre herencia: el reporte tiene un renderizador en vez de heredar de él.
  • •Abierto/Cerrado: añades un reporte o un formato sin tocar el otro eje.

hubPatrones relacionados

  • •Adapter: hace compatibles clases que ya existen; Bridge se diseña de antemano.
  • •Strategy: estructura parecida; Bridge separa dos jerarquías completas, Strategy intercambia un algoritmo.
  • •Abstract Factory: puede crear las combinaciones correctas de abstracción e implementación.

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_blocksBridge en tu lenguaje

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

LO IDIOMÁTICO EN TYPESCRIPT: La "implementación" es una interfaz y la "abstracción" una clase abstracta que la recibe por constructor con protected readonly (parameter properties). Para que el ejemplo se pueda ejecutar, los formatos son Markdown y CSV; en producción serían PDF o Excel.

bridge.ts · 55 líneas
export type Fila = Record<string, string | number>;

export interface Renderizador {
  titulo(texto: string): void;
  tabla(filas: Fila[]): void;
  generar(): string;
}

class RenderizadorMarkdown implements Renderizador {
  #lineas: string[] = [];
  titulo(texto: string) { this.#lineas.push(`# ${texto}`); }
  tabla(filas: Fila[]) {
    const columnas = Object.keys(filas[0] ?? {});
    this.#lineas.push(
      `| ${columnas.join(' | ')} |`,
      ...filas.map((f) => `| ${columnas.map((c) => f[c]).join(' | ')} |`),
    );
  }
  generar() { return this.#lineas.join('\n'); }
}

class RenderizadorCsv implements Renderizador {
  #lineas: string[] = [];
  titulo() { /* un CSV no tiene título */ }
  tabla(filas: Fila[]) {
    const columnas = Object.keys(filas[0] ?? {});
    this.#lineas.push(columnas.join(','), ...filas.map((f) => columnas.map((c) => f[c]).join(',')));
  }
  generar() { return this.#lineas.join('\n'); }
}

export abstract class Reporte {
  constructor(protected readonly salida: Renderizador) {}
  abstract exportar(): string;
}

export class ReporteVentas extends Reporte {
  exportar() {
    this.salida.titulo('Ventas de noviembre');
    this.salida.tabla([{ producto: 'Teclado', unidades: 12 }, { producto: 'Monitor', unidades: 4 }]);
    return this.salida.generar();
  }
}

export class ReporteInventario extends Reporte {
  exportar() {
    this.salida.titulo('Inventario');
    this.salida.tabla([{ sku: 'TEC-01', stock: 30 }, { sku: 'MON-02', stock: 0 }]);
    return this.salida.generar();
  }
}

// ── Uso: cualquier reporte con cualquier formato ──
console.log(new ReporteVentas(new RenderizadorMarkdown()).exportar());
console.log(new ReporteInventario(new RenderizadorCsv()).exportar());
Ver los 23 patrones en TypeScript →