Arquetipo
Patrones estructuralesUso: BajaComplejidad: Alta

Flyweight

Peso ligero · Estado compartido

Permite manejar una gran cantidad de objetos de forma eficiente compartiendo la parte de su estado que es común e inmutable.

“Tengo miles de objetos casi iguales y la memoria no alcanza.”

workEl caso real

Construyes una hoja de cálculo que funciona en el navegador. Un archivo típico de finanzas tiene 2 millones de celdas y cada celda tiene formato: fuente, tamaño, color, borde, alineación y formato numérico. Sin embargo, en todo el archivo solo hay unas 40 combinaciones de formato distintas.

warningEl problema sin el patrón

Si cada celda guarda su propio objeto de formato (unos 200 bytes), solo los formatos ocupan cerca de 400 MB. La pestaña del navegador se vuelve lenta y termina cerrándose.

check_circleCómo lo resuelve el patrón

Se separa el estado intrínseco, compartido e inmutable (el formato), del extrínseco, propio de cada celda (fila, columna y valor). Una fábrica de formatos devuelve siempre el mismo objeto para la misma combinación, y las celdas solo guardan una referencia: 40 objetos de formato en lugar de 2 millones.

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 Celda {
  constructor(
    public fila: number, public columna: number, public valor: string,
    // repetido en cada una de los 2 millones de celdas:
    public fuente: string, public tamano: number, public color: string,
    public borde: string, public formatoNumero: string,
  ) {}
}
check_circleCon el patrónDESPUÉS
class Formato {                    // flyweight: inmutable y compartido
  constructor(
    readonly fuente: string, readonly tamano: number,
    readonly color: string, readonly formatoNumero: string,
  ) {}
}

class FabricaFormatos {
  private cache = new Map<string, Formato>();

  obtener(fuente: string, tamano: number, color: string, formatoNumero: string) {
    const clave = [fuente, tamano, color, formatoNumero].join('|');
    if (!this.cache.has(clave)) {
      this.cache.set(clave, new Formato(fuente, tamano, color, formatoNumero));
    }
    return this.cache.get(clave)!;
  }
}

class Celda {                      // estado extrínseco: propio de cada celda
  constructor(
    readonly fila: number, readonly columna: number,
    public valor: string, public formato: Formato,
  ) {}
}

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

thumb_upCuándo usarlo

  • ✓La aplicación crea una cantidad enorme de objetos y la memoria es un problema medido, no supuesto.
  • ✓Gran parte del estado de esos objetos se repite y puede extraerse como inmutable.

do_not_disturb_onCuándo no usarlo

  • ✕La memoria no es un cuello de botella: el patrón añade complejidad sin beneficio.
  • ✕El estado que se repite cambia a menudo en cada objeto: no se puede compartir.
  • ✕Compartir tiene un costo: el estado propio de cada objeto hay que pasarlo o recalcularlo en cada llamada, así que cambias memoria por tiempo de CPU y el código se vuelve más difícil de entender.

memoryPrincipios en juego

  • •Inmutabilidad: el estado compartido no puede cambiar, porque afectaría a todos los que lo usan.
  • •Separación del estado intrínseco (compartido) y extrínseco (propio de cada objeto).

hubPatrones relacionados

  • •Composite: las hojas compartidas de un árbol pueden implementarse como flyweights.
  • •Singleton: Singleton es una única instancia; Flyweight son muchas instancias inmutables compartidas.
  • •Factory Method: la fábrica de flyweights decide si crea un objeto nuevo o reutiliza uno existente.

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

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

LO IDIOMÁTICO EN TYPESCRIPT: El flyweight es un objeto congelado con Object.freeze y tipado como Readonly<...>, así que nadie puede modificar un formato compartido. La fábrica usa un Map con una clave compuesta.

flyweight.ts · 53 líneas
export type Formato = Readonly<{
  fuente: string;
  tamano: number;
  color: string;
  formatoNumero: string;
}>;

export class FabricaFormatos {
  readonly #cache = new Map<string, Formato>();

  obtener(datos: Formato): Formato {
    const clave = `${datos.fuente}|${datos.tamano}|${datos.color}|${datos.formatoNumero}`;
    let formato = this.#cache.get(clave);
    if (!formato) {
      formato = Object.freeze({ ...datos });
      this.#cache.set(clave, formato);
    }
    return formato;
  }

  get total(): number {
    return this.#cache.size;
  }
}

export class Celda {
  constructor(
    readonly fila: number,
    readonly columna: number,
    public valor: string,
    public formato: Formato, // referencia a un objeto compartido
  ) {}
}

// ── Uso: 100 000 celdas ──
const fabrica = new FabricaFormatos();
const celdas: Celda[] = [];

for (let fila = 0; fila < 1000; fila++) {
  for (let columna = 0; columna < 100; columna++) {
    const formato = fabrica.obtener({
      fuente: 'Inter',
      tamano: 11,
      color: fila === 0 ? '#000000' : '#333333',      // encabezado o datos
      formatoNumero: columna === 0 ? '@' : '#,##0.00', // texto o monto
    });
    celdas.push(new Celda(fila, columna, '', formato));
  }
}

console.log(`${celdas.length} celdas comparten ${fabrica.total} formatos`);
// 100000 celdas comparten 4 formatos
console.log(celdas[1]!.formato === celdas[2]!.formato); // true: es el mismo objeto
Ver los 23 patrones en TypeScript →