设计模式对内存使用的影响

设计模式在JavaScript开发中扮演着重要角色，它们不仅影响代码结构和可维护性，还会对内存使用产生直接或间接的影响。不同的设计模式在内存分配、对象创建和垃圾回收等方面表现各异，理解这些影响有助于在特定场景下做出更合理的选择。

单例模式的内存特性

单例模式通过限制类实例化次数来减少内存占用。在JavaScript中，单例通常以模块模式或静态属性实现：

class DatabaseConnection {
  constructor() {
    if (DatabaseConnection.instance) {
      return DatabaseConnection.instance;
    }
    this.connection = this.createConnection();
    DatabaseConnection.instance = this;
  }
  
  createConnection() {
    // 模拟耗资源的连接创建
    return { id: Date.now() };
  }
}

const conn1 = new DatabaseConnection();
const conn2 = new DatabaseConnection();
console.log(conn1 === conn2); // true

这种模式显著减少了重复创建相同功能对象的内存开销，但需要注意：

1. 单例会常驻内存直到程序结束
2. 不当使用可能导致内存泄漏
3. 测试时可能因状态残留影响结果

工厂模式的内存权衡

工厂模式通过集中创建逻辑来管理对象实例，其内存影响取决于具体实现方式：

class Car {
  constructor(type) {
    this.type = type;
    // 每个实例都包含独立的方法副本
    this.startEngine = function() {
      console.log(`${type} engine started`);
    };
  }
}

class CarFactory {
  static createCar(type) {
    // 简单工厂可能造成重复方法定义
    return new Car(type);
  }
}

// 优化版本：原型共享方法
class OptimizedCar {
  constructor(type) {
    this.type = type;
  }
  
  startEngine() {
    console.log(`${this.type} engine started`);
  }
}

内存差异：

• 普通工厂：每个实例包含独立方法副本，内存占用高
• 优化版本：方法定义在原型上，实例共享同一方法
• 每创建10,000个实例，前者可能多占用2-3MB内存

观察者模式的内存风险

观察者模式在事件处理中广泛应用，但容易引发内存问题：

class EventBus {
  constructor() {
    this.listeners = {};
  }

  on(event, callback) {
    if (!this.listeners[event]) {
      this.listeners[event] = [];
    }
    this.listeners[event].push(callback);
  }

  off(event, callback) {
    const index = this.listeners[event]?.indexOf(callback);
    if (index > -1) {
      this.listeners[event].splice(index, 1);
    }
  }
}

// 使用示例
const bus = new EventBus();
function heavyHandler() {
  // 占用大量内存的处理函数
}

bus.on('data', heavyHandler);
// 忘记移除观察者将导致内存泄漏
// bus.off('data', heavyHandler);

关键内存问题：

1. 观察者长期持有对被观察对象的引用
2. 未及时移除无效监听器会导致内存增长
3. 高频事件可能产生大量临时对象

享元模式的内存优化

享元模式通过共享细粒度对象减少内存消耗，特别适合大量相似对象的场景：

class TreeType {
  constructor(name, color) {
    this.name = name;
    this.color = color;
  }
  
  draw(x, y) {
    console.log(`Drawing ${this.color} ${this.name} at (${x}, ${y})`);
  }
}

class TreeFactory {
  static types = new Map();
  
  static getType(name, color) {
    const key = `${name}_${color}`;
    if (!this.types.has(key)) {
      this.types.set(key, new TreeType(name, color));
    }
    return this.types.get(key);
  }
}

class Tree {
  constructor(x, y, type) {
    this.x = x;
    this.y = y;
    this.type = type;
  }
  
  draw() {
    this.type.draw(this.x, this.y);
  }
}

// 创建百万棵树，共享有限的TreeType
const forest = [];
for (let i = 0; i < 1000000; i++) {
  const type = TreeFactory.getType(
    Math.random() > 0.5 ? 'Oak' : 'Maple',
    Math.random() > 0.5 ? 'Green' : 'Red'
  );
  forest.push(new Tree(
    Math.random() * 1000,
    Math.random() * 1000,
    type
  ));
}

内存优势：

• 原始方式：百万个独立对象可能占用500MB
• 享元模式：相同场景可能仅需50MB
• 外部状态与内部状态分离是关键

装饰器模式的内存开销

装饰器模式通过包装对象动态添加功能，但嵌套层级会影响内存：

class Coffee {
  cost() {
    return 5;
  }
}

class MilkDecorator {
  constructor(coffee) {
    this.coffee = coffee;
  }
  
  cost() {
    return this.coffee.cost() + 2;
  }
}

class SugarDecorator {
  constructor(coffee) {
    this.coffee = coffee;
  }
  
  cost() {
    return this.coffee.cost() + 1;
  }
}

// 使用
let myCoffee = new Coffee();
myCoffee = new MilkDecorator(myCoffee);
myCoffee = new SugarDecorator(myCoffee);
console.log(myCoffee.cost()); // 8

