在诸如C++或者List着这样的传统语言中,织入模式就是一些提供能够被一个或者一组子类简单继承功能的类,意在重用其功能.

子类划分

对于不熟悉子类划分的开发者,在深入织入模式和装饰器模式之前,我们将对他们进行一个简短的初学者入门指引.
子类划分是一个参考了为一个新对象继承来自一个基类或者超类对象的属性的术语.在传统的面向对象编程中,类B能够从另外一个类A处扩展.这里我们将A看做是超类,而将B看做是A的子类.如此,所有B的实体都从A处继承了其A的方法.然而B仍然能够定义它自己的方法,包括那些重载的原本在A中的定义的方法.
B是否应该调用已经被重载的A中的方法,我们将这个引述为方法链.B是否应该调用A(超类)的构造器,我们将这称为构造器链.
为了演示子类划分,首先我们需要一个能够创建自身新实体的基对象.

  1. var Person =  function( firstName , lastName ){
  3.   this.firstName = firstName;
  4.   this.lastName =  lastName;
  5.   this.gender = "male";
  7. };

接下来,我们将制定一个新的类(对象),它是一个现有的Person对象的子类.让我们想象我们想要加入一个不同属性用来分辨一个Person和一个继承了Person”超类”属性的Superhero.由于超级英雄分享了一般人类许多共有的特征(例如:name,gender),因此这应该很有希望充分展示出子类划分是如何工作的.

  1. // a new instance of Person can then easily be created as follows:
  2. var clark = new Person( "Clark" , "Kent" );
  4. // Define a subclass constructor for for "Superhero":
  5. var Superhero = function( firstName, lastName , powers ){
  7.     // Invoke the superclass constructor on the new object
  8.     // then use .call() to invoke the constructor as a method of
  9.     // the object to be initialized.
  11.     Person.call( this, firstName, lastName );
  13.     // Finally, store their powers, a new array of traits not found in a normal "Person"
  14.     this.powers = powers;
  15. };
  17. SuperHero.prototype = Object.create( Person.prototype );
  18. var superman = new Superhero( "Clark" ,"Kent" , ["flight","heat-vision"] );
  19. console.log( superman ); 
  21. // Outputs Person attributes as well as powers

Superhero构造器创建了一个自Peroson下降的对象。这种类型的对象拥有链中位于它之上的对象的属性,而且如果我们在Person对象中设置了默认的值,Superhero能够使用特定于它的对象的值覆盖任何继承的值.

Mixin(织入目标类)

在Javascript中,我们会将从Mixin继承看作是通过扩展收集功能的一种途径.我们定义的每一个新的对象都有一个原型,从其中它可以继承更多的属性.原型可以从其他对象继承而来,但是更重要的是,能够为任意数量的对象定义属性.我们可以利用这一事实来促进功能重用.
Mix允许对象以最小量的复杂性从它们那里借用(或者说继承)功能.作为一种利用Javascript对象原型工作得很好的模式,它为我们提供了从不止一个Mix处分享功能的相当灵活,但比多继承有效得多得多的方式.
它们可以被看做是其属性和方法可以很容易的在其它大量对象原型共享的对象.想象一下我们定义了一个在一个标准对象字面量中含有实用功能的Mixin,如下所示:

  1. var myMixins = {
  3.   moveUp: function(){
  4.     console.log( "move up" );
  5.   },
  7.   moveDown: function(){
  8.     console.log( "move down" );
  9.   },
  11.   stop: function(){
  12.     console.log( "stop! in the name of love!" );
  13.   }
  15. };

然后我们可以方便的扩展现有构造器功能的原型,使其包含这种使用一个 如下面的score.js_.extends()方法辅助器的行为:

  1. // A skeleton carAnimator constructor
  2. function carAnimator(){
  3.   this.moveLeft = function(){
  4.     console.log( "move left" );
  5.   };
  6. }
  8. // A skeleton personAnimator constructor
  9. function personAnimator(){
  10.   this.moveRandomly = function(){ /*..*/ };
  11. }
  13. // Extend both constructors with our Mixin
  14. _.extend( carAnimator.prototype, myMixins );
  15. _.extend( personAnimator.prototype, myMixins );
  17. // Create a new instance of carAnimator
  18. var myAnimator = new carAnimator();
  19. myAnimator.moveLeft();
  20. myAnimator.moveDown();
  21. myAnimator.stop();
  23. // Outputs:
  24. // move left
  25. // move down
  26. // stop! in the name of love!

