JavaScript设计模式-模板方法

模板方法模式

模板方法由两部分组成，第一部分就是抽象父类，第二部分就是具体实现的子类。通常是抽象父类中封装了子类的算法框架，包括实现一些共有的方法以及封装子类所有的方法的执行顺序，子类可以通过继承这个抽象类，也继承了整个算法结构，并且可以选择重写父类的方法。模板方法中，子类实现中的相同部分被上移到父类中，而将不同的部分留待子类中实现。这也是很好地体现了泛化的思想。

var Beverage = function () {}

Beverage.prototype.boilWater = function () {
  console.log('把水煮开')
}

Beverage.prototype.brew = function () {
  // 空方法子类重写
  throw new Error('子类方法必须重写')
}

Beverage.prototype.pourInCup = function () {
  // 空方法子类重写
  throw new Error('子类方法必须重写')
}

Beverage.prototype.addCondiments = function () {
  // 空方法子类重写
  throw new Error('子类方法必须重写')
}

Beverage.prototype.init = function () {
  this.boilWater()
  this.brew()
  this.pourInCup()
  this.addCondiments()
}


子类继承方法
var Coffee = function () {}
Coffee.prototype = new Beverage()

Coffee.prototype.brew = function () {
  console.log(1)
}

Coffee.prototype.pourInCup = function () {
  console.log(1)
}

Coffee.prototype.addCondiments = function () {
  console.log(1)
}

var coffee = new Coffee()
coffee.init()

模板方法就是上面的Beverage.prototype.init，抛出错误是为了防止子类没有重写方法

钩子方法

通过模板方法，我们在父类封装了子类的算法框架，这些框架在正常状态下适用于大多数子类，但是有一些特别的子类不需要某个过程，钩子方法可用用来解决这个问题，钩子可以有一个默认的实现，究竟要不要挂钩，这由子类自行决定

var Beverage = function () {}

Beverage.prototype.boilWater = function () {
  console.log('把水煮开')
}

Beverage.prototype.brew = function () {
  // 空方法子类重写
  throw new Error('子类方法必须重写')
}

Beverage.prototype.pourInCup = function () {
  // 空方法子类重写
  throw new Error('子类方法必须重写')
}

Beverage.prototype.addCondiments = function () {
  // 空方法子类重写
  throw new Error('子类方法必须重写')
}

// 钩子方法
Beverage.prototype.isAddCondiments = function () {
  return true
}


Beverage.prototype.init = function () {
  this.boilWater()
  this.brew()
  this.pourInCup()
  if (this.isAddCondiments) {
     this.addCondiments() 
  }
}


子类继承方法
var Coffee = function () {}
Coffee.prototype = new Beverage()

Coffee.prototype.brew = function () {
  console.log(1)
}

Coffee.prototype.pourInCup = function () {
  console.log(1)
}

Coffee.prototype.addCondiments = function () {
  console.log(1)
}

Coffee.prototype.isAddCondiments = function () {
  return window.confirm('1111')
}

var coffee = new Coffee()
coffee.init()

用模板方法编写的程序，意味着子类放弃对自己的控制权，而是改为父类通知子类那些方法在什么时候被调用，作为子类就负责一些设计上的细节

var Beverage = function (params) {
  var boilWater = function () {
    console.log('把水煮开')
  }
  
  var brew = params.brew || function () {
    // 空方法子类重写'
    throw new Error('子类方法必须重写')
  }
  
  var pourInCup = params.pourInCup || function () {
    // 空方法子类重写
    throw new Error('子类方法必须重写')
  }
  
  var addCondiments = params.addCondiments || function () {
    // 空方法子类重写
    throw new Error('子类方法必须重写')
  }

  var F = function () {}
  F.prototype.init = function() {
    boilWater()
    brew()
    pourInCup()
    addCondiments()
  }
  return F
}



var Coffee = Beverage({
  brew: function () {
    console.log(1)
  },
  pourInCup: function () {
    console.log(1)
  },
  addCondiments: function () {
    console.log(1)
  }
})

var coffee = new Coffee()
coffee.init()

这段代码中，F类中含有模板方法

小结

模板方法是一种典型的通过封装变化提高系统拓展性的设计模式，子类的方法种类和执行顺序是不变的，所有吧这部分的逻辑抽象到父类的模板方法中，子类的方法具体怎么实现则是可变的，于是把这部分变化的逻辑封装到子类中，通过增加新的子类，我们便能给系统增加新的功能，并不需要改动抽象父类以及其他子类，这也符合开发-封闭原则的，很多时候我们不需要依样画瓢去实现一个模板方法模式，高阶函数是最好的选择