Babel/RequireJS + typeof « RangeError: taille de la pile d'appel maximal dépassé »

Question

J'ai un très basique erreur JS et je suis tout à fait honte de ne pas être en mesure de le résoudre ...

Je suis avec ES6 développer et Babel et moi faisons quelques expériences. S'il vous plaît noter que je suis en utilisant ces arguments avec Babel:

--presets es2015 --plugins transform-es2015-modules-amd

J'ai un module simple:

"use strict"; 

export default class Inspector { 
    static inspect() { 
     console.log(this.prototype.myMethod); 
     console.log(typeof this.prototype.myMethod); 
    } 
} 

J'utilise ce module comme ça:

"use strict"; 

import Inspector from "inspector"; 

class Child extends Inspector { 
    myMethod() { 
     console.log(`Hello from ${this.name}`); 
    } 
} 

Child.inspect(); 

L'objectif Voici vraiment bête: vérifiez simplement comment le prototype est rempli avec l'héritage ES6.

Les premiers console.log de inspect() affiche la méthode, comme prévu:

function myMethod() { console.log("Hello from " + this.name); }

Héritages a travaillé comme prévu, hourray! Mais le plus drôle est la deuxième console.log (console.log(typeof this.prototype.myMethod);) qui déclenche une erreur:

require.js:19 RangeError: Maximum call stack size exceeded(…)

Je me attendais quelque chose de plus comme « fonction », mais bon, je suppose que je suis assez naïf ...

Cette erreur semble être liée aux modules requirejs, mais je n'ai aucune idée pourquoi je peux enregistrer la fonction, mais pas son type.

S'il vous plaît noter également que je peux appeler cette méthode dans la méthode inspect:

static inspect() { 
     this.prototype.myMethod(); 
} 

Cette affiche « Bonjour de undefined » (je m'y attendais « Bonjour de l'enfant », mais puisque ce n'est pas une méthode statique c'est normal, de toute façon l'appel est correctement effectué!).

Donc, ma question ici: pourquoi puis-je me connecter et appeler une méthode, mais je ne peux pas exécuter typeof dessus?

Merci d'avance!

EDIT: vous pouvez voir ci-dessous les fichiers transpiled:

inspector.js

define(["exports"], function (exports) { 
    "use strict"; 

    Object.defineProperty(exports, "__esModule", { 
     value: true 
    }); 

    function _typeof(obj) { 
     return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj === "undefined" ? "undefined" : _typeof(obj); 
    } 

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

    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; 
     }; 
    })(); 

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

     _createClass(Inspector, null, [{ 
      key: "inspect", 
      value: function inspect() { 
       this.prototype.myMethod(); 
       console.log(this.prototype.myMethod); 
       console.log(_typeof(this.prototype.myMethod)); 
      } 
     }]); 

     return Inspector; 
    })(); 

    exports.default = Inspector; 
}); 

child.js

function _typeof(obj) { return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj; } 

define(["inspector"], function (_inspector) { 
    "use strict"; 

    var _inspector2 = _interopRequireDefault(_inspector); 

    function _interopRequireDefault(obj) { 
     return obj && obj.__esModule ? obj : { 
      default: obj 
     }; 
    } 

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

    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 _possibleConstructorReturn(self, call) { 
     if (!self) { 
      throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); 
     } 

     return call && ((typeof call === "undefined" ? "undefined" : _typeof(call)) === "object" || typeof call === "function") ? call : self; 
    } 

    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) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; 
    } 

    var Child = (function (_Inspector) { 
     _inherits(Child, _Inspector); 

     function Child() { 
      _classCallCheck(this, Child); 

      return _possibleConstructorReturn(this, Object.getPrototypeOf(Child).apply(this, arguments)); 
     } 

     _createClass(Child, [{ 
      key: "myMethod", 
      value: function myMethod() { 
       console.log("Hello from " + this.name); 
      } 
     }]); 

     return Child; 
    })(_inspector2.default); 

    Child.inspect(); 
}); 

Exception stracktrace est pas très utile malheureusement:

ea.check @ require.js:19

(anonymous function) @ require.js:23

(anonymous function) @ require.js:8

(anonymous function) @ require.js:24

x @ require.js:7

ea.emit @ require.js:24

ea.check @ require.js:20 ea.enable @ require.js:24

ea.init @ require.js:17 J @ require.js:14

h.completeLoad @ require.js:29

h.onScriptLoad @ require.js:30

EDIT2: En regardant les fichiers transpiled, il semble que mon typeof est remplacée par la méthode _typeOf de Babel. Et cette fonction est en boucle infiniment ...

Est-ce un bug avec Babel? Ai-je manqué des arguments pour la compilation?

Answer 1

On dirait un bug de babel, il pourrait être exactement celui-ci: https://phabricator.babeljs.io/T6777