Is there a good pattern for JavaScript calling overridden functions in a parent without knowing the specific parent?

Question

Basically I want inheritable functions as in

Base = function() { };

Base.prototype.foo = function() {
  console.log("base foo");
};

Derived = function() { };

somelib.inherit(Derived, Base);

Derived.prototype.foo = function() {
  console.log("derived foo");
}

d = new Derived():
d.foo();

And I want it to print

derived foo
base foo

Yes I know I can explicitly call Base.prototype.foo.call(this); I'm just wondering if there is a pattern for calling overridden super class functions automatically. The problem I'm trying to solve is 2 fold.

1. derived classes should NOT have to remember to call their parent's method, it just happens automatically.
2. if 1. can't happen then at least I'd like Derived not to call Base by name since that's brittle. Rather I'd like it call parentclass or something so you don't have to know the base. That way if you change the name of the base you don't have to go fixing every derived class.

Answer 1

You can implement such functionality by using a structure like:

function Base(){}
Base.prototype.destroy = function(){console.log('Base destroy');};

function Derived(){}
Derived.prototype = new Base; // Let Derived inherit from Base

// Override the `destroy` method
Derived.prototype.destroy = function() {
    console.log('Derived destroy');

    // Call parent class method
    this.constructor.prototype.destroy();
    // If the context of the method is important, you can use Function.call:
  //this.constructor.prototype.destroy.call(this);
};


// Create an instance of Derived, and call the destroy method:
(new Derived).destroy();