ES6（Babel） - 无法在类定义之外调用扩展类的super.methodName

Question

因此，我明白我可以在子类中使用super（）来调用在基类中定义的函数。但是，如果我想在其他地方调用该对象的父类方法，它炸弹

Parent.js

class Parent { 
    yell() { 
     console.log('yell') 
    } 
} 

Child.js

class Child extends Parent { 
    shout() { 
     super.yell() //this works 
    } 
} 


Child.super.yell() //this doesnt work 

Answer 1

如果你想调用一个方法super上一个实例，要么不要在子类中实现该方法（默认调用super方法），要么在子类方法实现中调用super.methodName()。

此外，您试图调用类本身而不是一个实例的方法，如果这是你的目标，你需要做的方法static：

class Parent { 
    static yell() { 
     console.log('yell') 
    } 
} 

class Child extends Parent { 

} 

Child.yell(); 

Answer 2

这可能有助于看看在transpiled代码巴贝尔输出：

'use strict'; 

var _get = function get(_x, _x2, _x3) { var _again = true; _function: while (_again) { var object = _x, property = _x2, receiver = _x3; desc = parent = getter = undefined; _again = false; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x = parent; _x2 = property; _x3 = receiver; _again = true; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } }; 

var _createClass = (function() { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })(); 

function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) subClass.__proto__ = superClass; } 

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } } 

var Parent = (function() { 
    function Parent() { 
     _classCallCheck(this, Parent); 
    } 

    _createClass(Parent, [{ 
     key: 'yell', 
     value: function yell() { 
      console.log('yell'); 
     } 
    }]); 

    return Parent; 
})(); 

var Child = (function (_Parent) { 
    function Child() { 
     _classCallCheck(this, Child); 

     if (_Parent != null) { 
      _Parent.apply(this, arguments); 
     } 
    } 

    _inherits(Child, _Parent); 

    _createClass(Child, [{ 
     key: 'shout', 
     value: function shout() { 
      _get(Object.getPrototypeOf(Child.prototype), 'yell', this).call(this); 
     } 
    }]); 

    return Child; 
})(Parent); 

这里有一些重要的事情：

• 你定义的方法添加到类的原型
• 儿童原型是父类
• 的实例调用超从原型

因此，为了抓住相同名称的功能打电话喊你可以做的几件事情之一：

Object.getPrototypeOf(Object.getPrototypeOf(_Child)).yell.call(_Child) 

或

Object.getPrototypeOf(Child.prototype).yell.call(_Child) 

或者，我建议这一个：

Parent.prototype.yell.call(_Child)