La propiedad prototype se crea cuando se declara una función.

Por ejemplo:

 function Person(dob){ this.dob = dob };

La propiedad Person.prototype 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};

Vale la pena señalar que Person.prototype es un Object literal por defecto (se puede cambiar según sea necesario).

Cada instancia creada con new Person() tiene una propiedad __proto__ que apunta a 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 Person , estos 2 objetos pueden llamar al método de age 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 enlace __proto__ a Function.prototype que, a su vez, es una instancia de Object y tiene un enlace __proto__ a Object.prototype . El enlace proto termina aquí con __proto__ en Object.prototype apuntando a null .

Cualquier objeto puede tener acceso a todas las propiedades en su protocadena vinculada 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) .

El siguiente código para el operador instanceof brinda una mejor comprensión:

El operador object instanceof Class devuelve true cuando un objeto es una instancia de una clase, más específicamente si Class.prototype se encuentra en la cadena de prototipos 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 devuelve verdadero si el objeto es una instancia de Clase.

__proto__ es el objeto real que se usa en la cadena de búsqueda para resolver métodos, etc. prototype es el objeto que se usa 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 una propiedad interna de un objeto, que apunta a su prototipo. Los estándares actuales proporcionan un método Object.getPrototypeOf(obj) equivalente, aunque el __proto__ estándar de facto es más rápido.

Puede encontrar relaciones de instanceof comparando el prototype de una función con la cadena __proto__ de un objeto, y puede romper estas relaciones cambiando el 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() , por lo que Point.prototype se guarda en myPoint.__proto__ en ese momento.

mi entendimiento es: __proto__ y prototipo se sirven para la técnica de cadena de prototipos. la diferencia es que las funciones nombradas con guión bajo (como __proto__) no están destinadas a los desarrolladores invocadas explícitamente en absoluto. en otras palabras, son solo para algunos mecanismos como heredar, etc. son 'back-end'. pero las funciones nombradas sin guión bajo están diseñadas para ser invocadas explícitamente, son 'front-end'.

Una buena forma de pensarlo es...

prototype es utilizado por funciones constructor . Realmente debería haberse llamado algo así como "prototypeToInstall" , ya que eso es lo que es.

y __proto__ es ese "prototipo instalado" en un objeto (que fue creado/instalado sobre el objeto desde dicha función constructor() )

Prototipo VS. __proto__ VS. [[Prototipo]]

Al crear una función, se crea automáticamente un objeto de propiedad llamado prototipo (no lo creó usted mismo) y se adjunta al objeto de la función (el constructor ).
Nota : este nuevo objeto prototipo también apunta al objeto de JavaScript nativo o tiene un enlace privado interno al mismo.

Ejemplo:

 function Foo () { this.name = 'John Doe'; } // Foo has an object property called prototype. // prototype was created automatically when we declared the function Foo. Foo.hasOwnProperty('prototype'); // true // Now, we can assign properties and methods to it: Foo.prototype.myName = function () { return 'My name is ' + this.name; }

Si crea un nuevo objeto a partir de Foo usando la palabra clave new , básicamente está creando (entre otras cosas) un nuevo objeto que tiene un enlace interno o privado a la función del prototipo de Foo que discutimos anteriormente:

 var b = new Foo(); b.[[Prototype]] === Foo.prototype // true

Para ser más específicos, __proto__ es en realidad una función captadora que pertenece al objeto nativo de JavaScript. Devuelve el enlace prototipo interno-privado de lo que sea this enlace (devuelve el [[Prototype]] de b ):

 b.__proto__ === Foo.prototype // true

Vale la pena señalar que a partir de ECMAScript5 , también puede usar el método getPrototypeOf para obtener el enlace privado interno:

 Object.getPrototypeOf(b) === b.__proto__ // true

Para dejarlo un poco claro además de las excelentes respuestas anteriores:

 function Person(name){ this.name = name }; var eve = new Person("Eve"); eve.__proto__ == Person.prototype //true eve.prototype //undefined

Las instancias tienen __proto__ , las clases tienen prototipo .

Para hacerlo mas simple:

 > var a = 1 undefined > a.__proto__ [Number: 0] > Number.prototype [Number: 0] > Number.prototype === a.__proto__ true

