JavaScript设计模式入门(一)：单例模式(Singleton)——让你的代码更优雅

引言：什么是单例模式？

单例模式是一种确保类只有一个实例，并提供全局访问点的设计模式。在JavaScript中，这种模式能有效避免重复创建对象，节省系统资源，同时保持状态一致性，是优化代码结构的重要工具。

学习单例模式的价值在于它能够帮助我们编写更加优雅、高效的代码，特别是在需要全局共享资源的场景下。通过掌握这一模式，你可以更好地控制对象的生命周期，减少不必要的内存消耗，并确保数据的一致性。

单例模式在日常开发中有广泛应用，如全局配置管理、日志系统、用户会话管理、数据库连接池等。它的优点在于能够有效控制资源使用，但缺点是可能导致代码耦合度提高。

本文将从单例模式的基础概念开始，逐步深入到实际应用场景，最后探讨最佳实践。在学习本文之前，读者需要具备基础的JavaScript知识，包括对象、原型、闭包等概念。文章将通过代码示例和实际应用，帮助读者全面理解并掌握单例模式，从而提升代码质量和开发效率。

单例模式的实现原理

单例模式是一种创建型设计模式，其核心思想是限制一个类的实例化次数为一次。这意味着无论我们尝试创建多少次该类的实例，最终都只会得到同一个对象。想象一下，一个国家的总统，无论多少人想成为总统，最终只能有一个在职总统。这就是单例模式的基本理念。

单例模式有两个关键特性：唯一性（只创建一个实例）和全局访问点（提供获取实例的方法）。唯一性确保了系统中只有一个实例存在，而全局访问点则允许其他代码在不持有实例引用的情况下访问这个实例。

与其他创建型模式（如工厂模式）不同，工厂模式每次调用都会创建新的实例，而单例模式则保证只创建一个实例，并在后续调用中返回已存在的实例。

让我们通过代码示例来理解单例模式的实现：

// 基础实现：使用闭包和IIFE
const Singleton = (function() {
  // 私有变量，存储单例实例
  let instance = null;
  
  // 私有构造函数
  function Constructor(data) {
    // 初始化逻辑
    this.data = data;
  }
  
  // 公共接口，获取单例实例
  return {
    getInstance: function(data) {
      if (!instance) {
        instance = new Constructor(data);
      }
      return instance;
    }
  };
})();

// 使用示例
const singleton1 = Singleton.getInstance("Instance 1");
const singleton2 = Singleton.getInstance("Instance 2");

console.log(singleton1 === singleton2); // 输出: true，证明是同一个实例

// 使用ES6 class实现
class Singleton {
  constructor(data) {
    // 确保只能实例化一次
    if (Singleton.instance) {
      return Singleton.instance;
    }
    
    this.data = data;
    Singleton.instance = this;
  }
  
  // 静态方法获取实例
  static getInstance(data) {
    if (!this.instance) {
      this.instance = new Singleton(data);
    }
    return this.instance;
  }
}

// 使用示例
const singleton1 = Singleton.getInstance("Instance 1");
const singleton2 = Singleton.getInstance("Instance 2");

console.log(singleton1 === singleton2); // 输出: true

单例模式适用于以下场景：

1. 需要全局共享状态的情况，如应用程序配置、用户会话等
2. 资源管理，如数据库连接池、线程池等
3. 当一个对象需要被频繁创建和销毁，且创建成本较高时
4. 需要确保某个类只有一个实例，并且提供一个全局访问点时

然而，使用单例模式也需要注意：

1. 避免滥用：单例模式会使代码耦合度变高，增加测试难度
2. 隐藏依赖关系：单例的全局访问点可能使依赖关系不明确
3. 状态共享问题：全局状态可能导致难以追踪的bug
4. 多线程问题：在某些JavaScript运行环境中（如Node.js集群模式），单例可能需要额外处理

合理使用单例模式，可以让你的代码更加优雅和高效，但过度使用则可能导致维护困难。在实际开发中，应权衡使用单例模式的利弊，确保它真正解决了你的问题，而不是引入了新的问题。

JavaScript中的单例模式实现方式

单例模式就像一个国家的总统，无论多少人尝试"选举"，最终只会有一个总统存在，并且所有人都知道如何找到这位总统。在JavaScript中，单例模式确保一个类只有一个实例，并提供一个全局访问点。

1. 对象字面量实现

这是最简单的单例实现方式，直接创建一个对象并导出：

