Object.getPrototypeOf () confusión

¿Cómo funciona Object.getPrototypeOf (obj)?

Según la definición Object.getPrototypeOf (obj) debe devolver la propiedad del prototipo de un Object o de otra manera es igual que obj.constructor.prototype.

Los objects creados con nuevo usan el valor de la propiedad prototipo de su function de constructor como prototipo.

Tomemos un ejemplo:

>element = document.getElementById("test") >a = Object.getPrototypeOf(element) HTMLDivElement 

Digamos que HTMLDivElement es el prototipo de elemento.

 >a.constructor.prototype HTMLDivElement 

por lo que un.constructor.prototype es HTMLDivElement para que Object.getPrototypeOf (a) devuelva HTMLDivElement pero devuelva HTMLElement. Estoy totalmente confundido con la definición de getPrototypeOf ().

 >b = Object.getPrototypeOf(a) 

HTMLElement —-> ¿por qué? a.constructor.prototype es HTMLDivElement

En realidad, está devolviendo la propiedad proto del prototipo, ¿no está mal según la definición de getPrototypeOf ()?

 >a.constructor.prototype.__proto__ HTMLElement 

cita de https://developer.mozilla.org/en/Core_JavaScript_1.5_Guide/Inheritance_Revisited

JavaScript es un poco confuso para los desarrolladores que vienen de Java o C ++, ya que es todo dynamic, todo el time de ejecución, y no tiene classs en absoluto. Todo son solo instancias (objects). Incluso las "classs" que simulamos son solo un object de function.


TEN EN CUENTA que el prototipo también es UN OBJETO, por lo que TAMBIÉN PUEDE TENER PROPIO PROPIO ÚNICO

así que el código que te hace confundir se ve así

 a = Object.getPrototypeOf(element) b = Object.getPrototypeOf(a) 

se puede traducir a esto

 a = element.__proto__ b = element.__ptoto__.__proto__ 

Creo que ahora está claro que a != b


1) Cada object en JavaScript tiene un prototipo , puede acceder a él a través de la propiedad __proto__

2) La function también es un object en Javascript

3) Las funciones también tienen un prototype propiedad

4) Podemos crear objects en JavaScript llamando a la function con la palabra key new

4) El prototype function es el __proto__ inicial para cualquier object creado por ellos


Para crear un nuevo object, podemos escribir algo como esto

 //here we define a function function SomeFunctionThatCreateObject() { this.someStringProperty = "blablabla"; } var obj = new SomeFunctionThatCreateObject(); //we create new object with function var p = Object.getPrototypeOf(obj); 

este código es igual a esto

 var SomeFunctionThatCreateObject = function(@this) { @this.someStringProperty = "blablabla"; return @this; }; SomeFunctionThatCreateObject.prototype = {}; //note that prototype is also an object var obj = {}; obj = SomeFunctionThatCreateObject(obj); obj.constructor = SomeFunctionThatCreateObject; obj.__proto__ = SomeFunctionThatCreateObject.prototype; var p = obj.__proto__; 

PD: también lea este https://stackoverflow.com/a/9220317/474290 y este https://developer.mozilla.org/en/Core_JavaScript_1.5_Guide/Inheritance_Revisited

 var elem = document.getElementsByTagName("div")[0], a = Object.getPrototypeOf ( elem ); console.log( elem.__proto__ ); //HTMLDivElement console.log( a ); // HTMLDivElement console.log( a.__proto__ ); //HTMLElement console.log( Object.getPrototypeOf ( a ) ); //HTMLElement 

por lo que Object.getPrototypeOf return object.__proto__ ( object.constructor.prototype )