Esto le permite adjuntar propiedades a X.prototype DESPUÉS de que se hayan creado instancias de objetos de tipo X, y aún tendrán acceso a esas nuevas propiedades a través de la referencia __proto__ que utiliza el motor de Javascript para avanzar en la cadena de prototipos.

Prototype u Object.prototype es una propiedad de un objeto literal. Representa el objeto prototipo de objeto que puede anular para agregar más propiedades o métodos a lo largo de la cadena de prototipos.

__proto__ es una propiedad de acceso (función get y set) que expone el prototipo interno de un objeto a través del cual se accede.

Referencias:

1. https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/prototype

2. http://www.w3schools.com/js/js_object_prototypes.asp

3. https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/proto

Otra buena manera de entenderlo:

 var foo = {} /* foo.constructor is Object, so foo.constructor.prototype is actually Object.prototype; Object.prototype in return is what foo.__proto__ links to. */ console.log(foo.constructor.prototype === foo.__proto__); // this proves what the above comment proclaims: Both statements evaluate to true. console.log(foo.__proto__ === Object.prototype); console.log(foo.constructor.prototype === Object.prototype);

Solo después de que IE11 __proto__ sea compatible. Antes de esa versión, como IE9, podía usar el constructor para obtener el __proto__ .

!!!ESTA ES LA MEJOR EXPLICACIÓN DEL MUNDO!!!!!

 var q = {} var prototype = {prop: 11} q.prop // undefined q.__proto__ = prototype q.prop // 11

en los constructores de funciones, el motor javascript llama a este q.__proto__ = prototype automáticamente cuando escribimos una new Class , y en el conjunto de accesorios __proto__ Class.prototype

 function Class(){} Class.prototype = {prop: 999} // set prototype as we need, before call new var q = new Class() // q.__proto__ = Class.prototype q.prop // 999

Disfrutar %)

DEFINICIONES

(el número dentro del paréntesis () es un 'enlace' al código que está escrito a continuación)

prototype - un objeto que consta de:
=> funciones (3) de este ConstructorFunction.prototype en particular (5) a las que puede acceder cada objeto (4) creado o por crear a través de esta función constructora (1)
=> la propia función constructora (1)
=> __proto__ de este objeto en particular (objeto prototipo)

__proto__ (dandor proto?) - un enlace ENTRE cualquier objeto (2) creado a través de una función constructora particular (1) Y las propiedades del objeto prototipo (5) de ese constructor QUE permite que cada objeto creado (2) tenga acceso a las propiedades del prototipo funciones y métodos (4) ( __proto__ se incluye de forma predeterminada en cada objeto en JS)

ACLARACIÓN DEL CÓDIGO

1.

 function Person (name, age) { this.name = name; this.age = age; }

2.

 var John = new Person('John', 37); // John is an object

3.

 Person.prototype.getOlder = function() { this.age++; } // getOlder is a key that has a value of the function

4.

 John.getOlder();

5.

 Person.prototype;

Cada función que crea tiene una propiedad llamada prototype y comienza su vida como un objeto vacío. Esta propiedad no sirve hasta que utilice esta función como función constructora, es decir, con la palabra clave 'nuevo'.

Esto a menudo se confunde con la propiedad __proto__ de un objeto. Algunos pueden confundirse y excepto que la propiedad prototype de un objeto podría obtener el prototipo de un objeto. Pero este no es el caso. El prototype se usa para obtener el __proto__ de un objeto creado a partir de un constructor de funciones.

En el ejemplo anterior:

 function Person(name){ this.name = name }; var eve = new Person("Eve"); console.log(eve.__proto__ == Person.prototype) // true // this is exactly what prototype does, made Person.prototype equal to eve.__proto__

Espero que tenga sentido.

Para explicar vamos a crear una función

 function a (name) { this.name = name; }

Cuando JavaScript ejecuta este código, agrega la propiedad prototype a a objeto, la propiedad prototype es un objeto con dos propiedades:

1. constructor
2. __proto__

Así que cuando lo hacemos

a.prototype que devuelve

 constructor: a // function definition __proto__: Object

Ahora, como puede ver, el constructor no es más que la función a sí misma y __proto__ apunta al Object de nivel raíz de JavaScript.

Veamos qué sucede cuando usamos a función con new palabra clave.

 var b = new a ('JavaScript');

Cuando JavaScript ejecuta este código, hace 4 cosas:

