Wie unterscheidet sich __proto__ von constructor.prototype?

Ich habe versucht, einzuwickeln meinen Kopf, um dieses vor kurzem und kam schließlich mit dieser "Karte", dass ich meinen Schuppen voller Licht über die Materie

http://i.stack.imgur.com/KFzI3.png

Ich weiß, ich bin nicht der erste, der macht dies, aber es war mehr interessant, es herauszufinden, es zu finden :-). Wie auch immer, nachdem ich gefunden habe, z.B. ein anderes Diagramm, das denke ich sagt im Grunde das gleiche:

Javascript Objekt-layout

Die meisten überraschend für mich war die Entdeckung, dass Object.__proto__ Punkte zu Function.prototype statt Object.prototypeaber ich bin sicher, es gibt einen guten Grund dafür 🙂

Ich füge den code erwähnt in dem Bild hier, wenn jemand will, um es zu testen. Beachten Sie, dass einige Eigenschaften Hinzugefügt werden, um die Objekte zu machen, einfach zu wissen, wo wir nach einigen Sprüngen:

Object.O1='';
Object.prototype.Op1='';

Function.F1 = '';
Function.prototype.Fp1 = '';

Cat = function(){};
Cat.C1 = '';
Cat.prototype.Cp1 = '';

mycat = new Cat();
o = {};

//EDITED: using console.dir now instead of console.log
console.dir(mycat);
console.dir(o);

InformationsquelleAutor der Antwort drodsou

Den Prototypal Inheritance in JavaScript basiert auf __proto__ Eigenschaft in dem Sinne, dass jedes Objekt erbt der Inhalt des referenzierten Objekts durch seine __proto__ Eigenschaft.

Den prototype Eigenschaft ist speziell nur für Function Objekte und nur bei Verwendung von new operator zum aufrufen einer Function als Konstruktor. In diesem Fall wird das erstellte Objekt __proto__ wird Konstruktor Function.prototype.

Dies bedeutet, dass das hinzufügen, um Function.prototype automatisch spiegeln sich auf alle Objekte aus, deren __proto__ auf die Function.prototype.

Ersetzen Konstruktor Function.prototype mit einem anderen Objekt wird nicht update __proto__ Eigenschaft für alle bereits vorhandenen Objekte.

Beachten Sie, dass __proto__ Eigenschaft sollte nicht direkt zugegriffen werden, Objekt.getPrototypeOf(object) sollte stattdessen verwendet werden.

Zur Beantwortung der ersten Frage, ich habe eine maßgeschneiderte Diagramm __proto__ und prototype Referenzen, leider stackoverflow nicht erlauben, mich zu fügen Sie das Bild mit "weniger als 10 Ruf". Vielleicht ein anderes mal.

[Bearbeiten]
Die Abbildung verwendet [[Prototype]] statt __proto__ denn das ist, wie ECMAScript-Spezifikation bezieht sich auf interne Objekte. Ich hoffe, Sie können herausfinden alles aus.

Hier sind einige Hinweise, die Ihnen helfen zu verstehen, die Abbildung:

red    = JavaScript Function constructor and its prototype
violet = JavaScript Object constructor and its prototype
green  = user-created objects
         (first created using Object constructor or object literal {},
          second using user-defined constructor function)
blue   = user-defined function and its prototype
         (when you create a function, two objects are created in memory:
          the function and its prototype)

Beachten Sie, dass constructor Eigenschaft existiert nicht in der Objekte angelegt, sondern wird vererbt vom Prototypen.

InformationsquelleAutor der Antwort xorcus

Ich weiß wirklich nicht, warum die Leute nicht korrekt um, wo das eigentliche problem im Verständnis.

Damit wäre viel einfacher für Sie, um vor Ort das problem

Also lasst uns sehen, was Los ist :

var newtoy = new Gadget("webcam", "black")

newtoy 
  .constructor //newtoy's constructor function is newtoy ( the function itself)
    .prototype //the function has a prototype property.( all functions has)
      .constructor //constructor here is a **property** (why ? becuase you just did `prototype.constructor`... see the dot ? )  ! it is not(!) the constructor function  !!! this is where your mess begins. it points back to the constructor function itself ( newtoy function)
         .prototype //so again we are at line 3 of this code snippet
            .constructor //same as line 4 ...
                .prototype 
                 rating = 3

