对于多级原型查找，有一个更简单、更紧凑的解决方案，但它需要Proxy支持。用法:SUPER(<实例>).<方法>(<参数>)，例如，假设两个类A和B用方法m扩展了A: SUPER(新B).m()。

function SUPER(instance) {
    return new Proxy(instance, {
        get(target, prop) {
            return Object.getPrototypeOf(Object.getPrototypeOf(target))[prop].bind(target);
        }
    });
}

以Douglas Crockford的想法为基础

    function Shape(){}

    Shape.prototype.name = 'Shape';

    Shape.prototype.toString = function(){
        return this.constructor.parent
            ? this.constructor.parent.toString() + ',' + this.name
            : this.name;
    };


    function TwoDShape(){}

    var F = function(){};

    F.prototype = Shape.prototype;

    TwoDShape.prototype = new F();

    TwoDShape.prototype.constructor = TwoDShape;

    TwoDShape.parent = Shape.prototype;

    TwoDShape.prototype.name = '2D Shape';


    var my = new TwoDShape();

    console.log(my.toString()); ===> Shape,2D Shape

在多重继承级别的情况下，此函数可以在其他语言中用作super()方法。这是一个演示，一些测试，你可以这样使用它，在你的方法使用:call_base(this， 'method_name'，参数);

它使用了最新的ES功能，与旧浏览器的兼容性不能保证。在IE11, FF29, CH35中测试。

/**
 * Call super method of the given object and method.
 * This function create a temporary variable called "_call_base_reference",
 * to inspect whole inheritance linage. It will be deleted at the end of inspection.
 *
 * Usage : Inside your method use call_base(this, 'method_name', arguments);
 *
 * @param {object} object The owner object of the method and inheritance linage
 * @param {string} method The name of the super method to find.
 * @param {array} args The calls arguments, basically use the "arguments" special variable.
 * @returns {*} The data returned from the super method.
 */
function call_base(object, method, args) {
    // We get base object, first time it will be passed object,
    // but in case of multiple inheritance, it will be instance of parent objects.
    var base = object.hasOwnProperty('_call_base_reference') ? object._call_base_reference : object,
    // We get matching method, from current object,
    // this is a reference to define super method.
            object_current_method = base[method],
    // Temp object wo receive method definition.
            descriptor = null,
    // We define super function after founding current position.
            is_super = false,
    // Contain output data.
            output = null;
    while (base !== undefined) {
        // Get method info
        descriptor = Object.getOwnPropertyDescriptor(base, method);
        if (descriptor !== undefined) {
            // We search for current object method to define inherited part of chain.
            if (descriptor.value === object_current_method) {
                // Further loops will be considered as inherited function.
                is_super = true;
            }
            // We already have found current object method.
            else if (is_super === true) {
                // We need to pass original object to apply() as first argument,
                // this allow to keep original instance definition along all method
                // inheritance. But we also need to save reference to "base" who
                // contain parent class, it will be used into this function startup
                // to begin at the right chain position.
                object._call_base_reference = base;
                // Apply super method.
                output = descriptor.value.apply(object, args);
                // Property have been used into super function if another
                // call_base() is launched. Reference is not useful anymore.
                delete object._call_base_reference;
                // Job is done.
                return output;
            }
        }
        // Iterate to the next parent inherited.
        base = Object.getPrototypeOf(base);
    }
}

对于多级原型查找，有一个更简单、更紧凑的解决方案，但它需要Proxy支持。用法:SUPER(<实例>).<方法>(<参数>)，例如，假设两个类A和B用方法m扩展了A: SUPER(新B).m()。

function SUPER(instance) {
    return new Proxy(instance, {
        get(target, prop) {
            return Object.getPrototypeOf(Object.getPrototypeOf(target))[prop].bind(target);
        }
    });
}

更灵活的答案与经典的js。

你在子类中定义了"_parent = A.prototype;"，然后你可以用apply调用父类的方法:

A类{ _msg = ' A '; _msgOnlyA='伟大的来自A'; 构造函数(){ ｝ 你好(){ console.log('你好' +。_msg +”、“+ this._msgOnlyA); ｝ }; 类B扩展A{ _parent = A.prototype; _msg = ' B '; 构造函数(){ 超级(); ｝ 你好(){ this._parent.hello。应用(这个参数); console.log('你好' + this._msg); ｝ }; var b = new b (); b.hello ();

ES6风格允许您使用新功能，如超级关键字。super关键字，当你使用ES6类语法时，它都是关于父类上下文的。作为一个非常简单的例子，签出:

记住:我们不能通过实例方法中的super关键字调用父静态方法。调用方法也应该是静态的。

通过实例方法调用静态方法- TypeError ! 类Foo { static classMethod() { 返回“你好”; ｝ ｝ 类Bar扩展Foo { classMethod () { return super.classMethod() + '， too'; ｝ ｝ console.log (Bar.classMethod ());// 'hello' -调用继承的静态方法 console.log(())(新酒吧.classMethod ());// 'Uncaught TypeError' -调用一个实例方法

通过super调用静态方法-这是有效的!

类Foo { static classMethod() { 返回“你好”; ｝ ｝ 类Bar扩展Foo { static classMethod() { return super.classMethod() + '， too'; ｝ ｝ console.log (Bar.classMethod ());// 'hello, too'

现在，超级上下文基于调用而改变——瞧!

类Foo { static classMethod() { 返回'hello I am static only'; ｝ classMethod () { 返回'hello there I am an instance '; ｝ ｝ 类Bar扩展Foo { classMethod () { return super.classMethod() + '， too'; ｝ ｝ console.log(())(新酒吧.classMethod ());// "你好，我也是一个实例" console.log (Bar.classMethod ());// "你好，我是静态的"

同样，你可以使用super来调用父构造函数:

class Foo {}

class Bar extends Foo {
    constructor(num) {
        let tmp = num * 2; // OK
        this.num = num; // ReferenceError
        super();
        this.num = num; // OK
    }
}

当然你也可以用它来访问父类属性super。prop。 所以，使用ES6，快乐吧。