JavaScript设计模式之单例模式原理与用法实例分析

什么是单例模式？

单例模式是一种经典的设计模式，它保证一个类只有一个实例并提供一个全局的访问点。在JavaScript中，单例模式可以用于创建唯一的全局对象。

单例模式的应用场景

单例模式的应用场景非常广泛，例如：

1. 管理页面中的全局状态，例如Vue.js中的store
2. 缓存数据，例如浏览器中的localStorage
3. 控制某些资源的访问，例如线程池
4. 避免重复实例化某些对象，例如弹窗、对话框等

单例模式的实现方式

单例模式的实现方式有很多种，下面介绍其中的两种。

第一种方式：使用闭包实现单例模式

var Singleton = (function () {
  var instance;

  function init() {
    // 私有方法和属性
    function privateMethod() {
      console.log('This is a private method');
    }

    var privateVariable = 'This is a private variable';

    // 公有方法和属性
    return {
      publicMethod: function () {
        console.log('This is a public method');
      },
      publicVariable: 'This is a public variable'
    };
  }

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

// 使用单例模式创建一个对象
var mySingleton1 = Singleton.getInstance();
var mySingleton2 = Singleton.getInstance();

// 判断是否为同一个对象
console.log(mySingleton1 === mySingleton2);  // true

第二种方式：使用ES6 class实现单例模式

class Singleton {
  constructor() {
    if (!Singleton.instance) {
      // 私有方法和属性
      function privateMethod() {
        console.log('This is a private method');
      }

      let privateVariable = 'This is a private variable';

      // 公有方法和属性
      this.publicMethod = function () {
        console.log('This is a public method');
      };

      this.publicVariable = 'This is a public variable';

      Singleton.instance = this;
    }
    return Singleton.instance;
  }
}

// 使用单例模式创建一个对象
const mySingleton1 = new Singleton();
const mySingleton2 = new Singleton();

// 判断是否为同一个对象
console.log(mySingleton1 === mySingleton2);  // true

单例模式的优缺点

单例模式的优点是：

1. 单例模式可以避免重复创建对象，提高性能和减少内存消耗
2. 单例模式提供了一个全局访问点，方便其他组件或模块获取单例对象的引用

单例模式的缺点是：

1. 单例模式会使代码变得更加复杂
2. 单例模式不易于扩展和修改

示例说明

一个常见的应用场景是管理网页中的全局状态，例如Vue.js中的store。我们可以使用单例模式来创建一个store对象，然后在组件中引用这个对象并修改相应的状态。

class Store {
  constructor() {
    if (!Store.instance) {
      // 初始状态
      this.state = {
        counter: 0
      };

      Store.instance = this;
    }
    return Store.instance;
  }

  // 更新状态的方法
  updateState(key, value) {
    this.state[key] = value;
  }
}

// 使用单例模式创建一个store对象
const myStore = new Store();

// 在组件中使用store对象
myStore.updateState('counter', myStore.state.counter + 1);

另一个应用场景是创建一个线程池，在有任务时从池中取出一个线程执行任务。我们可以使用单例模式来创建一个线程池的管理器对象，以保证线程池的唯一性和线程的安全性。

class ThreadPool {
  constructor() {
    if (!ThreadPool.instance) {
      // 线程池
      this.pool = [];

      ThreadPool.instance = this;
    }
    return ThreadPool.instance;
  }

  // 添加线程
  addThread(thread) {
    this.pool.push(thread);
  }

  // 删除线程
  removeThread(thread) {
    const index = this.pool.indexOf(thread);
    if (index > -1) {
      this.pool.splice(index, 1);
    }
  }

  // 取出一个线程执行任务
  getThread() {
    if (this.pool.length > 0) {
      return this.pool.shift();
    }
    return null;
  }
}

// 使用单例模式创建一个线程池管理器对象
const threadPool = new ThreadPool();

// 添加一个线程
threadPool.addThread('Thread 1');

// 取出一个线程执行任务
const thread = threadPool.getThread();
console.log(thread);  // "Thread 1"