1. Crea un nuevo objeto, un objeto vacío // {}
2. Crea __proto__ en b y hace que apunte a a.prototype así que b.__proto__ === a.prototype
3. Ejecuta a.prototype.constructor (que es la definición de la función a ) con el objeto recién creado (creado en el paso n. ° 1) como su contexto (esto), por lo tanto, la propiedad de name se pasa como 'JavaScript' (que se agrega a this ) se agrega al objeto recién creado.
4. Devuelve el objeto recién creado (creado en el paso n. ° 1), por lo que var b se asigna al objeto recién creado.

Ahora, si agregamos a.prototype.car = "BMW" y hacemos b.car , aparece la salida "BMW".

esto se debe a que cuando JavaScript ejecutó este código, buscó la propiedad del car en b , no encontró entonces JavaScript usó b.__proto__ (que se hizo para apuntar a 'a.prototype' en el paso n.° 2) y encuentra la propiedad car , así que devuelva " BMW".

Lo sé, llego tarde, pero déjame intentar simplificarlo.

Digamos que hay una función

 function Foo(message){ this.message = message ; }; console.log(Foo.prototype);

La función Foo tendrá un objeto prototipo vinculado. Entonces, cada vez que creamos una función en JavaScript, siempre tiene un objeto prototipo vinculado.

Ahora sigamos adelante y creemos dos objetos usando la función Foo.

 var a = new Foo("a"); var b = new Foo("b"); console.log(a.message); console.log(b.message);

1. Ahora tenemos dos objetos, el objeto a y el objeto b. Ambos se crean utilizando el constructor Foo. Tenga en cuenta que el constructor es solo una palabra aquí.
2. Los objetos a y b tienen una copia de la propiedad del mensaje.
3. Estos dos objetos a y b están vinculados al objeto prototipo del constructor Foo.
4. En los objetos a y b, podemos acceder al prototipo Foo usando la propiedad __proto__ en todos los navegadores y en IE podemos usar Object.getPrototypeOf(a) u Object.getPrototypeOf(b)

Ahora, Foo.prototype, a.__proto__ y b.__proto__ denotan el mismo objeto.

 b.__proto__ === Object.getPrototypeOf(a); a.__proto__ === Foo.prototype; a.constructor.prototype === a.__proto__;

todo lo anterior sería verdadero.

Como sabemos, en JavaScript las propiedades se pueden agregar dinámicamente. Podemos agregar propiedades al objeto.

 Foo.prototype.Greet = function(){ console.log(this.message); } a.Greet();//a b.Greet();//b a.constructor.prototype.Greet();//undefined

Como puede ver, agregamos el método Greet() en Foo.prototype, pero se puede acceder a él en ayb o en cualquier otro objeto que se construya con Foo.

Al ejecutar a.Greet(), JavaScript primero buscará Greet en el objeto a en la lista de propiedades. Al no encontrar , subirá en __proto__cadena de a. Dado que a.__proto__ y Foo.prototype son el mismo objeto, JavaScript encontrará el método Greet() y lo ejecutará.

Espero que ahora prototipo y __proto__ se simplifiquen un poco.

En JavaScript, una función se puede utilizar como constructor. Eso significa que podemos crear objetos a partir de ellos usando la nueva palabra clave. Cada función constructora viene con un objeto incorporado encadenado con ellas. Este objeto incorporado se llama prototipo. Instances of a constructor function use __proto__ to access the prototype property of its constructor function.

1. Primero creamos un constructor: function Foo(){} . Para ser claros, Foo es solo otra función. Pero podemos crear un objeto a partir de él con la nueva palabra clave. Por eso la llamamos función constructora.

2. Cada función tiene una propiedad única que se llama propiedad prototipo. Entonces, la función Constructor Foo tiene una propiedad de prototipo que apunta a su prototipo, que es Foo.prototype (ver imagen).

3. Las funciones constructoras son en sí mismas una función que es una instancia de un constructor de sistema llamado constructor [[Función]]. Entonces podemos decir que la function Foo está construida por un constructor [[Function]]. Entonces, __proto__ de nuestra Foo function apuntará al prototipo de su constructor, que es Function.prototype .

4. Function.prototype no es más que un objeto que se construye a partir de otro constructor de sistema llamado [[Object]] . Entonces, [[Object]] es el constructor de Function.prototype . Entonces, podemos decir que Function.prototype es una instancia de [[Object]] . Entonces __proto__ de Function.prototype apunta a Object.prototype .

