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)