从0开始学习JavaScript--JavaScript 单例模式

单例模式是一种常见的设计模式，它保证一个类仅有一个实例，并提供一个全局访问点。在 JavaScript 中，单例模式通常用于创建唯一的对象，以确保全局只有一个实例。本文将深入探讨单例模式的基本概念、实现方式，以及在实际应用中的各种场景。

单例模式的基本概念

单例模式的核心思想是确保一个类只有一个实例，并提供一个全局访问点。这样做的好处包括：

资源共享： 由于只有一个实例，可以避免多次创建相同对象，减少内存占用。
全局访问： 通过单一的入口访问对象，方便管理和控制。

在 JavaScript 中，实现单例模式有多种方式，我们将分别介绍其中的三种：懒汉式、饿汉式和模块模式。

懒汉式单例模式

懒汉式单例模式是指在需要时才创建实例，如果实例已经存在，则返回现有实例。这样可以延迟对象的创建，提高性能。

示例代码：

class LazySingleton {
  constructor() {
    if (!LazySingleton.instance) {
      this.data = Math.random(); // 示例中添加随机数，表示实例的一些数据
      LazySingleton.instance = this;
    }

    return LazySingleton.instance;
  }
}

const instance1 = new LazySingleton();
const instance2 = new LazySingleton();

console.log(instance1 === instance2); // 输出: true
console.log(instance1.data === instance2.data); // 输出: true

在这个示例中，LazySingleton 类只有在实例不存在时才创建新实例。之后，无论创建多少次实例，都返回第一次创建的实例。

饿汉式单例模式

饿汉式单例模式是指在应用启动时就立即创建实例，无论后续是否会使用到。

示例代码：

class EagerSingleton {
  constructor() {
    if (!EagerSingleton.instance) {
      this.data = Math.random();
      EagerSingleton.instance = this;
    }

    return EagerSingleton.instance;
  }
}

const instance1 = new EagerSingleton();
const instance2 = new EagerSingleton();

console.log(instance1 === instance2); // 输出: true
console.log(instance1.data === instance2.data); // 输出: true

在这个示例中，EagerSingleton 类在第一次创建实例时就立即创建了一个实例。之后，无论创建多少次实例，都返回第一次创建的实例。

模块模式的单例

模块模式是一种结合了闭包和立即调用函数表达式（IIFE）的方式，创建单例的模式。

示例代码：

const ModuleSingleton = (function () {
  let instance;

  function createInstance() {
    return {
      data: Math.random()
    };
  }

  return {
    getInstance: function () {
      if (!instance) {
        instance = createInstance();
      }
      return instance;
    }
  };
})();

const instance1 = ModuleSingleton.getInstance();
const instance2 = ModuleSingleton.getInstance();

console.log(instance1 === instance2); // 输出: true
console.log(instance1.data === instance2.data); // 输出: true

在这个示例中，ModuleSingleton 使用闭包和 IIFE 创建了一个包含 getInstance 方法的模块。getInstance 方法确保只有一个实例被创建，并提供全局访问点。

单例模式的实际应用场景

1. 管理全局状态

单例模式常用于管理全局状态，确保整个应用中只有一个状态管理实例，例如 Redux 中的 store。

const store = createStore(reducer);

2. 数据缓存

在需要缓存数据的场景，可以使用单例模式确保只有一个缓存实例。

class DataCache {
  constructor() {
    if (!DataCache.instance) {
      this.cache = {};
      DataCache.instance = this;
    }

    return DataCache.instance;
  }

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

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

const cache = new DataCache();
cache.set('user', { name: 'John' });
console.log(cache.get('user')); // 输出: { name: 'John' }

3. 配置管理

在配置管理中，使用单例模式可以确保只有一个配置管理实例，方便全局访问配置信息。

class ConfigurationManager {
  constructor() {
    if (!ConfigurationManager.instance) {
      this.config = { /* 配置信息 */ };
      ConfigurationManager.instance = this;
    }

    return ConfigurationManager.instance;
  }

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

const configManager = new ConfigurationManager();
console.log(configManager.getConfig('apiUrl')); // 输出: 配置信息中的 apiUrl

单例模式的进阶应用

1. 日志记录器

在应用中使用单例模式创建一个全局的日志记录器，确保只有一个实例记录所有日志信息。

class Logger {
  constructor() {
    if (!Logger.instance) {
      this.logs = [];
      Logger.instance = this;
    }

    return Logger.instance;
  }

  log(message) {
    this.logs.push(message);
    console.log(message);
  }

  printLogs() {
    console.log('All logs:');
    this.logs.forEach(log => console.log(log));
  }
}

const logger = new Logger();
logger.log('Log message 1');
logger.log('Log message 2');

const anotherLogger = new Logger();
console.log(logger === anotherLogger); // 输出: true
anotherLogger.printLogs(); // 输出: Log message 1 \n Log message 2

在这个例子中，Logger 类用于记录应用中的日志信息，通过单例模式确保只有一个全局的日志记录器。

2. 文件系统管理

在需要管理文件系统的应用中，使用单例模式可以确保只有一个实例负责文件系统的操作，避免文件冲突和资源竞争。

class FileSystemManager {
  constructor() {
    if (!FileSystemManager.instance) {
      this.files = [];
      FileSystemManager.instance = this;
    }

    return FileSystemManager.instance;
  }

  createFile(name) {
    this.files.push(name);
    console.log(`File '${name}' created.`);
  }

  listFiles() {
    console.log('Files in the system:');
    this.files.forEach(file => console.log(file));
  }
}

const fileSystem = new FileSystemManager();
fileSystem.createFile('document.txt');
fileSystem.createFile('image.jpg');

const anotherFileSystem = new FileSystemManager();
console.log(fileSystem === anotherFileSystem); // 输出: true
anotherFileSystem.listFiles(); // 输出: document.txt \n image.jpg

在这个例子中，FileSystemManager 类用于管理文件系统，确保只有一个实例负责文件的创建和列举。

3. 数据库连接

在需要管理数据库连接的应用中，使用单例模式可以确保只有一个实例负责数据库的连接，提高性能和资源利用率。

class DatabaseConnection {
  constructor() {
    if (!DatabaseConnection.instance) {
      this.isConnected = false;
      DatabaseConnection.instance = this;
    }

    return DatabaseConnection.instance;
  }

  connect() {
    if (!this.isConnected) {
      console.log('Database connected.');
      this.isConnected = true;
    } else {
      console.log('Already connected to the database.');
    }
  }

  disconnect() {
    if (this.isConnected) {
      console.log('Database disconnected.');
      this.isConnected = false;
    } else {
      console.log('Not connected to the database.');
    }
  }
}

const dbConnection = new DatabaseConnection();
dbConnection.connect();
dbConnection.disconnect();

const anotherDbConnection = new DatabaseConnection();
console.log(dbConnection === anotherDbConnection); // 输出: true
anotherDbConnection.connect(); // 输出: Already connected to the database.