5. Object.prototype es el último hombre en pie en la cadena de prototipos. Quiero decir que no ha sido construido. Ya está en el sistema. Entonces su __proto__ apunta a null .

6. Ahora llegamos a las instancias de Foo . Cuando creamos una instancia usando new Foo() , crea un nuevo objeto que es una instancia de Foo . Eso significa que Foo es el constructor de estas instancias. Aquí creamos dos instancias (x e y). __proto__ de xey, por lo tanto, apunta a Foo.prototype .

Intentaré una explicación de cuarto grado:

Las cosas son muy simples. Un prototype es un ejemplo de cómo se debe construir algo. Entonces:

• Soy una function y construyo nuevos objetos similares a mi prototype .

• Soy un object y fui construido usando mi __proto__ como ejemplo

prueba :

 function Foo() { } var bar = new Foo() // `bar` is constructed from how Foo knows to construct objects bar.__proto__ === Foo.prototype // => true // bar is an instance - it does not know how to create objects bar.prototype // => undefined

¿Qué pasa con el uso de __proto__ para métodos estáticos?

 function Foo(name){ this.name = name Foo.__proto__.collection.push(this) Foo.__proto__.count++ } Foo.__proto__.count=0 Foo.__proto__.collection=[] var bar = new Foo('bar') var baz = new Foo('baz') Foo.count;//2 Foo.collection // [{...}, {...}] bar.count // undefined

prototipo

prototipo es una propiedad de una Función. Es el modelo para crear objetos usando esa función (constructor) con la nueva palabra clave.

__proto__

__proto__ se usa en la cadena de búsqueda para resolver métodos, propiedades. cuando se crea un objeto (usando la función de constructor con la nueva palabra clave), __proto__ se establece en (Constructor) Function.prototype

 function Robot(name) { this.name = name; } var robot = new Robot(); // the following are true robot.__proto__ == Robot.prototype robot.__proto__.__proto__ == Object.prototype

Aquí está mi explicación (imaginaria) para aclarar la confusión:

