Flyweight

A forest of 1,000,000 heavy trees

Each Tree stores its own mesh, texture and color — even though most trees share the same handful of species.

class Tree {
  constructor(x, y, name, color) {
    this.x = x; this.y = y;
    this.name  = name;
    this.color = color;
    // duplicated on EVERY instance:
    this.mesh    = loadMesh(name);     // ~1.5MB
    this.texture = loadTexture(name);  // ~1.5MB
  }
}
// 1,000,000 × its own mesh+texture → 💥

Split intrinsic (shared) from extrinsic (per-instance)

A TreeType flyweight holds the heavy, shared state. A factory hands out one instance per unique species. Each Tree keeps only its own x/y + a reference.

class TreeType {          // shared
  constructor(name, color) {
    this.name = name; this.color = color;
    this.mesh = loadMesh(name);  // heavy, once
  }
}

class TreeFactory {
  static cache = new Map();
  static get(name, color) {
    const key = name + color;
    if (!this.cache.has(key))
      this.cache.set(key, new TreeType(name, color));
    return this.cache.get(key);   // reuse!
  }
}

class Tree {                // per-instance
  constructor(x, y, type) {
    this.x = x; this.y = y; this.type = type;
  }
}

Plant 1,000 trees — count the flyweights

Only 3 species exist, so the factory ever creates 3 TreeType flyweights, no matter how many Tree instances reference them.

Share state, slash memory

• Intrinsic state (shared, immutable) lives in the flyweight; extrinsic state (unique, contextual) is passed in by the caller.
• A factory guarantees one flyweight per unique key — new callers reuse, they never duplicate.
• You already see it: font glyphs, game sprites/particles, table-cell styles.
• Caution: it adds a layer of indirection — reach for it only when object count or memory pressure genuinely hurts (YAGNI otherwise).