Arquetipo
Patrones estructuralesUso: AltaComplejidad: Media

Composite

Objeto compuesto · Árbol

Compone objetos en estructuras de árbol para representar jerarquías parte-todo, y permite tratar igual a los elementos individuales y a los grupos.

“Trabajo con árboles y quiero tratar igual a una hoja y a un grupo.”

workEl caso real

Recursos humanos necesita el costo mensual de planilla de cualquier parte de la empresa: un equipo, una gerencia o la compañía completa. Una gerencia contiene áreas, las áreas contienen equipos, y en cualquier nivel puede haber empleados directos.

warningEl problema sin el patrón

La función que calcula el costo pregunta en cada nivel si el elemento es un empleado o un área y recorre recursivamente con if/instanceof. El mismo recorrido se repite para contar personas, listar correos o calcular bonos.

check_circleCómo lo resuelve el patrón

Empleado (hoja) y Area (compuesto) implementan la misma interfaz, MiembroOrganizacion, con costoMensual(). El empleado devuelve su sueldo; el área suma el costo de sus miembros, sean personas u otras áreas. Quien pide el costo no necesita saber qué tiene delante.

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
function costo(nodo: Empleado | Area): number {
  if (nodo instanceof Empleado) return nodo.sueldo;
  let total = 0;
  for (const hijo of nodo.hijos) total += costo(hijo);
  return total; // y el mismo recorrido, copiado en cada reporte
}
check_circleCon el patrónDESPUÉS
interface MiembroOrganizacion {
  costoMensual(): number;
}

class Empleado implements MiembroOrganizacion {
  constructor(readonly nombre: string, private sueldo: number) {}
  costoMensual() { return this.sueldo; }
}

class Area implements MiembroOrganizacion {
  private miembros: MiembroOrganizacion[] = [];
  constructor(readonly nombre: string) {}

  agregar(m: MiembroOrganizacion) { this.miembros.push(m); return this; }
  costoMensual() {
    return this.miembros.reduce((total, m) => total + m.costoMensual(), 0);
  }
}

const tecnologia = new Area('Tecnología')
  .agregar(new Empleado('Ana', 5200))
  .agregar(new Area('Equipo Pagos').agregar(new Empleado('Luis', 4100)));
tecnologia.costoMensual(); // 9300

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

thumb_upCuándo usarlo

  • ✓Tus datos forman un árbol parte-todo: organigramas, menús, categorías, carpetas, paquetes de productos.
  • ✓Quieres que el cliente trate igual a un elemento individual y a un grupo.

do_not_disturb_onCuándo no usarlo

  • ✕La estructura no es jerárquica.
  • ✕Hojas y compuestos tienen operaciones muy distintas: forzar una interfaz común obliga a métodos que no aplican.

memoryPrincipios en juego

  • •Polimorfismo: la hoja y el compuesto responden al mismo mensaje.
  • •Abierto/Cerrado: un tipo de nodo nuevo (por ejemplo, un contratista) no cambia el código cliente.

hubPatrones relacionados

  • •Iterator: permite recorrer el árbol sin exponer su estructura.
  • •Visitor: permite añadir operaciones nuevas sobre todo el árbol.
  • •Decorator: también envuelve objetos con la misma interfaz, pero tiene un solo hijo y añade comportamiento.
  • •Chain of Responsibility: una petición puede subir desde una hoja hasta sus padres.

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

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

LO IDIOMÁTICO EN TYPESCRIPT: Hoja y compuesto comparten una interfaz. El compuesto suma con reduce y un generador recursivo (yield*) permite recorrer todo el árbol sin exponer cómo está guardado.

composite.ts · 39 líneas
export interface MiembroOrganizacion {
  readonly nombre: string;
  costoMensual(): number;
  personas(): Generator<Empleado>;
}

export class Empleado implements MiembroOrganizacion {
  constructor(readonly nombre: string, private readonly sueldo: number) {}

  costoMensual(): number { return this.sueldo; }
  *personas(): Generator<Empleado> { yield this; }
}

export class Area implements MiembroOrganizacion {
  readonly #miembros: MiembroOrganizacion[] = [];
  constructor(readonly nombre: string) {}

  agregar(...miembros: MiembroOrganizacion[]): this {
    this.#miembros.push(...miembros);
    return this;
  }

  costoMensual(): number {
    return this.#miembros.reduce((total, m) => total + m.costoMensual(), 0);
  }

  *personas(): Generator<Empleado> {
    for (const m of this.#miembros) yield* m.personas();
  }
}

// ── Uso ──
const tecnologia = new Area('Tecnología').agregar(
  new Empleado('Ana', 5200),
  new Area('Equipo Pagos').agregar(new Empleado('Luis', 4100), new Empleado('Marta', 3900)),
);

console.log(tecnologia.costoMensual());                        // 13200
console.log([...tecnologia.personas()].map((p) => p.nombre));  // [ 'Ana', 'Luis', 'Marta' ]
Ver los 23 patrones en TypeScript →