Zugriff auf die übergeordnete Klasse in Backbone

Ich muss die initializeMethode der übergeordneten Klasse innerhalb der geerbten Klasse MyModelaufrufen, anstatt sie wie heute vollständig zu überschreiben.

Wie könnte ich das machen?

So sieht mein Code gerade aus:

BaseModel = Backbone.Model.extend({
    initialize: function(attributes, options) {
        // Do parent stuff stuff
    }
});

MyModel = BaseModel.extend({
    initialize: function() {
        // Invoke BaseModel.initialize();
        // Continue doing specific stuff for this child-class.
    },
});

MyModel = BaseModel.extend({
    initialize: function() {
        MyModel.__super__.initialize.apply(this, arguments);
        // Continue doing specific stuff for this child-class.
    },
});

Versuchen

MyModel = BaseModel.extend({
    initialize: function() {
        BaseModel.prototype.initialize.apply(this, arguments);
        // Continue doing specific stuff for this child-class.
    },
});

Dies funktionierte für mich, als ich versuchte, unter meinen Modellen zu erben:

MyModel.prototype.initialize.call(this, options);

Referenziert von http://documentcloud.github.com/backbone/#Model-extend

Vielen Dank.

Ich denke es wäre

MyModel = BaseModel.extend({
    initialize: function() {
        this.constructor.__super__.initialize.call(this);
        // Continue doing specific stuff for this child-class.
    },
});

Dies scheint fast ein Duplikat von Super in Backbone zu sein , also möchten Sie so etwas:

Backbone.Model.prototype.initialize.call(this);

Ähnlich wie @wheresrhys, aber ich würde apply anstelle von call verwenden, falls BaseModel.initialize Argumente erwartet. Ich versuche zu vermeiden, die Attributzuordnung zu verarbeiten, die bei der Initialisierung an ein Backbone-Modell übergeben werden kann. Wenn das BaseModel jedoch tatsächlich eine Ansicht oder eine Sammlung wäre, möchte ich möglicherweise Optionen festlegen.

var MyModel = BaseModel.extend({
    initialize: function() {
        this.constructor.__super__.initialize.apply(this, arguments);
        // Continue doing specific stuff for this child-class.
    },
});

Hier ist eine CallSuper-Methode für mehrere Generationen. Fügen Sie sie einfach Ihrer erweiterten Klasse hinzu.

callSuper: function (methodName) {
    var previousSuperPrototype, fn, ret;

    if (this.currentSuperPrototype) {
        previousSuperPrototype = this.currentSuperPrototype;
        // Up we go
        this.currentSuperPrototype = this.currentSuperPrototype.constructor.__super__;
    } else {
        // First level, just to to the parent
        this.currentSuperPrototype = this.constructor.__super__;
        previousSuperPrototype = null;
    }

    fn = this.currentSuperPrototype[methodName];

    ret = (arguments.length > 1) ? fn.apply(this, Array.prototype.slice.call(arguments, 1)) : fn.call(this);

    this.currentSuperPrototype = previousSuperPrototype;

    return ret;
}

Sie können Ihren Code mithilfe der funktionalen Vererbung neu schreiben.

var BackBone=function(){
    var that={};

    that.m1=function(){

   };
   return that;

};

var MyModel=function(){

 var that=BackBone();
 var original_m1=that.m1;

//overriding of m1
 that.m1=function(){
    //call original m1
 original_m1();
 //custom code for m1
  };
};