// 直接创建对象并导出
const singleton = {
  name: 'Singleton Instance',
  method: function() {
    console.log('This is a singleton method');
  }
};

// 导出对象
module.exports = singleton;

这种方式简单直接，但缺乏封装性，任何代码都可以修改对象属性。

2. 构造函数实现

通过构造函数内部判断是否已存在实例：

function Singleton() {
  // 如果已经存在实例，则返回已存在的实例
  if (Singleton.instance) {
    return Singleton.instance;
  }
  
  // 否则创建新实例
  this.name = 'Singleton Instance';
  this.method = function() {
    console.log('This is a singleton method');
  };
  
  // 保存实例
  Singleton.instance = this;
}

// 使用
const instance1 = new Singleton();
const instance2 = new Singleton();
console.log(instance1 === instance2); // 输出: true

这种方式通过构造函数的静态属性保存实例，确保只有一个实例存在。

3. 闭包实现

利用闭包保存实例状态，就像一个私人保险箱，只有持有钥匙的人才能访问：

function createSingleton() {
  let instance = null;  // 私有变量，外部无法访问
  
  return function() {
    if (!instance) {
      instance = {
        name: 'Singleton Instance',
        method: function() {
          console.log('This is a singleton method');
        }
      };
    }
    return instance;
  };
}

const Singleton = createSingleton();
const instance1 = Singleton();
const instance2 = Singleton();
console.log(instance1 === instance2); // 输出: true

这种方式利用闭包的私有性，确保实例只能通过特定方式访问。

4. ES6模块实现

利用ES6模块的单一特性，就像一个国家的法律体系，全国统一适用：

// singleton.js
let instance = null;

class Singleton {
  constructor() {
    if (instance) {
      return instance;
    }
    
    this.name = 'Singleton Instance';
    this.method = function() {
      console.log('This is a singleton method');
    };
    
    instance = this;
  }
}

export default Singleton;

这种方式利用了ES6模块的特性，模块只会被加载一次，确保了单例的唯一性。

5. 比较分析

实现方式	优点	缺点	适用场景
对象字面量	简单直接、性能好	缺乏封装性、安全性低	小型项目、简单配置
构造函数	面向对象、可扩展	可能被new多次、需手动检查	需要类结构的项目
闭包	私有性、封装性好	代码复杂度高、内存占用大	需要严格封装的场景
ES6模块	现代化、简洁、自动单例	依赖ES6环境、浏览器兼容性	现代JavaScript项目

单例模式在实际开发中非常实用，特别是在需要全局状态管理、配置信息存储等场景。选择合适的实现方式，可以让代码更加优雅和可维护。

单例模式的实际应用案例

单例模式的实际应用案例

单例模式在实际开发中有着广泛的应用，它确保一个类只有一个实例，并提供一个全局访问点。以下是几个典型的应用场景：

全局状态管理

全局状态管理就像一个中央信息中心，整个应用都可以访问但只有一个实例。这对于管理应用的全局状态非常有用。

// 全局状态管理器
class AppStateManager {
  constructor() {
    if (AppStateManager.instance) {
      return AppStateManager.instance;
    }
    this.state = {};
    AppStateManager.instance = this;
  }

  setState(key, value) {
    this.state[key] = value;
  }

  getState(key) {
    return this.state[key];
  }
}

// 使用示例
const appState1 = new AppStateManager();
const appState2 = new AppStateManager();

appState1.setState('user', { name: 'Alice' });

console.log(appState2.getState('user')); // 输出: { name: 'Alice' }
// 两个实例实际上是同一个对象
console.log(appState1 === appState2); // 输出: true

日志记录器

日志记录器就像一个只有一本的记事本，所有人都可以写但都在同一本上，确保日志的一致性和完整性。

// 日志记录器
class Logger {
  constructor() {
    if (Logger.instance) {
      return Logger.instance;
    }
    this.logs = [];
    Logger.instance = this;
  }

  log(level, message) {
    const timestamp = new Date().toISOString();
    this.logs.push({ timestamp, level, message });
    console.log(`[${timestamp}] ${level}: ${message}`);
  }

  getLogs() {
    return this.logs;
  }
}

// 使用示例
const logger1 = new Logger();
const logger2 = new Logger();

logger1.log('INFO', 'User logged in');
logger2.log('ERROR', 'Failed to process request');

// 两个实例共享同一个日志
console.log(logger1.getLogs() === logger2.getLogs()); // 输出: true

配置管理

配置管理类似于应用的设置中心，所有配置都在一处管理，避免多处定义导致的混乱。