如我们所见,这允许我们将通用的行为轻易的”混”入相当普通对象构造器中.
在接下来的示例中,我们有两个构造器:一个Car和一个Mixin.我们将要做的是静Car参数化(另外一种说法是扩展),以便它能够继承Mixin中的特定方法,名叫driveForwar()和driveBackward().这一次我们不会使用Underscore.js.
取而代之，这个示例将演示如何将一个构造器参数化，以便在无需重复每一个构造器函数过程的前提下包含其功能。

  1. // Define a simple Car constructor
  2. var Car = function ( settings ) {
  4.         this.model = settings.model || "no model provided";
  5.         this.color = settings.color || "no colour provided";
  7.     };
  9. // Mixin
  10. var Mixin = function () {};
  12. Mixin.prototype = {
  14.     driveForward: function () {
  15.         console.log( "drive forward" );
  16.     },
  18.     driveBackward: function () {
  19.         console.log( "drive backward" );
  20.     },
  22.     driveSideways: function () {
  23.         console.log( "drive sideways" );
  24.     }
  26. };
  29. // Extend an existing object with a method from another
  30. function augment( receivingClass, givingClass ) {
  32.     // only provide certain methods
  33.     if ( arguments[2] ) {
  34.         for ( var i = 2, len = arguments.length; i < len; i++ ) {
  35.             receivingClass.prototype[arguments[i]] = givingClass.prototype[arguments[i]];
  36.         }
  37.     }
  38.     // provide all methods
  39.     else {
  40.         for ( var methodName in givingClass.prototype ) {
  42.             // check to make sure the receiving class doesn't 
  43.             // have a method of the same name as the one currently 
  44.             // being processed 
  45.             if ( !Object.hasOwnProperty(receivingClass.prototype, methodName) ) {
  46.                 receivingClass.prototype[methodName] = givingClass.prototype[methodName];
  47.             }
  49.             // Alternatively:
  50.             // if ( !receivingClass.prototype[methodName] ) {
  51.             //  receivingClass.prototype[methodName] = givingClass.prototype[methodName];
  52.             // }
  53.         }
  54.     }
  55. }
  58. // Augment the Car constructor to include "driveForward" and "driveBackward"
  59. augment( Car, Mixin, "driveForward", "driveBackward" );
  61. // Create a new Car
  62. var myCar = new Car({
  63.     model: "Ford Escort",
  64.     color: "blue"
  65. });
  67. // Test to make sure we now have access to the methods
  68. myCar.driveForward();
  69. myCar.driveBackward();
  71. // Outputs:
  72. // drive forward
  73. // drive backward
  75. // We can also augment Car to include all functions from our mixin
  76. // by not explicitly listing a selection of them
  77. augment( Car, Mixin );
  79. var mySportsCar = new Car({
  80.     model: "Porsche",
  81.     color: "red"
  82. });
  84. mySportsCar.driveSideways();
  86. // Outputs:
  87. // drive sideways

优点&缺点

Mixin支持在一个系统中降解功能的重复性,增加功能的重用性.在一些应用程序也许需要在所有的对象实体共享行为的地方,我们能够通过在一个Mixin中维护这个共享的功能,来很容易的避免任何重复,而因此专注于只实现我们系统中真正彼此不同的功能.
也就是说,对Mixin的副作用是值得商榷的.一些开发者感觉将功能注入到对象的原型中是一个坏点子,因为它会同时导致原型污染和一定程度上的对我们原有功能的不确定性.在大型的系统中,很可能是有这种情况的.
我认为,强大的文档对最大限度的减少对待功能中的混入源的迷惑是有帮助的,而且对于每一种模式而言,如果在实现过程中小心行事,我们应该是没多大问题的.