Imagine que hay una clase imaginaria (plano/cortador de galletas) asociada con la función. Esa clase imaginaria se usa para instanciar objetos. El prototype es el mecanismo de extensión (método de extensión en C# o Swift Extension) para agregar cosas a esa clase imaginaria.

 function Robot(name) { this.name = name; }

Lo anterior se puede imaginar como:

 // imaginary class class Robot extends Object{ static prototype = Robot.class // Robot.prototype is the way to add things to Robot class // since Robot extends Object, therefore Robot.prototype.__proto__ == Object.prototype var __proto__; var name = ""; // constructor function Robot(name) { this.__proto__ = prototype; prototype = undefined; this.name = name; } }

Entonces,

 var robot = new Robot(); robot.__proto__ == Robot.prototype robot.prototype == undefined robot.__proto__.__proto__ == Object.prototype

Ahora agregando método al prototype de Robot:

 Robot.prototype.move(x, y) = function(x, y){ Robot.position.x = x; Robot.position.y = y}; // Robot.prototype.move(x, y) ===(imagining)===> Robot.class.move(x, y)

Lo anterior se puede imaginar como una extensión de la clase Robot:

 // Swift way of extention extension Robot{ function move(x, y){ Robot.position.x = x; Robot.position.y = y } }

Que a su vez,

 // imaginary class class Robot{ static prototype = Robot.class // Robot.prototype way to extend Robot class var __proto__; var name = ""; // constructor function Robot(name) { this.__proto__ = prototype; prototype = undefined; this.name = name; } // added by prototype (as like C# extension method) function move(x, y){ Robot.position.x = x; Robot.position.y = y }; }

Ejemplo explicativo:

 function Dog(){} Dog.prototype.bark = "woof" let myPuppie = new Dog()

ahora, myPupppie tiene la propiedad __proto__ que apunta a Dog.prototype.

 > myPuppie.__proto__ >> {bark: "woof", constructor: ƒ}

pero myPuppie NO tiene una propiedad prototipo.

 > myPuppie.prototype >> undefined

Entonces, __proto__ de mypuppie es la referencia a la propiedad .prototype de la función constructora que se usó para instanciar este objeto (y el objeto myPuppie actual tiene una relación de "delegados a" con este objeto __proto__ ), mientras que la propiedad .prototype de myPuppie simplemente está ausente (ya que no lo configuramos).

Buena explicación de MPJ aquí: proto vs prototipo - Creación de objetos en JavaScript

__proto__ es la base para construir prototype y una función constructora, por ejemplo: function human(){} tiene un prototype que se comparte a través de __proto__ en la nueva instancia de la función constructora. Una lectura más detallada aquí

 (function(){ let a = function(){console.log(this.b)}; a.prototype.b = 1; a.__proto__.b = 2; let q = new a(); console.log(ab); console.log(qb) })()

Prueba este código para entender

 'use strict' function A() {} var a = new A(); class B extends A {} var b = new B(); console.log('====='); // ===== console.log(B.__proto__ === A); // true console.log(B.prototype.__proto__ === A.prototype); // true console.log(b.__proto__ === B.prototype); // true console.log(a.__proto__ === A.prototype); // true console.log(A.__proto__ === Function.__proto__); // true console.log(Object.__proto__ === Function.__proto__); // true console.log(Object.prototype === Function.__proto__.__proto__); // true console.log(Object.prototype.__proto__ === null); // true

En JavaScript, cada objeto (¡la función también es objeto!) tiene una propiedad __proto__ , la propiedad es una referencia a su prototipo.

Cuando usamos el new operador con un constructor para crear un nuevo objeto, la propiedad __proto__ del nuevo objeto se establecerá con la propiedad del prototype del constructor, luego el nuevo objeto llamará al constructor, en ese proceso "esto" será una referencia a el nuevo objeto en el ámbito del constructor, finalmente devuelve el nuevo objeto.

El prototipo de Constructor es la propiedad __proto__ , la propiedad del prototype de Constructor es trabajar con el new operador.

El constructor debe ser una función, pero la función no siempre es constructor, incluso si tiene la propiedad prototype .

La cadena de prototipos en realidad es la propiedad __proto__ del objeto para hacer referencia a su prototipo, y la propiedad __proto__ del prototipo para hacer referencia al prototipo del prototipo, y así sucesivamente, hasta hacer referencia a la propiedad __proto__ del prototipo del objeto, que es una referencia nula.

Por ejemplo:

 console.log(a.constructor === A); // true // "a" don't have constructor, // so it reference to A.prototype by its ``__proto__`` property, // and found constructor is reference to A

La propiedad [[Prototype]] y __proto__ en realidad es lo mismo.

Podemos usar el método getPrototypeOf de Object para obtener el prototipo de algo.

 console.log(Object.getPrototypeOf(a) === a.__proto__); // true

Cualquier función que escribimos se puede usar para crear un objeto con el operador new , por lo que cualquiera de esas funciones puede ser un constructor.

Resumen:

La propiedad __proto__ de un objeto es una propiedad que se asigna al prototype de la función constructora del objeto. En otras palabras:

instance.__proto__ === constructor.prototype // true

Esto se utiliza para formar la cadena prototype de un objeto. La cadena de prototype es un mecanismo de búsqueda de propiedades en un objeto. Si se accede a la propiedad de un objeto, JavaScript buscará primero en el objeto mismo. Si la propiedad no se encuentra allí, subirá hasta la protochain hasta que se encuentre (o no)

Ejemplo:

 function Person (name, city) { this.name = name; } Person.prototype.age = 25; const willem = new Person('Willem'); console.log(willem.__proto__ === Person.prototype); // the __proto__ property on the instance refers to the prototype of the constructor console.log(willem.age); // 25 doesn't find it at willem object but is present at prototype console.log(willem.__proto__.age); // now we are directly accessing the prototype of the Person function

Nuestro primer registro da como resultado true , esto se debe a que, como se mencionó, la propiedad __proto__ de la instancia creada por el constructor se refiere a la propiedad prototype del constructor. Recuerde, en JavaScript, las funciones también son Objetos. Los objetos pueden tener propiedades, y una propiedad predeterminada de cualquier función es una propiedad llamada prototipo.

Luego, cuando esta función se utiliza como función constructora, el objeto instanciado a partir de ella recibirá una propiedad llamada __proto__ . Y esta propiedad __proto__ se refiere a la propiedad prototype de la función constructora (que por defecto tiene cada función).

¿Por qué es útil?

JavaScript tiene un mecanismo al buscar propiedades en Objects que se llama 'herencia prototípica' , esto es lo que hace básicamente:

• Primero, se verifica si la propiedad está ubicada en el propio Objeto. Si es así, se devuelve esta propiedad.
• Si la propiedad no está ubicada en el objeto en sí, 'subirá la protocadena'. Básicamente mira el objeto al que se refiere la propiedad __proto__ . Allí, verifica si la propiedad está disponible en el objeto al que hace referencia __proto__ .
• Si la propiedad no está ubicada en el objeto __proto__ , ascenderá por la cadena __proto__ hasta llegar al objeto Object .
• Si no puede encontrar la propiedad en ninguna parte del objeto y su cadena de prototype , devolverá undefined .

Por ejemplo:

 function Person (name) { this.name = name; } let mySelf = new Person('Willem'); console.log(mySelf.__proto__ === Person.prototype); console.log(mySelf.__proto__.__proto__ === Object.prototype);

Esta es una pregunta muy importante relevante para cualquiera que quiera entender la herencia prototípica. Por lo que entiendo, el prototipo se asigna de forma predeterminada cuando se crea un objeto con nuevo de una función porque la función tiene un objeto prototipo por definición:

 function protofoo(){ } var protofoo1 = new protofoo(); console.log(protofoo.prototype.toString()); //[object Object]

Cuando creamos un objeto ordinario sin new, es decir, explícitamente a partir de una función, no tiene prototipo pero tiene un proto vacío al que se le puede asignar un prototipo.

 var foo={ check: 10 }; console.log(foo.__proto__); // empty console.log(bar.prototype); // TypeError foo.__proto__ = protofoo1; // assigned console.log(foo.__proto__); //protofoo

Podemos usar Object.create para vincular un objeto explícitamente.

 // we can create `bar` and link it to `foo` var bar = Object.create( foo ); bar.fooprops= "We checking prototypes"; console.log(bar.__proto__); // "foo" console.log(bar.fooprops); // "We checking prototypes" console.log(bar.check); // 10 is delegated to `foo`

Como bien dice esto

__proto__ es el objeto real que se usa en la cadena de búsqueda para resolver métodos, etc. prototipo es el objeto que se usa para construir __proto__ cuando creas un objeto con nuevo:

 ( new Foo ).__proto__ === Foo.prototype; ( new Foo ).prototype === undefined;

Además, podemos notar que la propiedad __proto__ de un objeto creado usando el constructor de funciones apunta hacia la ubicación de memoria apuntada por la propiedad prototipo de ese constructor respectivo.

Si cambiamos la ubicación de la memoria del prototipo de la función constructora, __proto__ del objeto derivado seguirá apuntando hacia el espacio de direcciones original. Por lo tanto, para que la propiedad común esté disponible en la cadena de herencia, siempre agregue la propiedad al prototipo de la función constructora, en lugar de reiniciarla (lo que cambiaría su dirección de memoria).

Considere el siguiente ejemplo:

 function Human(){ this.speed = 25; } var himansh = new Human(); Human.prototype.showSpeed = function(){ return this.speed; } himansh.__proto__ === Human.prototype; //true himansh.showSpeed(); //25 //now re-initialzing the Human.prototype aka changing its memory location Human.prototype = {lhs: 2, rhs:3} //himansh.__proto__ will still continue to point towards the same original memory location. himansh.__proto__ === Human.prototype; //false himansh.showSpeed(); //25

Solo hay un objeto que se usa para el encadenamiento protípico. Este objeto obviamente tiene un nombre y un valor: __proto__ es su nombre, y prototype es su valor. Eso es todo.

para que sea aún más fácil de entender, mire el diagrama en la parte superior de esta publicación (Diagrama de dmitry soshnikov), nunca encontrará __proto__ apunta a otra cosa que no sea prototype como su valor.

La esencia es esta: __proto__ es el nombre que hace referencia al objeto prototipo, y prototype es el objeto prototipo real.

Es como decir:

 let x = {name: 'john'};

x es el nombre del objeto (puntero) y {name: 'john'} es el objeto real (valor de datos).

NOTA: esto es solo una pista enormemente simplificada sobre cómo se relacionan en un alto nivel.

Actualización: aquí hay un ejemplo de javascript simple y concreto para una mejor ilustración:

 let x = new String("testing") // Or any other javascript object you want to create Object.getPrototypeOf(x) === x.__proto__; // true

Esto significa que cuando Object.getPrototypeOf(x) nos obtiene el valor real de x (que es su prototipo), es exactamente a lo que apunta el __proto__ de x . Por lo tanto __proto__ de hecho apunta al prototipo de x . Por lo tanto __proto__ hace referencia a x (puntero de x ), y prototype es el valor de x (su prototipo).

Espero que esté un poco claro ahora.

Me hice un pequeño dibujo que representa el siguiente fragmento de código:

 var Cat = function() {} var tom = new Cat()

Tengo una experiencia clásica en OO, por lo que fue útil representar la jerarquía de esta manera. Para ayudarlo a leer este diagrama, trate los rectángulos en la imagen como objetos de JavaScript. Y sí, las funciones también son objetos. ;)

