制作者形式

将一个庞杂的构建与其示意相星散，使得一样的构建历程能够建立差别的示意。重要处理在软件体系中，有时候面临着”一个庞杂对象”的建立事情，因为需求的变化，这个庞杂对象的某些部份常常面临着猛烈的变化，一些基础部件不会变。所以须要将变与稳定星散。与笼统工场的区分：在制作者形式里，有个指点者(Director)，由指点者来治理制作者，用户是与指点者联络的，指点者联络制作者末了获得产物。即制作者形式能够强迫执行一种分步骤举行的制作历程。

制作者形式四要素

1.产物类Product：平常是一个较为庞杂的对象，也就是说建立对象的历程比较庞杂，平常会有比较多的代码量。
2.笼统制作者类Builder: 将制作的详细历程交与它的子类来完成，如许更轻易扩大。
3.制作者类ConcreteBuilder: 组建产物；返回组建好的产物。
4.指点类Director: 担任挪用恰当的制作者来组建产物，指点类平常不与产物类发作依靠关联，与指点类直接交互的是制作者类

制作者形式长处

1.制作者形式的封装性很好。运用制作者形式能够有用的封装变化，在运用制作者形式的场景中，平常产物类和制作者类是比较稳定的，因而，将重要的营业逻辑封装在指点者类中对整体而言能够获得比较好的稳定性。
2.制作者形式很轻易举行扩大。如果有新的需求，经由过程完成一个新的制作者类就能够完成。

举例

好像很笼统。举个例子：前面你建立了一个临盆保时捷的工场，临盆一台保时捷911须要的重要部件都一样(引擎，轮子，方向盘…)和流程是稳定的，变的是引擎，轮子，控制体系等等部件详细完成，这些部件的临盆交由详细的builder去临盆。

代码

//制作者形式
var DP = require("./DesignPattern.js");

function Car() {
  var _frame, _engine, _wheel;
  this.setFrame = function (val) {
    _frame = val;
  };
  this.setEngine = function (val) {
    _engine = val;
  };
  this.setWheel = function (val) {
    _wheel = val;
  };
  this.getFrame = function () {
    return _frame
  };
  this.getEngine = function () {
    return _engine
  };
  this.getWheel = function () {
    return _wheel
  };
  this.check = function () {
    console.log(_frame + '搜检终了');
    console.log(_engine + '搜检终了');
    console.log(_wheel + '搜检终了');
  };
}

//笼统临盆者
function Builder() {
  DP.Interface(this, ['buildFrame', 'buildEngine', 'buildWheel', 'buildCar'])
}

//指点者,产物临盆流程范例
function Director(Builder) {
  //传入详细制作者
  var _builder = Builder;
  this.build = function () {
    _builder.buildFrame();
    _builder.buildEngine();
    _builder.buildWheel();
    return _builder.buildCar();
  };
}

function Builder911() {
  this.__proto__ = new Builder();
  var _car = new Car();
  this.buildFrame = function () {
    console.log('制作911骨架');
    _car.setFrame('911骨架');
  };
  this.buildEngine = function () {
    console.log('制作911引擎');
    _car.setEngine('911引擎');
  };
  this.buildWheel = function () {
    console.log('制作911轮子');
    _car.setWheel('911轮子');
  };
  this.buildCar = function () {
    console.log('911汽车各部组装终了');
    return _car;
  };
}

function BuilderCayma() {
  this.__proto__ = new Builder();
  var _car = new Car();
  this.buildFrame = function () {
    console.log('制作Cayma骨架');
    _car.setFrame('Cayma骨架');
  };
  this.buildEngine = function () {
    console.log('制作Cayma引擎');
    _car.setEngine('Cayma引擎');
  };
  this.buildWheel = function () {
    console.log('制作Cayma轮子');
    _car.setWheel('Cayma轮子');
  };
  this.buildCar = function () {
    console.log('Cayma汽车各部组装终了');
    return _car;
  };
}

var builder911 = new Builder911();
var director911 = new Director(builder911);
var car911 = director911.build();
car911.check();

var builderCayma = new BuilderCayma();
var directorCayma = new Director(builderCayma);
var Cayma = directorCayma.build();
Cayma.check();

实用场景

须要天生的对象具有庞杂的内部结构；须要天生的对象内部属性自身相互依靠。