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
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
}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(); // 9300Ejemplos 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.
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.
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' ]LO IDIOMÁTICO EN C# / .NET: Hoja y compuesto implementan IMiembroOrganizacion. El compuesto suma con LINQ (Sum) y aplana el árbol con SelectMany; la hoja usa yield return, así que el recorrido es perezoso y no crea listas intermedias.
var tecnologia = new Area("Tecnología",
new Empleado("Ana", 5200),
new Area("Equipo Pagos", new Empleado("Luis", 4100), new Empleado("Marta", 3900)));
Console.WriteLine(tecnologia.CostoMensual()); // 13200
Console.WriteLine(string.Join(", ", tecnologia.Personas().Select(p => p.Nombre))); // Ana, Luis, Marta
public interface IMiembroOrganizacion
{
decimal CostoMensual();
IEnumerable<Empleado> Personas();
}
public record Empleado(string Nombre, decimal Sueldo) : IMiembroOrganizacion
{
public decimal CostoMensual() => Sueldo;
public IEnumerable<Empleado> Personas()
{
yield return this;
}
}
public class Area(string nombre, params IMiembroOrganizacion[] miembros) : IMiembroOrganizacion
{
private readonly List<IMiembroOrganizacion> _miembros = [.. miembros];
public string Nombre { get; } = nombre;
public void Agregar(IMiembroOrganizacion miembro) => _miembros.Add(miembro);
public decimal CostoMensual() => _miembros.Sum(m => m.CostoMensual());
public IEnumerable<Empleado> Personas() => _miembros.SelectMany(m => m.Personas());
}LO IDIOMÁTICO EN JAVA: La interfaz sealed limita los nodos del árbol a Empleado (hoja) y Area (compuesto). El compuesto suma con un Stream y aplana el árbol con flatMap, de forma recursiva y perezosa.
void main() {
var tecnologia = new Area("Tecnología",
new Empleado("Ana", 5200),
new Area("Equipo Pagos", new Empleado("Luis", 4100), new Empleado("Marta", 3900)));
IO.println(tecnologia.costoMensual()); // 13200
IO.println(tecnologia.personas().map(Empleado::nombre).toList()); // [Ana, Luis, Marta]
}
sealed interface MiembroOrganizacion permits Empleado, Area {
int costoMensual();
Stream<Empleado> personas();
}
record Empleado(String nombre, int sueldo) implements MiembroOrganizacion {
@Override public int costoMensual() { return sueldo; }
@Override public Stream<Empleado> personas() { return Stream.of(this); }
}
final class Area implements MiembroOrganizacion {
private final String nombre;
private final List<MiembroOrganizacion> miembros;
Area(String nombre, MiembroOrganizacion... miembros) {
this.nombre = nombre;
this.miembros = new ArrayList<>(List.of(miembros));
}
String nombre() { return nombre; }
void agregar(MiembroOrganizacion miembro) { miembros.add(miembro); }
@Override public int costoMensual() {
return miembros.stream().mapToInt(MiembroOrganizacion::costoMensual).sum();
}
@Override public Stream<Empleado> personas() {
return miembros.stream().flatMap(MiembroOrganizacion::personas);
}
}LO IDIOMÁTICO EN JAVASCRIPT: Hoja y compuesto tienen los mismos métodos (no hace falta declarar una interfaz). Además, ambos implementan [Symbol.iterator] con un generador, así que cualquier parte del árbol se puede recorrer con for...of o con el operador de propagación [...area].
export class Empleado {
constructor(nombre, sueldo) {
this.nombre = nombre;
this.sueldo = sueldo;
}
costoMensual() { return this.sueldo; }
*[Symbol.iterator]() { yield this; }
}
export class Area {
#miembros = [];
constructor(nombre) { this.nombre = nombre; }
agregar(...miembros) {
this.#miembros.push(...miembros);
return this;
}
costoMensual() {
return this.#miembros.reduce((total, m) => total + m.costoMensual(), 0);
}
*[Symbol.iterator]() {
for (const miembro of this.#miembros) yield* miembro;
}
}
// ── 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].map((p) => p.nombre)); // [ 'Ana', 'Luis', 'Marta' ]LO IDIOMÁTICO EN PYTHON: Hoja y compuesto cumplen el mismo Protocol. El compuesto suma con sum() sobre un generador y ambos implementan __iter__, así que cualquier parte del árbol se recorre con un simple for. yield from delega el recorrido en cada hijo.
from collections.abc import Iterator
from dataclasses import dataclass
from typing import Protocol
class MiembroOrganizacion(Protocol):
nombre: str
def costo_mensual(self) -> float: ...
def __iter__(self) -> Iterator["Empleado"]: ...
@dataclass
class Empleado:
nombre: str
sueldo: float
def costo_mensual(self) -> float:
return self.sueldo
def __iter__(self) -> Iterator["Empleado"]:
yield self
class Area:
def __init__(self, nombre: str, *miembros: MiembroOrganizacion) -> None:
self.nombre = nombre
self._miembros = list(miembros)
def agregar(self, miembro: MiembroOrganizacion) -> None:
self._miembros.append(miembro)
def costo_mensual(self) -> float:
return sum(m.costo_mensual() for m in self._miembros)
def __iter__(self) -> Iterator[Empleado]:
for miembro in self._miembros:
yield from miembro
if __name__ == "__main__":
tecnologia = Area(
"Tecnología",
Empleado("Ana", 5200),
Area("Equipo Pagos", Empleado("Luis", 4100), Empleado("Marta", 3900)),
)
print(tecnologia.costo_mensual()) # 13200
print([p.nombre for p in tecnologia]) # ['Ana', 'Luis', 'Marta']LO IDIOMÁTICO EN GO: La interfaz Miembro es implícita: empleados y áreas la cumplen sin declararlo. Para recorrer el árbol, cada miembro devuelve un iterador iter.Seq (Go 1.23), que se usa directamente con for range y se detiene si el bucle hace break.
package main
import (
"fmt"
"iter"
)
type Miembro interface {
CostoMensual() float64
Personas() iter.Seq[Empleado]
}
type Empleado struct {
Nombre string
Sueldo float64
}
func (e Empleado) CostoMensual() float64 { return e.Sueldo }
func (e Empleado) Personas() iter.Seq[Empleado] {
return func(yield func(Empleado) bool) { yield(e) }
}
type Area struct {
Nombre string
miembros []Miembro
}
func NuevaArea(nombre string, miembros ...Miembro) *Area {
return &Area{Nombre: nombre, miembros: miembros}
}
func (a *Area) CostoMensual() float64 {
total := 0.0
for _, m := range a.miembros {
total += m.CostoMensual()
}
return total
}
func (a *Area) Personas() iter.Seq[Empleado] {
return func(yield func(Empleado) bool) {
for _, m := range a.miembros {
for persona := range m.Personas() {
if !yield(persona) {
return
}
}
}
}
}
func main() {
tecnologia := NuevaArea("Tecnología",
Empleado{"Ana", 5200},
NuevaArea("Equipo Pagos", Empleado{"Luis", 4100}, Empleado{"Marta", 3900}),
)
fmt.Println(tecnologia.CostoMensual()) // 13200
for persona := range tecnologia.Personas() {
fmt.Println(persona.Nombre) // Ana, Luis, Marta
}
}LO IDIOMÁTICO EN RUST: En Rust, un árbol se modela de forma natural con un enum recursivo: cada nodo es una hoja o un compuesto, y match trata los dos casos. El recorrido devuelve un iterador perezoso (Box<dyn Iterator>) que se aplana de forma recursiva con flat_map.
enum Miembro {
Empleado {
nombre: String,
sueldo: u32,
},
Area {
nombre: String,
miembros: Vec<Miembro>,
},
}
impl Miembro {
fn empleado(nombre: &str, sueldo: u32) -> Self {
Self::Empleado {
nombre: nombre.to_string(),
sueldo,
}
}
fn area(nombre: &str, miembros: Vec<Miembro>) -> Self {
Self::Area {
nombre: nombre.to_string(),
miembros,
}
}
fn nombre(&self) -> &str {
match self {
Self::Empleado { nombre, .. } | Self::Area { nombre, .. } => nombre,
}
}
fn costo_mensual(&self) -> u32 {
match self {
Self::Empleado { sueldo, .. } => *sueldo,
Self::Area { miembros, .. } => miembros.iter().map(Miembro::costo_mensual).sum(),
}
}
fn personas(&self) -> Box<dyn Iterator<Item = &str> + '_> {
match self {
Self::Empleado { nombre, .. } => Box::new(std::iter::once(nombre.as_str())),
Self::Area { miembros, .. } => Box::new(miembros.iter().flat_map(Miembro::personas)),
}
}
}
fn main() {
let tecnologia = Miembro::area(
"Tecnología",
vec![
Miembro::empleado("Ana", 5200),
Miembro::area(
"Equipo Pagos",
vec![
Miembro::empleado("Luis", 4100),
Miembro::empleado("Marta", 3900),
],
),
],
);
println!("{}: {}", tecnologia.nombre(), tecnologia.costo_mensual()); // Tecnología: 13200
println!("{:?}", tecnologia.personas().collect::<Vec<_>>()); // ["Ana", "Luis", "Marta"]
}LO IDIOMÁTICO EN PHP: Hoja y compuesto implementan la misma interfaz. El recorrido usa generadores: yield en la hoja y yield from en el compuesto, que delega en cada hijo. El resultado se puede recorrer con foreach sin construir listas intermedias.
<?php
declare(strict_types=1);
interface MiembroOrganizacion
{
public function costoMensual(): int;
/** @return iterable<Empleado> */
public function personas(): iterable;
}
final readonly class Empleado implements MiembroOrganizacion
{
public function __construct(public string $nombre, private int $sueldo) {}
public function costoMensual(): int { return $this->sueldo; }
public function personas(): iterable { yield $this; }
}
final class Area implements MiembroOrganizacion
{
/** @var list<MiembroOrganizacion> */
private array $miembros;
public function __construct(public readonly string $nombre, MiembroOrganizacion ...$miembros)
{
$this->miembros = $miembros;
}
public function agregar(MiembroOrganizacion $miembro): void { $this->miembros[] = $miembro; }
public function costoMensual(): int
{
return array_sum(array_map(fn (MiembroOrganizacion $m) => $m->costoMensual(), $this->miembros));
}
public function personas(): iterable
{
foreach ($this->miembros as $miembro) yield from $miembro->personas();
}
}
$tecnologia = new Area('Tecnología',
new Empleado('Ana', 5200),
new Area('Equipo Pagos', new Empleado('Luis', 4100), new Empleado('Marta', 3900)),
);
echo $tecnologia->costoMensual(), "\n"; // 13200
foreach ($tecnologia->personas() as $persona) {
echo $persona->nombre, "\n"; // Ana, Luis, Marta
}