摘要：概念模式就是一些提供能夠被一個(gè)或者一組子類簡(jiǎn)單繼承功能的類意在重用其功能。示例下面通過一個(gè)簡(jiǎn)單的例子來演示這個(gè)模式混入模式的實(shí)現(xiàn)不指定特定方法名的時(shí)候，將后者所有的方法都添加到前者里優(yōu)缺點(diǎn)優(yōu)點(diǎn)有助于減少系統(tǒng)中的重復(fù)功能及增加函數(shù)復(fù)用。

Mixin模式就是一些提供能夠被一個(gè)或者一組子類簡(jiǎn)單繼承功能的類,意在重用其功能。在面向?qū)ο蟮恼Z言中，我們會(huì)通過接口繼承的方式來實(shí)現(xiàn)功能的復(fù)用。但是在javascript中，我們沒辦法通過接口繼承的方式，但是我們可以通過javascript特有的原型鏈屬性，將功能引用復(fù)制到原型鏈上，達(dá)到功能的注入。

下面通過一個(gè)簡(jiǎn)單的例子來演示這個(gè)模式

var Car = function(settings) {
  this.model = settings.model || "no model provided"
  this.color = settings.color || "no color provided"
}

var Mixin = function() {}

Mixin.prototype = {
  driveForward: function() {
    console.log("drive forward")
  },
  driveBackward: function() {
    console.log("drive backward")
  },
  driveSideways: function() {
    console.log("drive sideways")
  }
}

//混入模式的實(shí)現(xiàn)
function Merge(recClass, giveClass) {
  if(arguments.length > 2) {
    for(var i = 2, lenth = arguments.length; i < lenth ; ++ i) {
      var methodName = arguments[i]
      recClass.prototype[methodName] = giveClass.prototype[methodName]
    }
  }else {
    for(var methodName in giveClass.prototype) {
      if(!recClass.prototype[methodName]) {
        recClass.prototype[methodName] = giveClass.prototype[methodName]
      }
    }
  }
}

Merge(Car, Mixin, "driveForward", "driveBackward")

var myCar = new Car({
  model: "BMW",
  color: "blue"
})

myCar.driveForward()    //drive forward
myCar.driveBackward()   //drive backward

//不指定特定方法名的時(shí)候，將后者所有的方法都添加到前者里
Merge(Car, Mixin)

var mySportsCar = new Car({
  model: "Porsche",
  color: "red"
})

mySportsCar.driveForward()  //drive forward

優(yōu)點(diǎn)
有助于減少系統(tǒng)中的重復(fù)功能及增加函數(shù)復(fù)用。當(dāng)一個(gè)應(yīng)用程序可能需要在各種對(duì)象實(shí)例中共享行為時(shí)，我們可以通過在Mixin中維持這種共享功能并專注于僅實(shí)現(xiàn)系統(tǒng)中真正不同的功能，來輕松避免任何重復(fù)。

缺點(diǎn)
有些人認(rèn)為將功能注入對(duì)象原型中會(huì)導(dǎo)致原型污染和函數(shù)起源方面的不確定性。

vue中關(guān)于混入的代碼目錄/src/core/global-api/mixin.js
可以看到vue源碼中是通過mergeOptions來合并配置到options上

export function initMixin (Vue: GlobalAPI) {
  Vue.mixin = function (mixin: Object) {
    this.options = mergeOptions(this.options, mixin)
    return this
  }
}

下面我們來看合并配置的相關(guān)代碼/src/core/instance/init.js
當(dāng)執(zhí)行new Vue的時(shí)候options._isComponent為false，會(huì)走else的分支

export function initMixin (Vue: Class) {
  Vue.prototype._init = function (options?: Object) {
    const vm: Component = this
    // a uid
    vm._uid = uid++

    let startTag, endTag
    /* istanbul ignore if */
    if (process.env.NODE_ENV !== "production" && config.performance && mark) {
      startTag = `vue-perf-start:${vm._uid}`
      endTag = `vue-perf-end:${vm._uid}`
      mark(startTag)
    }

    // a flag to avoid this being observed
    vm._isVue = true
    // merge options
    if (options && options._isComponent) {
      // optimize internal component instantiation
      // since dynamic options merging is pretty slow, and none of the
      // internal component options needs special treatment.
      initInternalComponent(vm, options)
    } else {
      vm.$options = mergeOptions(  //合并配置
        resolveConstructorOptions(vm.constructor),
        options || {},
        vm
      )
    }
    /* istanbul ignore else */
    if (process.env.NODE_ENV !== "production") {
      initProxy(vm)
    } else {
      vm._renderProxy = vm
    }
    // expose real self
    vm._self = vm
    initLifecycle(vm)
    initEvents(vm)
    initRender(vm)
    callHook(vm, "beforeCreate")
    initInjections(vm) // resolve injections before data/props
    initState(vm)
    initProvide(vm) // resolve provide after data/props
    callHook(vm, "created")

    /* istanbul ignore if */
    if (process.env.NODE_ENV !== "production" && config.performance && mark) {
      vm._name = formatComponentName(vm, false)
      mark(endTag)
      measure(`vue ${vm._name} init`, startTag, endTag)
    }

    if (vm.$options.el) {
      vm.$mount(vm.$options.el)
    }
  }
}

下面來看mergeOptions的實(shí)現(xiàn)src/core/util/options.js
mergeField將this.options(parent)和需要混入的對(duì)象mixin(child)合并在this.options上面

/**
 * Merge two option objects into a new one.
 * Core utility used in both instantiation and inheritance.
 */
export function mergeOptions (
  parent: Object,
  child: Object,
  vm?: Component
): Object {
  if (process.env.NODE_ENV !== "production") {
    checkComponents(child)
  }

  if (typeof child === "function") {
    child = child.options
  }

  normalizeProps(child, vm)
  normalizeInject(child, vm)
  normalizeDirectives(child)
  const extendsFrom = child.extends
  if (extendsFrom) {
    parent = mergeOptions(parent, extendsFrom, vm)
  }
  if (child.mixins) {
    for (let i = 0, l = child.mixins.length; i < l; i++) {
      parent = mergeOptions(parent, child.mixins[i], vm)
    }
  }
  const options = {}
  let key
  for (key in parent) {
    mergeField(key)
  }
  for (key in child) {
    if (!hasOwn(parent, key)) {
      mergeField(key)
    }
  }
  function mergeField (key) {
    const strat = strats[key] || defaultStrat
    options[key] = strat(parent[key], child[key], vm, key)
  }
  return options
}

《JavaScript設(shè)計(jì)模式》

JS設(shè)計(jì)模式之Obeserver（觀察者）模式、Publish/Subscribe（發(fā)布/訂閱）模式
JS設(shè)計(jì)模式之Factory（工廠）模式
JS設(shè)計(jì)模式之Singleton（單例）模式
JS設(shè)計(jì)模式之Facade（外觀）模式
JS設(shè)計(jì)模式之Module（模塊）模式、Revealing Module（揭示模塊）模式
JS設(shè)計(jì)模式之Mixin（混入）模式