Toll , so jetzt schauen wir uns diese __proto__

Vorher bitte vergessen Sie 2 Dinge in Bezug auf __proto__ :

1. Wenn Sie ein Objekt erstellen, das mit der new Betreiber, seine internen [[Prototype]]/proto__ Eigenschaft wird festgelegt, um die prototype Eigenschaft(1) von seiner constructor function oder "Schöpfer", wenn Sie möchten .

2. Hart codiert in JS — : Object.prototype.__proto__ ist null.

Let ' s finden Sie diese 2 Punkte als "bill"

newtoy
     .__proto__ //When `newtoy` was created , Js put __proto__'s value equal to the value of the cunstructor's prototype value. which is `Gadget.prototype`.
       .__proto__ //Ok so now our starting point is `Gadget.prototype`. so  regarding "bill" who is the constructor function now? watch out !! it's a simple object ! a regular object ! prototype is a regular object!! so who is the constructor function of that object ? Right , it's the `function Object(){...}`.  Ok .( continuing "bill" ) does it has a `prototype` property ? sure. all function has. it's `Object.prototype`. just remember that when Gadget.prototype was created , it's internal `__proto__` was refered to `Object.prototype` becuase as "bill" says :"..will be set to the `prototype` property of   its `constructor function`"
          .__proto__ //Ok so now our satrting point is `Object.prototype`. STOP. read bullet 2.Object.prototype.__proto__ is null by definition. when Object.prototype ( as an object) was created , they SET THE __PROTO__ AS NULL HARDCODED

Besser?

InformationsquelleAutor der Antwort Royi Namir

Wenn alle diese zahlen waren überwältigend, lassen Sie uns nehmen einen Blick, was die Eigenschaften bedeuten.

STH.prototype

Beim erstellen einer neuen Funktion, es wird ein leeres Objekt erzeugt wird, in parallele und Zusammenhang mit der Funktion mit [[Prototype]] Kette. Der Zugriff auf dieses Objekt verwenden wir prototype Eigenschaft der Funktion.

function Gadget() {}
//in background, new object has been created
//we can access it with Gadget.prototype
//it looks somewhat like {constructor: Gadget}

Beachten Sie, dass prototype Eigenschaft ist nur für Veranstaltungen zur Verfügung.

STH.Konstruktor

Prototyp-Objekt oben erwähnt hat keine Eigenschaften, außer einer - constructor. Diese Eigenschaft repräsentiert eine Funktion, schuf den Prototyp-Objekt.

var toy = new Gadget();

Beim erstellen Gadget Funktion, erstellten wir ein Objekt wie {constructor: Gadget} wie gut, dass ist nichts, wie Gadget.prototype. Als constructor bezieht sich auf eine Funktion, die ein Objekt erstellt Prototypen, toy.constructor stellt Gadget Funktion. Wir schreiben toy.constructor.prototype und wir sind immer {constructor: Gadget} wieder.

Daher, es ist ein Teufelskreis: Sie können toy.constructor.prototype.constructor.prototype.constructor.prototype.constructor.prototype.constructor.prototype.constructor.prototype.constructor.prototype.constructor.prototype - und er wird es immer sein Gadget.prototype.

toy
.constructor    //Gadget
.prototype    //{constructor: Gadget}
.constructor    //Gadget
.prototype    //{constructor: Gadget}
//...

STH.__proto__

Während prototypeist eine Eigenschaft, die spezifisch für Funktionen __proto__ ist für alle Objekte verfügbar, da legt es in Object.prototype. Es bezieht sich auf den Prototyp einer Funktion, die ein Objekt erstellen.

[].__proto__ === Array.prototype
//true

({}).__proto === Object.prototype
//true

Hier toy.__proto__ ist Gadget.prototype. Als Gadget.prototype ist ein Objekt ({}) und Objekte erstellt werden, mit Object - Funktion (siehe Beispiel oben), bekommen wir Object.prototype. Dies ist den höheren Objekt in JavaScript und seinen __proto__ kann nur zeigen null.

toy
.__proto__    //Gadget.prototype (object looking like {constructor: Gadget})
.__proto__    //Object.prototype (topmost object in JS)
.__proto__    //null - Object.prototype is the end of any chain

InformationsquelleAutor der Antwort Damian Czapiewski