Difficulté à marcher manuellement sur la chaîne de prototype

Je voulais essayer de marcher manuellement la chaîne prototype de quelques objets juste pour voir ce que je trouve en cours de route. Cependant, je me suis coincé sur le premier que j'ai essayé. Voici le code:

function MyObject() { } var x = new MyObject(); console.log('--------------------------------------------'); console.log('x.constructor.name: ' + x.constructor.name); console.log('x.constructor.prototype.constructor.name: ' + x.constructor.prototype.constructor.name); console.log(x.constructor.prototype === Function.prototype ? 'Good guess.' : 'No, you are wrong.'); console.log(x.constructor === MyObject ? 'Good guess.' : 'No, you are wrong.'); console.log('--------------------------------------------'); 

Le code ci-dessus résulte de la sortie suivante dans la Console d'outils pour développeurs de Google Chrome:

 -------------------------------------------- x.constructor.name: MyObject x.constructor.prototype.constructor.name: MyObject No, you are wrong. Good guess. -------------------------------------------- 

Il est logique que le constructeur de x soit la fonction MyObject, puisque x a été instancié en utilisant le nouveau mot-clé sur MyObject (cela découle de la définition d'un constructeur). Pour cette raison, je comprends la première ligne de sortie (note: j'ai commencé à compter les lignes de sortie à partir de zéro sur). La deuxième ligne, cependant, me confond. J'aimerais savoir ce qu'est le prototype de MyObject. Apparemment, ce n'est pas un objet de type Fonction, comme l'indique la 3ème ligne de sortie, ce qui me dit que je me trompe. La quatrième ligne de sortie renforce la sortie de la première ligne.

Sur une note plus générale, j'ai supposé que la manière correcte de parcourir la chaîne prototype d'un objet serait de passer de l'objet en question à son constructeur, puis du constructeur au prototype du constructeur, en supposant que cette dernière référence ne soit pas nul. J'ai supposé que ce processus en deux étapes (consistant à aller au constructeur, puis au prototype du constructeur) devrait être répété jusqu'à ce qu'une référence nulle d'un constructeur à un prototype soit atteinte, signifiant ainsi la fin de la chaîne de prototypes. Cela ne semble pas fonctionner, cependant, puisque l'application de cet algorithme au scénario ci-dessus conduit simplement à des références circulaires.

• Propriété ou fonction prototype primordiale
• Constructeur vs componentWillMount; Quel composantWillMount peut faire qu'un constructeur ne peut pas?
• Pourquoi l'inscription du constructeur actuel d'une classe en javascript est-elle importante?
• Constructeur pour objets appelables en JavaScript
• Javascript appliquez sur le constructeur, lancer "paramètre formel mal formé"

En résumé, j'ai deux questions:

1. Pourquoi x.constructor === x.constructor.prototype.constructor (ou, en d'autres termes, pourquoi les références circulaires), et quel type d'objet est x.constructor.prototype de toute façon (ou, en d'autres termes, comment Est-ce qu'il a été instancié / d'où est-il venu?)
2. Comment l'algorithme ci-dessus peut-il être corrigé afin de marcher correctement la chaîne prototype pour l'objet x?

modifier

J'ai rencontré une question similaire sur StackOverflow ici , mais cela ne demande pas explicitement la manière correcte de parcourir la chaîne de prototypes. Il fait remarquer les références circulaires, mais …

• Comment surcharger le constructeur d'un objet dans JS (Javascript)?
• Constructeur asynchrone
• Javascript Proper Class constructor
• Invocation de la construction sans parenthèses
• Javascript this inside this.method

 var protoOfA = Object.getPrototypeOf(a); 

 var protoOfA = a.__proto__; 

 function F() {}; a = new F(); console.log(Object.getPrototypeOf(a) === F.prototype); // true 

 console.log(typeof a); // "object" console.log(typeof F); // "function" 

 console.log(Object.getPrototypeOf(F)); // "function Empty() {}" console.log(Empty); // ReferenceError: Empty is not defined 

 for (var p = x ; p != null ; p = Object.getPrototypeOf(p)) { // do something with p }