Patrón Composite

💡 Ver Caso Práctico: Ejemplo Práctico del Patrón Composite

Composite es un patrón de diseño estructural que permite componer objetos en estructuras de árbol y trabajar con esas estructuras como si fueran objetos individuales.

Propósito y Caso de Uso

Utiliza Composite cuando el modelo de tu dominio sea naturalmente jerárquico —árbol de categorías, sistema de archivos, menú de navegación con submenús— y necesites que el código cliente pueda operar sobre una hoja individual o sobre una rama completa sin distinguir casos con if.

Estructura del Patrón

1. Componente: Interfaz común para hojas y compuestos (ej. render(), getSize()).
2. Hoja (Leaf): Elemento sin hijos, implementa el comportamiento base.
3. Compuesto (Composite): Contiene una lista de componentes hijos (hojas u otros compuestos) y delega/agrega sus operaciones.

Flujo de Funcionamiento

1. Llamada uniforme: El cliente invoca el mismo método (ej. getSize()) sobre cualquier nodo, sin saber si es hoja o rama.
2. Delegación recursiva: Si el nodo es un Compuesto, recorre a sus hijos y agrega (suma, concatena) sus resultados.
3. Caso base: Si el nodo es una Hoja, devuelve directamente su propio valor.

Ejemplos de Implementación Reales

interface FileSystemNode {
  getSize(): number;
}
 
class FileLeaf implements FileSystemNode {
  constructor(private sizeKb: number) {}
  getSize(): number { return this.sizeKb; }
}
 
class FolderComposite implements FileSystemNode {
  private children: FileSystemNode[] = [];
 
  add(node: FileSystemNode): void {
    this.children.push(node);
  }
 
  getSize(): number {
    // Suma recursiva sin distinguir si el hijo es archivo o carpeta
    return this.children.reduce((total, child) => total + child.getSize(), 0);
  }
}
 
const images = new FolderComposite();
images.add(new FileLeaf(120));
images.add(new FileLeaf(340));
 
const project = new FolderComposite();
project.add(images);
project.add(new FileLeaf(15)); // README.md suelto
 
console.log(project.getSize()); // 475 — mismo método, distintos niveles

Cuándo NO usarlo

Si tu modelo de datos no es realmente jerárquico (una lista plana sin anidamiento), Composite añade una abstracción innecesaria (YAGNIGlosarioYAGNI (You Aren't Gonna Need It)Principio de Extreme Programming (XP) que establece que un programador no debe añadir funcionalidad hasta que sea estrictamente necesario. Su objetivo es evitar la sobre-ingeniería (over-engineering), previniendo código para funcionalidades hipotéticas.Ver término completo →).