javascript设计模式-装饰者

发布时间:2024年01月21日

装饰者

基本实现

是一种为对象增加我的技术,它并不使用创建新子类手段,一切都在动态完成。这个过程相对于使用者来说是透明的。透明地把对象包装在具有同样接口的另一个对象之中。

比如可以动态的为自行车对象添加可选的特色配件上。比如添加4个选件,可以新定义4个超类,但如果自行车种类过多,则需要派生出N多子类。基本是不可以维护。如果用装饰者,只需要维护4个类即可,一个选件一个类。通过装饰加在各个原有的自行车上。

缺点在于,在遇到用装饰者包装起来的对象时,那些依赖于类型检查的代码会出问题,所以在设计此模式的类时不要使用类型检查。另外一点这种模式常常要引入许多小对象,它们看起来差不多,实际功能却大相径庭。所以使用此模式时要仔细,因为它的代码和API都不容易设计和使用。它的架构如下:

/* The Bicycle interface. */
var Bicycle = new Interface('Bicycle', ['assemble', 'wash', 'getPrice']);

/* 自行车实例. */
var AcmeComfortCruiser = function() { };// implements Bicycle
AcmeComfortCruiser.prototype = {
  assemble: function() {
  },
  wash: function() {
  },
  getPrice: function() {
    return 399.00;
  }
};
/* 选件类,其实就是装饰者类,所有自行车和装饰者都需要实现Bicycle接口.装饰者模式颇多得益于接口的使用,其最重要的特点之一就是它可以用来替代组件,原来使用AcmeComfortCruiser的地方都可以用装饰类来代替而不用修改源代码,下面的装饰类对原类的两个方法进行了装饰。 * 下面的superclass是个自定义的属性,是在extends方法中加上的*/
var HeadlightDecorator = function(bicycle) { // implements Bicycle
    HeadlightDecorator.superclass.constructor.call(this, bicycle);
}
extend(HeadlightDecorator, BicycleDecorator); // Extend the superclass.
HeadlightDecorator.prototype.assemble = function() {
  return this.bicycle.assemble() + ' Attach headlight to handlebars.';
};
HeadlightDecorator.prototype.getPrice = function() {
  return this.bicycle.getPrice() + 15.00;
};
var myBicycle= newAcmeComfortCruiser();//裸自行车
var myBicycle = new TaillightDecorator(myBicycle); //加了一个篮子
myBicycle = new TaillightDecorator(myBicycle); //又加了另一个篮子
alert(myBicycle.getPrice());  //得到最终的价格

简单的组合模式和装饰者模式基本一样,但有些本质的区别,组合对象并不修改方法调用,其着眼于组织对象。而装饰者存在的唯一目的就是修改方法调用而不是组织子对象,因为子对象只有一个。

装饰者的作用在于以某种方式对其组件对象的行为进行修改。这种修改可以体现在方法之前、之后添加行为或是直接替换方法,甚至添加新的方法。

上例中一次只能添加一个选件,如果多个选件,需要多次调用即可。

HeadlightDecorator.prototype.getPrice = function() {
  return this.bicycle.getPrice() + 15.00;//之后};
var FrameColorDecorator = function(bicycle, frameColor) { //implements Bicycle
  this.superclass.constructor(bicycle); // Call the superclass's constructor.
  this.frameColor = frameColor;
}
extend(FrameColorDecorator, BicycleDecorator); // Extend the superclass.FrameColorDecorator.prototype.assemble = function() {
  return 'Paint the frame ' + this.frameColor + ' and allow it to dry. ' + 
      this.bicycle.assemble();//之前,注意这个参数的传递};
LifetimeWarrantyDecorator.prototype.repair = function() {
  return 'This bicycle is covered by a lifetime warranty. Please take it to ' +'an authorized Acme Repair Center.';
};//直接替换掉原来的方法实现

添加新方法时需要注意,因为接口中并没有声明,又不适合直接改接口,这样很多装饰子类中可能会有很多无用的代码,最好的方法是使用一种称为pass-through method的技术,暂时没搞清楚其运行机制。

OUTERLOOP:对组件对象进行检查 ,并为其拥有的每一个方法创建一个通道方法。这样在装饰类外再套上另一个装饰者的话,内层装饰者定义的新方法仍然可以访问。这样不用担心新创建的方法无法访问了。

var Bicycle = new Interface('Bicycle', ['assemble', 'wash', 'getPrice']);
/* 自行车实例. */
var AcmeComfortCruiser = function() { };// implements Bicycle
AcmeComfortCruiser.prototype = {
    assemble: function() {
    },
    wash: function() {
    },
    getPrice: function() {
        return 399.00;
    }
};
var BicycleDecorator = function(bicycle) { // implements Bicycle
    this.bicycle = bicycle;
    this.interface = Bicycle;
    //这处会自动循环,通过另一种方式代替方法的调用,见最后    outerloop: for(var key in this.bicycle) {
        // Ensure that the property is a function.
        if(typeof this.bicycle[key] !== 'function') {
            continue outerloop;
        }
        for(var i = 0, len = this.interface.methods.length; i < len; i++) {
            if(key === this.interface.methods[i]) {
                continue outerloop;
            }
        }
        // Add the new method.
        var that = this;
        (function(methodName) {
            that[methodName] = function() {
                return that.bicycle[methodName]();
            };
        })(key);
    }
}
BicycleDecorator.prototype = {
    assemble: function() {
        return this.bicycle.assemble();
    },
    wash: function() {
        return this.bicycle.wash();
    },
    getPrice: function() {
        console.log('4');
        return this.bicycle.getPrice();
    }
};
var HeadlightDecorator = function(bicycle) { // implements Bicycle
    HeadlightDecorator.superclass.constructor.call(this, bicycle);
}
extend(HeadlightDecorator, BicycleDecorator); // Extend the superclass.
HeadlightDecorator.prototype.assemble = function() {
    return this.bicycle.assemble() + ' Attach headlight to handlebars.';
};
HeadlightDecorator.prototype.getPrice = function() {
    console.log('3');
    return this.bicycle.getPrice() + 15.00;
};
var TaillightDecorator = function(bicycle) { // implements Bicycle
    TaillightDecorator.superclass.constructor.call(this, bicycle);
}
extend(TaillightDecorator, BicycleDecorator); // Extend the superclass.
TaillightDecorator.prototype.assemble = function() {
    return this.bicycle.assemble() + ' Attach taillight to the seat post.';
};
TaillightDecorator.prototype.getPrice = function() {
    console.log('2');
    return this.bicycle.getPrice() + 9.00;
};
TaillightDecorator.prototype.ringBell = function() {
    console.log('1');
    return 'Bell rung.';
};
var c = new AcmeComfortCruiser();
c = new TaillightDecorator(c);
c = new HeadlightDecorator(c);
console.log(c.ringBell());//无论什么顺序都会调用console.log(c.getPrice());//423

有些时候装饰者的应用顺序很重要,但在理想情况下,装饰者应该能以一种完全与顺序无关的方式创建。如果必须要以某种顺序调用,可以结合工厂一般可以办到。某些装饰者修改组件方法的方式决定了它们需要最先或最后被应用,在此情况下工厂的作用就尤为重要。

函数装饰者

也可以用装饰者来装饰函数,通过把函数当作参数传递。在PYTHON语言中这是一个核心应用。它对函数的输出应用某种格式或执行某种转换方面非常有用。

文章来源:https://blog.csdn.net/liudonglovehemin/article/details/135728408
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。