Cuál es la diferencia entre __proto__
y prototype
Leí la mayoría de los artículos en la web y todavía no puedo entenderlo … por lo que entiendo __proto__
es la propiedad que es prototipo object prototype
es el object real ¿estoy correcto? ….
¿Por qué solo las funciones tienen propiedad de prototipo? ¿Y cómo es un object?
var fn = function(){}; console.dir(fn);
salida
function fn() arguments: null caller: null length: 0 name: "" prototype: Object __proto__: () <function scope>
Usando el object y la function trato de establecer valores para __proto__
y prototipo en la console de Chrome como se muestra a continuación
//create object and display it var o = {name : 'ss'}; console.dir(o);
salida
Object name: "ss", __proto__: Object
//set the values o.__proto__ = 'aaa'; o.prototype = 'bbb'; //after set the values display the object console.dir(o);
salida
Object name: "ss", prototype: "aaa", __proto__: Object
//create function and display it var fn = function(){}; console.dir(fn);
salida
function fn() arguments: null caller: null length: 0 name: "" prototype: Object __proto__: () <function scope>
//set the values fn.prototype = 'fff'; fn.__proto__ = 'eee'; //after set the values display the object console.dir(fn);
salida
function fn() arguments: null caller: null length: 0 name: "" prototype: "fff" __proto__: function() <function scope>
Entonces me doy count de que no puedo establecer valores para __proto__
pero puedo establecer valores para el prototype
. ¿Por qué no puedo establecer valores para __proto__
???
Eso es bastante simple en realidad.
{object}.__proto__
es una reference al object {constructor function}.prototype
. new {constructor function} (params)
en JavaScript hace tres cosas principales:
{constructor function}
con this
set a ese object recién nacido (obj). obj.__proto__ = {constructor function}.prototype;
Y eso es más o less.
Ese obj.__proto__
establece una list vinculada única utilizada para search properties no definidas en el object mismo. Como está establecido en el object {constructor function}.prototype
, podemos tratar ese prototipo como un "rack" para los methods de objects, funciones asociadas a las instancias de los objects.
Ejemplo:
function Foo() {} Foo.prototype.bar = function() { return "foo.bar here"; } var obj = new Foo(); // creating object with __proto__ set to Foo.prototype; obj.bar(); // will return "foo.bar here"
En la mayoría de los idiomas, hay classs y objects. Las classs henetworkingan de otras classs.
En JavaScript,
La inheritance está basada en prototypes. Eso significa que no hay classs. En cambio, un object henetworkinga de otro object
Herencia, el __proto__
Cuando un object conejo henetworkinga de otro object animal , en JavaScript eso significa que hay una propiedad especial rabbit.__proto__ = animal
.
Cuando se accede a una propiedad de conejo y el intérprete no puede encontrarla en el conejo, sigue el enlace __proto__
y busca en el animal.
var animal = { eats: true } var rabbit = { jumps: true } rabbit.__proto__ = animal // inherit alert(rabbit.eats) // true
El Prototipo
Una nueva function llama a los sets el __proto__
del object al valor de su propiedad de prototipo.
var animal = { eats: true } function Rabbit(name) { this.name = name } Rabbit.prototype = animal var rabbit = new Rabbit('John') alert( rabbit.eats )
Referencia completa.