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
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,
) {}
}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.
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.
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 objetoLO IDIOMÁTICO EN C# / .NET: El formato compartido es un record (inmutable y con igualdad por valor), así que sirve directamente como clave de diccionario. GetOrAdd de ConcurrentDictionary lo guarda solo la primera vez y es seguro con varios hilos. La celda es un record struct: no crea un objeto aparte por celda.
using System.Collections.Concurrent;
var fabrica = new FabricaFormatos();
var celdas = new List<Celda>(100_000);
for (var fila = 0; fila < 1000; fila++)
for (var columna = 0; columna < 100; columna++)
celdas.Add(new Celda(fila, columna, "", fabrica.Obtener(new Formato(
"Inter", 11,
fila == 0 ? "#000000" : "#333333",
columna == 0 ? "@" : "#,##0.00"))));
Console.WriteLine($"{celdas.Count} celdas comparten {fabrica.Total} formatos"); // 100000 celdas comparten 4 formatos
Console.WriteLine(ReferenceEquals(celdas[101].Formato, celdas[102].Formato)); // True: el mismo objeto
public sealed record Formato(string Fuente, int Tamano, string Color, string FormatoNumero);
public record struct Celda(int Fila, int Columna, string Valor, Formato Formato);
public class FabricaFormatos
{
private readonly ConcurrentDictionary<Formato, Formato> _cache = new();
public Formato Obtener(Formato datos) => _cache.GetOrAdd(datos, datos);
public int Total => _cache.Count;
}LO IDIOMÁTICO EN JAVA: Un record es inmutable y trae equals y hashCode por valor, así que sirve directamente como clave de un Map; computeIfAbsent crea el formato solo la primera vez. El propio JDK usa este patrón: Integer.valueOf devuelve objetos compartidos para los números de -128 a 127.
void main() {
var fabrica = new FabricaFormatos();
var celdas = new ArrayList<Celda>(100_000);
for (var fila = 0; fila < 1000; fila++) {
for (var columna = 0; columna < 100; columna++) {
var formato = fabrica.obtener(new Formato("Inter", 11,
fila == 0 ? "#000000" : "#333333",
columna == 0 ? "@" : "#,##0.00"));
celdas.add(new Celda(fila, columna, "", formato));
}
}
IO.println(celdas.size() + " celdas comparten " + fabrica.total() + " formatos"); // 100000 celdas comparten 4 formatos
IO.println(celdas.get(101).formato() == celdas.get(102).formato()); // true: el mismo objeto
}
record Formato(String fuente, int tamano, String color, String formatoNumero) {}
record Celda(int fila, int columna, String valor, Formato formato) {}
final class FabricaFormatos {
private final Map<Formato, Formato> cache = new HashMap<>();
Formato obtener(Formato datos) {
return cache.computeIfAbsent(datos, clave -> clave);
}
int total() {
return cache.size();
}
}LO IDIOMÁTICO EN JAVASCRIPT: Los formatos compartidos son objetos congelados con Object.freeze: intentar cambiar uno lanza un error (los módulos se ejecutan en modo estricto), así que nadie puede afectar a todas las celdas. La fábrica es una closure con un Map privado que devuelve siempre el mismo objeto.
function crearFabricaFormatos() {
const cache = new Map();
return {
obtener(datos) {
const clave = `${datos.fuente}|${datos.tamano}|${datos.color}|${datos.formatoNumero}`;
if (!cache.has(clave)) cache.set(clave, Object.freeze({ ...datos }));
return cache.get(clave);
},
get total() {
return cache.size;
},
};
}
// ── Uso: 100 000 celdas ──
const fabrica = crearFabricaFormatos();
const celdas = [];
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',
formatoNumero: columna === 0 ? '@' : '#,##0.00',
});
celdas.push({ fila, columna, valor: '', formato }); // estado propio + referencia compartida
}
}
console.log(`${celdas.length} celdas comparten ${fabrica.total} formatos`); // 100000 celdas comparten 4 formatos
console.log(celdas[1].formato === celdas[2].formato); // true
try {
celdas[1].formato.color = '#ff0000';
} catch (error) {
console.log(error.constructor.name); // TypeError: los módulos usan modo estricto y el objeto está congelado
}
console.log(celdas[2].formato.color); // #333333LO IDIOMÁTICO EN PYTHON: El flyweight es una dataclass(frozen=True, slots=True): inmutable y con poca memoria por objeto. La fábrica es una función con @functools.cache, que devuelve siempre el mismo objeto para los mismos argumentos. __slots__ en Celda también ahorra memoria en millones de celdas.
from dataclasses import FrozenInstanceError, dataclass
from functools import cache
@dataclass(frozen=True, slots=True)
class Formato:
fuente: str
tamano: int
color: str
formato_numero: str
@cache
def obtener_formato(fuente: str, tamano: int, color: str, formato_numero: str) -> Formato:
return Formato(fuente, tamano, color, formato_numero)
class Celda:
__slots__ = ("fila", "columna", "valor", "formato")
def __init__(self, fila: int, columna: int, valor: str, formato: Formato) -> None:
self.fila = fila
self.columna = columna
self.valor = valor
self.formato = formato # referencia a un objeto compartido
if __name__ == "__main__":
celdas = [
Celda(fila, columna, "", obtener_formato(
"Inter", 11,
"#000000" if fila == 0 else "#333333",
"@" if columna == 0 else "#,##0.00",
))
for fila in range(1000)
for columna in range(100)
]
print(f"{len(celdas)} celdas comparten {obtener_formato.cache_info().currsize} formatos")
# 100000 celdas comparten 4 formatos
print(celdas[1].formato is celdas[2].formato) # True
try:
celdas[1].formato.color = "#ff0000" # type: ignore[misc]
except FrozenInstanceError:
print("Un formato compartido no se puede modificar")LO IDIOMÁTICO EN GO: Go 1.23 trae el paquete unique, que implementa justo este patrón (lo llama "interning"): unique.Make devuelve un Handle, y dos valores iguales comparten el mismo handle y una sola copia en memoria. Comparar handles es tan barato como comparar punteros.
package main
import (
"fmt"
"unique"
)
type Formato struct {
Fuente string
Tamano int
Color string
FormatoNumero string
}
type Celda struct {
Fila, Columna int
Valor string
Formato unique.Handle[Formato] // referencia al formato compartido
}
func main() {
celdas := make([]Celda, 0, 100_000)
distintos := map[unique.Handle[Formato]]bool{}
for fila := range 1000 {
for columna := range 100 {
f := Formato{Fuente: "Inter", Tamano: 11, Color: "#333333", FormatoNumero: "#,##0.00"}
if fila == 0 {
f.Color = "#000000" // encabezado
}
if columna == 0 {
f.FormatoNumero = "@" // texto
}
handle := unique.Make(f)
distintos[handle] = true
celdas = append(celdas, Celda{Fila: fila, Columna: columna, Formato: handle})
}
}
fmt.Printf("%d celdas comparten %d formatos\n", len(celdas), len(distintos)) // 100000 celdas comparten 4 formatos
fmt.Println(celdas[101].Formato == celdas[102].Formato) // true
// Value() devuelve una copia: nadie puede modificar el formato compartido
copia := celdas[101].Formato.Value()
copia.Color = "#ff0000"
fmt.Println(celdas[102].Formato.Value().Color) // #333333
}LO IDIOMÁTICO EN RUST: Los formatos se comparten con Rc (un puntero con conteo de referencias): cada celda guarda un Rc<Formato> y clonarlo no copia el formato. Como Formato deriva Hash y Eq, sirve de clave en el HashMap de la fábrica. Además, Rust no permite modificar un valor compartido por un Rc.
use std::collections::HashMap;
use std::rc::Rc;
#[derive(Clone, PartialEq, Eq, Hash)]
struct Formato {
fuente: &'static str,
tamano: u8,
color: &'static str,
formato_numero: &'static str,
}
impl Formato {
fn describir(&self) -> String {
format!(
"{} {}pt {} {}",
self.fuente, self.tamano, self.color, self.formato_numero
)
}
}
#[derive(Default)]
struct FabricaFormatos {
cache: HashMap<Formato, Rc<Formato>>,
}
impl FabricaFormatos {
fn obtener(&mut self, formato: Formato) -> Rc<Formato> {
Rc::clone(
self.cache
.entry(formato.clone())
.or_insert_with(|| Rc::new(formato)),
)
}
}
struct Celda {
fila: u32,
columna: u32,
formato: Rc<Formato>, // referencia al formato compartido
}
fn main() {
let mut fabrica = FabricaFormatos::default();
let mut celdas = Vec::with_capacity(100_000);
for fila in 0..1000 {
for columna in 0..100 {
let formato = fabrica.obtener(Formato {
fuente: "Inter",
tamano: 11,
color: if fila == 0 { "#000000" } else { "#333333" },
formato_numero: if columna == 0 { "@" } else { "#,##0.00" },
});
celdas.push(Celda {
fila,
columna,
formato,
});
}
}
println!(
"{} celdas comparten {} formatos",
celdas.len(),
fabrica.cache.len()
); // 100000 celdas comparten 4 formatos
let (a, b) = (&celdas[101], &celdas[102]);
println!(
"({},{}) y ({},{}) comparten formato: {}",
a.fila,
a.columna,
b.fila,
b.columna,
Rc::ptr_eq(&a.formato, &b.formato)
);
println!(
"{} · usado por {} celdas",
a.formato.describir(),
Rc::strong_count(&a.formato) - 1
);
}LO IDIOMÁTICO EN PHP: El formato compartido es una clase readonly: una vez creado, nadie puede cambiarlo. La fábrica guarda los formatos en un array asociativo con una clave compuesta y ??= crea cada uno solo la primera vez. memory_get_usage() permite comprobar el ahorro.
<?php
declare(strict_types=1);
final readonly class Formato
{
public function __construct(
public string $fuente,
public int $tamano,
public string $color,
public string $formatoNumero,
) {}
}
final class FabricaFormatos
{
/** @var array<string, Formato> */
private array $cache = [];
public function obtener(string $fuente, int $tamano, string $color, string $formatoNumero): Formato
{
$clave = "{$fuente}|{$tamano}|{$color}|{$formatoNumero}";
return $this->cache[$clave] ??= new Formato($fuente, $tamano, $color, $formatoNumero);
}
public function total(): int
{
return count($this->cache);
}
}
final class Celda
{
public function __construct(public int $fila, public int $columna, public string $valor, public Formato $formato) {}
}
$fabrica = new FabricaFormatos();
$celdas = [];
for ($fila = 0; $fila < 1000; $fila++) {
for ($columna = 0; $columna < 100; $columna++) {
$formato = $fabrica->obtener('Inter', 11, $fila === 0 ? '#000000' : '#333333', $columna === 0 ? '@' : '#,##0.00');
$celdas[] = new Celda($fila, $columna, '', $formato);
}
}
echo count($celdas), " celdas comparten {$fabrica->total()} formatos\n"; // 100000 celdas comparten 4 formatos
var_dump($celdas[101]->formato === $celdas[102]->formato); // bool(true): el mismo objeto
try {
$celdas[101]->formato->color = '#ff0000';
} catch (Error $error) {
echo $error->getMessage(), "\n"; // Cannot modify readonly property Formato::$color
}