// 配置管理器
class ConfigManager {
  constructor() {
    if (ConfigManager.instance) {
      return ConfigManager.instance;
    }
    this.config = {
      apiUrl: 'https://api.example.com',
      timeout: 5000
    };
    ConfigManager.instance = this;
  }

  get(key) {
    return this.config[key];
  }

  set(key, value) {
    this.config[key] = value;
  }
}

// 使用示例
const config = new ConfigManager();
console.log(config.get('apiUrl')); // 输出: https://api.example.com
config.set('timeout', 3000);
console.log(config.get('timeout')); // 输出: 3000

弹窗管理

弹窗管理就像一个只有一个舞台的剧场，一次只能有一个表演者，避免多个弹窗同时显示导致的冲突。

// 弹窗管理器
class ModalManager {
  constructor() {
    if (ModalManager.instance) {
      return ModalManager.instance;
    }
    this.currentModal = null;
    ModalManager.instance = this;
  }

  show(modal) {
    if (this.currentModal) {
      this.currentModal.hide();
    }
    this.currentModal = modal;
    modal.show();
  }

  hide() {
    if (this.currentModal) {
      this.currentModal.hide();
      this.currentModal = null;
    }
  }
}

// 使用示例
const modalManager = new ModalManager();

const loginModal = { show: () => console.log('Login modal shown'), hide: () => console.log('Login modal hidden') };
const alertModal = { show: () => console.log('Alert modal shown'), hide: () => console.log('Alert modal hidden') };

modalManager.show(loginModal); // 输出: Login modal shown
modalManager.show(alertModal); // 输出: Alert modal shown, Login modal hidden

数据库连接池

数据库连接池类似于一个共享的出租车队，大家都可以使用但资源是共享的，提高性能并避免资源浪费。

// 数据库连接池
class ConnectionPool {
  constructor(maxConnections = 5) {
    if (ConnectionPool.instance) {
      return ConnectionPool.instance;
    }
    this.maxConnections = maxConnections;
    this.connections = [];
    this.usedConnections = 0;
    ConnectionPool.instance = this;
  }

  getConnection() {
    if (this.usedConnections < this.maxConnections) {
      this.usedConnections++;
      return `Connection ${this.usedConnections}`;
    }
    return 'No available connections';
  }

  releaseConnection(connection) {
    if (connection !== 'No available connections') {
      this.usedConnections--;
    }
  }
}

// 使用示例
const pool1 = new ConnectionPool(3);
const pool2 = new ConnectionPool(3);

console.log(pool1.getConnection()); // 输出: Connection 1
console.log(pool2.getConnection()); // 输出: Connection 2
console.log(pool1.getConnection()); // 输出: Connection 3
console.log(pool1.getConnection()); // 输出: No available connections

// 两个实例实际上是同一个连接池
console.log(pool1 === pool2); // 输出: true

这些案例展示了单例模式在不同场景下的应用，通过确保只有一个实例，我们可以有效地管理资源、保持状态一致性并简化代码结构。

单例模式的最佳实践

何时使用单例模式就像城市共享中央图书馆，只有在真正需要全局唯一实例时才使用，如配置管理器或日志记录器。滥用单例会导致代码耦合度高，难以维护。

性能考虑方面，单例模式的关键优化点是延迟加载，只在第一次需要时才创建实例：

// 延迟加载的单例实现
class LazySingleton {
  constructor() {
    if (LazySingleton.instance) return LazySingleton.instance;
    this.data = 'Initialized only once';
    LazySingleton.instance = this;
  }
  
  static getInstance() {
    if (!LazySingleton.instance) {
      LazySingleton.instance = new LazySingleton();
    }
    return LazySingleton.instance;
  }
}

ES6模块系统为单例提供了更优雅的实现，每个模块只会在第一次导入时执行：

// config.js - 单例模块
const config = { apiUrl: 'https://api.example.com' };
export default config;

// 其他文件导入时总是同一个实例

为使用单例的代码编写测试时，需要特别注意状态隔离：

class TestableSingleton {
  constructor() {
    if (TestableSingleton.instance) return TestableSingleton.instance;
    this.count = 0;
    TestableSingleton.instance = this;
  }
  
  static reset() { TestableSingleton.instance = null; } // 重置方法
  
  increment() { return ++this.count; }
}