Los objetos en JavaScript tienen propiedades y __proto__ es solo uno de ellos.

La idea detrás de esta propiedad es apuntar al objeto antecesor en la jerarquía (de herencia).

El objeto raíz en JavaScript es Object.prototype y todos los demás objetos son descendientes de este. La propiedad __proto__ del objeto raíz es null , lo que representa el final de la cadena de herencia.

Notarás que prototype es una propiedad de funciones. Cat es una función, pero también Function y Object son funciones (nativas). tom no es una función, por lo que no tiene esta propiedad.

La idea detrás de esta propiedad es apuntar a un objeto que se usará en la construcción, es decir, cuando llame al new operador en esa función.

Tenga en cuenta que los objetos prototipo (rectángulos amarillos) tienen otra propiedad llamada constructor que apunta al objeto de función respectivo. Por razones de brevedad esto no fue representado.

De hecho, cuando creamos el objeto tom con new Cat() , el objeto creado tendrá la propiedad __proto__ establecida en el objeto prototype de la función constructora.

Al final, juguemos un poco con este diagrama. Las siguientes afirmaciones son verdaderas:

• La propiedad tom.__proto__ apunta al mismo objeto que Cat.prototype .

• Cat.__proto__ apunta al objeto Function.prototype , tal como lo Function.__proto__ y Object.__proto__ .

