回调到动态对象

Question

this.a = new A()
this.b = new B()

// point b callback to a member of object a
this.b.setCallback(this.a.mycallback)

// initiate callback
this.b.doCallback() // calls this.a->mycallback()

// ..... later on
// replace this.a with a new object
this.a = new A()

// callback is broken now?
this.b.doCallback()

How can I make the callback method of this.b point to the member of this.a regardless whether this.a is replaced with a new instance? In other words have it resolved dynamically?

I know how to do this in other languages but for some reason in Javascript I can not seem to figure it out.

[edit]

The problem seems to be something different. The callback functions were already declared in the prototype of the object. But now I've isolated the problem I think.

Below you see a piece of code from my object. It contains 2 member objects. One player and one waveform. The player is something which is instantiated dynamically after a new url is available. I want the waveform to make a callback, named "seek", to a member of this.player, even after the object changed.

This doesn't seem to work:

//  placeholder, object is instantiated later
    this.player = {}

    var self = this

    this.waveform = new Waveform(this.waveformDiv, {
        seek : self.player.seek,
    })
    // after this point this.player can be instantiated multiple times with 
    // different Player objects. I want the callback to seek to point to the new instance.

... but it DOES work once I set the seek option using an anonymous function:

seek : function(time){ self.player.seek(time)},

I would like to understand why the 2 approaches are fundamentally different.

Answer 1

Add mycallback to prototype of A.

A.prototype.mycallback = function (...) {...};

After this any instance of A will have mycallback.

Answer 2

I think I can answer my own question now.

seek : self.player.seek 

This creates a direct reference to the player object method seek. Because it is a reference to the specific instance method this breaks as soon as player is replaced with a different instance. The player location in memory changes and so will its member function locations.

seek : function(time){ self.player.seek(time)}

This time a function is created and seek holds a reference to the function. This is not linked to the player instance directly. When seek is called, the function is executed and the variables in the function are evaluated on every call. So when the function executes self.player is looked up and will point to the correct/new player object.