浅谈单例模式和策略模式

开启掘金成长之旅！这是我参与「掘金日新计划 · 2 月更文挑战」的第 1 天，点击查看活动详情

设计模式在开发过程中广泛使用，可以提升代码鲁棒性，如何在自己的代码中合理使用设计模式已经成为程序员的一个评价标准，这里就带大家简单了解下单例模式和策略模式，以及这两种模式的使用场景。

单例模式

• 单例模式的定义是：保证一个类仅有一个实例，并提供一个访问它的全局访问点。

核心是保证一个类仅有一个实例。

var single = function (name) {
    this.instance = null;
    this.name = name
};

single.prototype.getName = function () {
    return this.name;
};

single.getInstance = function (name) {  // ①
    if (!this.instance) {
        this.instance = new single(name)
    }
    return this.instance;
};

var a = single.getInstance('tom');
var b = single.getInstance('bob');

console.log(a === b); // true

举个例子，上面我们通过 ① 处实现了只存在一个实例。

但是在js中我们会有一个习惯，基于 new 来实现一个对象，并且因为单一职责原则，我们会将管理单例 和 单例内部方法分开，于是一般会是下面这种

let  ProxySingle = (function () { 
    let instance;
    return function (html) { 
        if (!instance) { 
            instance = new createOne(html)
        }
        return instance
    }
})()

let createOne = function(){}

var a = new ProxySingle('stive');
var b = new ProxySingle('bob');
console.log(a === b); // true

// document.getElementById( 'loginBtn' ).onclick = function(){    // 惰性单例
  // var loginLayer = ProxySingle();
  // loginLayer.style.display = 'block';
//};

当实例只在方法被调用的时候产生的时候，就被称为惰性单例，上面惰性单例case

策略模式

• 定义： 定义一系列的算法，把它们各自封装成策略类，算法被封装在策略类内部的方法里。在客户对Context发起请求的时候，Context 总是把请求委托给这些策略对象中间的某一个进行计算。

策略类的核心是策略类和 context 类， 策略类负责各种算法，context 负责委托给策略类中的其中一个进行计算

var strategies = {
    "S": function( salary ){
      return salary * 4;
    },
    "A": function( salary ){
      return salary * 3;
    },
    "B": function( salary ){
      return salary * 2;
    }
};

var calculateBonus = function( level, salary ){
    return strategies[ level ]( salary );
};

console.log( calculateBonus( 'S', 20000 ) );     // 输出：80000
console.log( calculateBonus( 'A', 10000 ) );     // 输出：30000

这种模式的使用场景是：存在大量的 if-else 时，将条件封装进入策略类中，存在一个 context 去调用不同的策略算法。（在js中，一般策略类就是一个对象，其中各个属性都是策略算法）