• Cat.prototype.__proto__ y tom.__proto__.__proto__ apuntan al mismo objeto y ese es Object.prototype .

¡Salud!

existen tantas buenas respuestas para esta pregunta, pero para recapitular y forma compacta de respuesta que tienen buenos detalles, agrego lo siguiente:

lo primero que debemos considerar es cuando se inventó JS, las computadoras tienen muy poca memoria, por lo que si necesitamos un proceso para crear nuevos tipos de objetos, debemos considerar el rendimiento de la memoria.

por lo que ubicaron los métodos que el objeto creado a partir de ese object type específico necesita, en la parte separada de la memoria en lugar de almacenar métodos además del objeto cada vez que creamos un nuevo objeto. Entonces, si reinventamos el new concepto de función de operador y constructor con las nuevas características de JS, tenemos estos pasos:

1. y objeto vacío. (ese será el resultado final de la instanciación del tipo de objeto)

 let empty={}

2. ya sabemos que, por motivos de rendimiento de la memoria, todos los métodos necesarios para las instancias de un object type se encuentran en la propiedad prototype de la función constructora. (las funciones también son objetos, por lo que pueden tener propiedades), por lo que hacemos referencia al __protp__ del objeto empty a la ubicación donde existen esos métodos. (Consideramos la función que usamos conceptualmente como el constructor, llamado constructor.

 empty.__proto__ = constructor.prototype

3. debemos inicializar los valores de tipo de objeto. en la función JS están desconectados de los objetos. con notación de puntos o métodos como bind call apply que tienen los objetos de función, debemos decir "cuál es this contexto de la función".

 let newFunc = constructor.bind(empty)

4. ahora tenemos una nueva función que tiene un objeto empty como this contexto. después de la ejecución de esta función. el objeto empty se llenará, y el resultado de la instanciación del tipo de objeto será este objeto empty si la función constructor definida no regresa (como si ese fuera el resultado del proceso)

entonces, como puede ver, __proto__ es una propiedad de objetos que se refiere a otros objetos (en las funciones JS también son objetos) propiedad de objeto prototype que consiste en propiedades que se usan en instancias de un object type específico.

como puede adivinar por la frase, functions are objects , las funciones también tienen la propiedad __proto__ para que puedan referirse a las propiedades prototype de otros objetos. así es como se implementa la prototype inheritance .