Prototype chain: call “super” method over multiple

Question

I have got the following prototype chain

• SuperSuperClass
  • SuperClass
    • Class

each with a method named do.

What is the common approach for calling the respective super class method?
For the moment I use <ClassName>.prototype.__proto__.<methodName>.call(this) but that looks odd.

Using the following code the console prints (as expected):

• Class.prototype.do
• SuperClass.prototype.do
• SuperSuperClass.prototype.do

SuperSuperClass = function SuperSuperClass() {}
SuperSuperClass.prototype.do = function() {
    console.log('SuperSuperClass.prototype.do');
};

function SuperClass() {
    SuperSuperClass.call(this);
}
SuperClass.prototype = Object.create(SuperSuperClass.prototype);
SuperClass.prototype.constructor = SuperClass;
SuperClass.prototype.do = function() {
    console.log('SuperClass.prototype.do');
    SuperClass.prototype.__proto__.do.call(this);
};

function Class() {
    SuperClass.call(this);
}
Class.prototype = Object.create(SuperClass.prototype);
Class.prototype.constructor = Class;
Class.prototype.do = function() {
    console.log('Class.prototype.do');
    Class.prototype.__proto__.do.call(this);
};

var objClass = new Class();
objClass.do();

JSFiddle

Answer 1

What is the common approach for calling the respective super class method?

Use <SuperClassName>.prototype.<methodName>.call(this). It's not only shorter, but also has the benefit of working in environments that don't support the non-standard __proto__ property.