Si encuentras alguna incompatibilidad en tu código o proyecto, recuerda probar siempre en un ambiente de testing antes subir el código al proyecto final.
Solución:
__proto__ es el objeto real que se utiliza en la cadena de búsqueda para resolver métodos, etc. prototype es el objeto que se utiliza para construir __proto__ cuando creas un objeto con new:
( new Foo ).__proto__ === Foo.prototype;
( new Foo ).prototype === undefined;
prototype es una propiedad de un objeto Función. Es el prototipo de los objetos construidos por esa función.
__proto__ es propiedad interna de un objeto, apuntando a su prototipo. Los estándares actuales proporcionan un equivalente Object.getPrototypeOf(O) método, aunque estándar de facto __proto__ es más rápido
Puedes encontrar instanceof relaciones mediante la comparación de una función prototype a un objeto __proto__ cadena, y puedes romper estas relaciones cambiando prototype.
function Point(x, y)
this.x = x;
this.y = y;
var myPoint = new Point();
// the following are all true
myPoint.__proto__ == Point.prototype
myPoint.__proto__.__proto__ == Object.prototype
myPoint instanceof Point;
myPoint instanceof Object;
Aquí Point es una función constructora, construye un objeto (estructura de datos) procedimentalmente. myPoint es un objeto construido por Point() asi que Point.prototype se guarda en myPoint.__proto__ En ese tiempo.
La propiedad prototipo se crea cuando se declara una función.
Por ejemplo:
function Person(dob)
this.dob = dob
;
Person.prototype La propiedad se crea internamente una vez que declara la función anterior. Se pueden agregar muchas propiedades a Person.prototype que son compartidas por instancias de Person creadas usando new Person().
// adds a new method age to the Person.prototype Object.
Person.prototype.age = function()return date-dob;
Cabe resaltar que Person.prototype es un Object literal por defecto (se puede cambiar según sea necesario).
Cada instancia creada usando new Person() tiene un __proto__ propiedad que apunta a la Person.prototype. Esta es la cadena que se utiliza para atravesar para encontrar una propiedad de un objeto en particular.
var person1 = new Person(somedate);
var person2 = new Person(somedate);
crea 2 instancias de Personestos 2 objetos pueden llamar age método de Person.prototype como person1.age, person2.age.
En la imagen de arriba de su pregunta, puede ver que Foo es un Function Object y por lo tanto tiene un __proto__ enlace a la Function.prototype que a su vez es un ejemplo de Object y tiene un __proto__ enlace a Object.prototype. El enlace proto termina aquí con __proto__ en el Object.prototype apuntando a null.
Cualquier objeto puede tener acceso a todas las propiedades en su protocadena como vinculado por __proto__ formando así la base para la herencia prototípica.
__proto__ no es una forma estándar de acceder a la cadena de prototipos, el enfoque estándar pero similar es usar Object.getPrototypeOf(obj).
Debajo del código para instanceof operador da una mejor comprensión:
objeto instanceof El operador de clase devuelve true cuando un objeto es una instancia de una Clase, más específicamente si Class.prototype se encuentra en la protocadena de ese objeto, entonces el objeto es una instancia de esa Clase.
function instanceOf(Func)
var obj = this;
while(obj !== null)
if(Object.getPrototypeOf(obj) === Func.prototype)
return true;
obj = Object.getPrototypeOf(obj);
return false;
El método anterior se puede llamar como: instanceOf.call(object, Class) que regresan true si el objeto es una instancia de Clase.
Si conservas algún titubeo y forma de avanzar nuestro post puedes dejar una reseña y con mucho gusto lo ojearemos.