// 测试用例
describe('TestableSingleton', () => {
  beforeEach(() => TestableSingleton.reset()); // 测试前重置
  test('should maintain state', () => {
    const singleton1 = new TestableSingleton();
    singleton1.increment();
    const singleton2 = new TestableSingleton();
    expect(singleton2.increment()).toBe(2);
  });
});

在某些情况下，依赖注入或模块可能是比单例更好的选择：

// 使用依赖注入替代单例
class DatabaseService {
  constructor(config) { this.config = config; }
  connect() { /* 使用提供的配置连接数据库 */ }
}

记住，设计模式是工具，不是目的。选择最适合当前问题的解决方案，而不是仅仅因为模式流行就使用它。

单例模式的进阶技巧

延迟加载

延迟加载是一种只在需要时才创建单例实例的技术，可以提高应用性能。想象一个懒汉，只有在需要时才起床做事。

// 延迟加载单例实现
class LazySingleton {
  constructor() {
    this._instance = null; // 私有实例变量
    this.data = 'Initial Data';
  }
  
  // **获取单例实例的关键方法**
  getInstance() {
    if (!this._instance) {
      console.log('创建新实例...');
      this._instance = new this.constructor();
    } else {
      console.log('返回已有实例...');
    }
    return this._instance;
  }
}

// 使用示例
const singleton1 = new LazySingleton();
const instance1 = singleton1.getInstance(); // 创建新实例
const instance2 = singleton1.getInstance(); // 返回已有实例
console.log(instance1 === instance2); // true，验证单例特性

可配置的单例

可配置单例允许在运行时配置单例行为，增加了灵活性。

class ConfigurableSingleton {
  constructor(config = {}) {
    this._instance = null;
    this.config = { name: '默认名称', ...config }; // 合并配置
  }
  
  getInstance(newConfig) {
    if (!this._instance) {
      this._instance = new this.constructor(newConfig || this.config);
    } else if (newConfig) {
      this.config = { ...this.config, ...newConfig }; // 更新配置
    }
    return this._instance;
  }
}

单例模式的继承

通过继承可以扩展单例功能，创建具有特定功能的子类单例。

class BaseSingleton {
  constructor() {
    this._instance = null;
  }
  
  getInstance() {
    if (!this._instance) {
      this._instance = new this.constructor();
    }
    return this._instance;
  }
}

class ExtendedSingleton extends BaseSingleton {
  constructor() {
    super();
    this.timestamp = Date.now(); // 添加新功能
  }
  
  getTimestamp() {
    return this.timestamp;
  }
}

与其他模式结合

单例与观察者模式结合，创建全局事件总线：

class EventBusSingleton {
  constructor() {
    this._instance = null;
    this._events = {};
  }
  
  getInstance() {
    if (!this._instance) {
      this._instance = this;
    }
    return this._instance;
  }
  
  on(event, callback) {
    if (!this._events[event]) {
      this._events[event] = [];
    }
    this._events[event].push(callback);
  }
  
  emit(event, data) {
    if (this._events[event]) {
      this._events[event].forEach(cb => cb(data));
    }
  }
}

// 使用示例
const eventBus = new EventBusSingleton().getInstance();
eventBus.on('data', console.log);
eventBus.emit('data', 'Hello 单例事件总线!');

框架中的应用

在React、Vue等框架中，单例模式广泛应用于状态管理和全局服务。例如Redux store就是一个典型的单例实现：

class ReduxStoreSingleton {
  constructor(reducer) {
    this._instance = null;
    this._state = null;
    this._reducer = reducer;
    this._listeners = [];
  }
  
  getInstance(initialState) {
    if (!this._instance) {
      this._state = this._reducer(initialState, { type: '@@INIT' });
      this._instance = this;
    }
    return this._instance;
  }
  
  dispatch(action) {
    this._state = this._reducer(this._state, action);
    this._listeners.forEach(listener => listener());
  }
}

这些进阶技巧使单例模式更加灵活，能够适应各种复杂场景，同时保持全局唯一性的核心优势。

总结与思考

单例模式确保全局只有一个实例，提供统一访问点，适用于全局状态管理、配置信息等场景。通过模块模式、立即执行函数或ES6 Class实现，能有效节省内存并避免冲突。在实际项目中，单例模式可用于管理全局状态、创建日志系统或统一配置管理，显著提升代码质量与可维护性。

单例模式虽强大，但并非万能。过度使用可能导致代码耦合或违反单一职责原则，需谨慎权衡。下一篇文章我们将探讨工厂方法模式，继续深入JavaScript设计模式的世界，让你的代码更加优雅和专业。