// 内存结构形成链式引用

内存特点：

1. 每个装饰器都会创建新对象
2. 装饰层级越深，内存占用越大
3. 可能影响垃圾回收效率

策略模式的内存效率

策略模式将算法封装为独立对象，其内存影响取决于策略存储方式：

// 策略定义
const strategies = {
  add: (a, b) => a + b,
  subtract: (a, b) => a - b,
  multiply: (a, b) => a * b
};

class Calculator {
  constructor(strategy) {
    this.strategy = strategy;
  }
  
  execute(a, b) {
    return this.strategy(a, b);
  }
}

// 使用
const calc = new Calculator(strategies.add);
console.log(calc.execute(5, 3)); // 8

内存考量：

1. 策略作为函数：共享原型，内存高效
2. 策略作为类实例：每个策略都是独立对象
3. 策略缓存可以避免重复创建

代理模式的内存控制

代理模式可以用于控制大对象的创建和访问，优化内存使用：

class HeavyImage {
  constructor(path) {
    this.path = path;
    this.loadImage(); // 模拟昂贵操作
  }
  
  loadImage() {
    console.log(`Loading huge image from ${this.path}`);
    // 这里会占用大量内存
  }
  
  display() {
    console.log(`Displaying image from ${this.path}`);
  }
}

class ImageProxy {
  constructor(path) {
    this.path = path;
    this.realImage = null;
  }
  
  display() {
    if (!this.realImage) {
      this.realImage = new HeavyImage(this.path);
    }
    this.realImage.display();
  }
}

// 使用
const gallery = [
  new ImageProxy('photo1.jpg'),
  new ImageProxy('photo2.jpg'),
  new ImageProxy('photo3.jpg')
];

// 只有实际查看时才加载真实图片
gallery[0].display();

内存优势：

1. 延迟加载节省初始内存
2. 可以智能释放不再需要的对象
3. 适合管理大型资源集合

备忘录模式的状态存储

备忘录模式保存对象状态会带来额外内存开销：

class Editor {
  constructor() {
    this.content = '';
  }
  
  type(text) {
    this.content += text;
  }
  
  save() {
    return new EditorMemento(this.content);
  }
  
  restore(memento) {
    this.content = memento.getContent();
  }
}

class EditorMemento {
  constructor(content) {
    this.content = content;
    this.timestamp = Date.now();
  }
  
  getContent() {
    return this.content;
  }
}

// 使用
const editor = new Editor();
const history = [];

editor.type('Hello');
history.push(editor.save());
editor.type(' World');
history.push(editor.save());

// 恢复到第一个状态
editor.restore(history[0]);

内存注意事项：

1. 保存完整状态可能消耗大量内存
2. 需要实现合理的快照清理机制
3. 增量式状态保存可以优化内存

组合模式的结构内存

组合模式构建树形结构时需要考虑节点内存：

class Component {
  constructor(name) {
    this.name = name;
  }
  
  operation() {
    throw new Error('Abstract method');
  }
}

class Leaf extends Component {
  operation() {
    console.log(`Leaf ${this.name} operation`);
  }
}

class Composite extends Component {
  constructor(name) {
    super(name);
    this.children = [];
  }
  
  add(component) {
    this.children.push(component);
  }
  
  operation() {
    console.log(`Composite ${this.name} operation`);
    this.children.forEach(child => child.operation());
  }
}

// 构建深度嵌套结构
const root = new Composite('root');
const branch1 = new Composite('branch1');
const branch2 = new Composite('branch2');

branch1.add(new Leaf('leaf1'));
branch2.add(new Leaf('leaf2'));
branch2.add(new Leaf('leaf3'));

root.add(branch1);
root.add(branch2);

root.operation();

内存特点：

1. 每个节点都是独立对象
2. 深度嵌套结构占用线性增长
3. 叶子节点与容器节点内存需求不同

职责链模式的处理对象

职责链模式创建的处理对象链会影响内存：

class Handler {
  constructor() {
    this.next = null;
  }
  
  setNext(handler) {
    this.next = handler;
    return handler;
  }
  
  handle(request) {
    if (this.next) {
      return this.next.handle(request);
    }
    return null;
  }
}

class ConcreteHandlerA extends Handler {
  handle(request) {
    if (request === 'A') {
      return 'Handled by A';
    }
    return super.handle(request);
  }
}

class ConcreteHandlerB extends Handler {
  handle(request) {
    if (request === 'B') {
      return 'Handled by B';
    }
    return super.handle(request);
  }
}

// 构建链条
const handlerA = new ConcreteHandlerA();
const handlerB = new ConcreteHandlerB();
handlerA.setNext(handlerB);

// 使用
console.log(handlerA.handle('B')); // 'Handled by B'

内存考量：

1. 每个处理器都是独立对象
2. 长链条会增加内存占用
3. 可以考虑复用处理器实例