Czym __proto__ różni się od constructor.prototype?

function Gadget(name, color)
{
   this.name = name;
   this.color = color;
}

Gadget.prototype.rating = 3

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

newtoy.constructor.prototype.constructor.prototype.constructor.prototype 

Zawsze zwraca obiekt z ratingiem = 3.

Ale jeśli wykonam następujące czynności:

newtoy.__proto__.__proto__.__proto__

Łańcuch kończy się powrotem null.

Również w przeglądarce Internet Explorer, jak sprawdzić wartość null, jeśli nie ma __proto__właściwości?

Ostatnio próbowałem to obejść i w końcu wymyśliłem tę „mapę”, która moim zdaniem rzuca pełne światło na tę sprawę

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

Wiem, że nie jestem pierwszą osobą, która to wymyśliła, ale ciekawsze było wymyślenie tego niż znalezienie :-). Zresztą po tym znalazłem np. Ten kolejny schemat, który chyba mówi w zasadzie to samo:

Układ obiektów JavaScript

Najbardziej zaskakujące było dla mnie odkrycie, że zamiast tego Object.__proto__wskazuje , ale jestem pewien, że jest ku temu dobry powód :-)Function.prototypeObject.prototype

Wklejam kod wymieniony na obrazku tutaj, jeśli ktoś chce go przetestować. Zwróć uwagę, że do obiektów dodawane są pewne właściwości, dzięki czemu można łatwo zorientować się, gdzie jesteśmy po wykonaniu pewnych skoków:

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);

constructorjest predefiniowaną właściwością [[DontEnum]] obiektu wskazywanego przez prototypewłaściwość obiektu funkcji i początkowo będzie wskazywać na sam obiekt funkcji.

__proto__ jest odpowiednikiem wewnętrznej właściwości [[Prototype]] obiektu, tj. jego rzeczywistego prototypu.

Kiedy tworzysz obiekt za pomocą newoperatora, jego wewnętrzna właściwość [[Prototype]] zostanie ustawiona na obiekt wskazywany przez właściwość funkcji konstruktora prototype.

Oznacza to, że .constructorzostanie oszacowana .__proto__.constructorfunkcja konstruktora użyta do utworzenia obiektu, a jak się dowiedzieliśmy, protoypewłaściwość tej funkcji została użyta do ustawienia [[Prototype]] obiektu.

Wynika z tego, że .constructor.prototype.constructorjest identyczny z .constructor(o ile te właściwości nie zostały nadpisane); zobacz tutaj, aby uzyskać bardziej szczegółowe wyjaśnienie.

Jeśli __proto__jest dostępny, możesz przejść przez rzeczywisty łańcuch prototypów obiektu. Nie ma sposobu, aby to zrobić w zwykłym ECMAScript3, ponieważ JavaScript nie został zaprojektowany do głębokich hierarchii dziedziczenia.

Dziedziczenie prototypów w JavaScript jest oparte na __proto__własności w tym sensie, że każdy obiekt dziedziczy zawartość obiektu, do którego odwołuje się jego __proto__własność.

prototypeNieruchomość jest specjalny tylko dla Functionobiektów i wyłącznie przy użyciu newoperatora nazwać Functionjako konstruktora. W tym przypadku utworzony obiekt __proto__zostanie ustawiony na obiekt konstruktora Function.prototype.

Oznacza to, że dodawanie do Function.prototypebędzie automatycznie odzwierciedlać wszystkie obiekty, do których __proto__odwołuje się Function.prototype.

Zastąpienie konstruktora Function.prototypeinnym obiektem nie zaktualizuje __proto__właściwości żadnego z już istniejących obiektów.

Należy pamiętać, że __proto__nie należy uzyskiwać bezpośredniego dostępu do właściwości , zamiast tego należy użyć Object.getPrototypeOf (object) .

Aby odpowiedzieć na pierwsze pytanie, stworzyłem niestandardowy diagram __proto__i prototypereferencje, niestety stackoverflow nie pozwala mi na dodanie obrazu z „mniej niż 10 reputacją”. Może innym razem.

[Edytuj] Rysunek używa [[Prototype]]zamiast, __proto__ponieważ tak specyfikacja ECMAScript odnosi się do obiektów wewnętrznych. Mam nadzieję, że wszystko zrozumiesz.

Oto kilka wskazówek, które pomogą Ci zrozumieć rysunek:

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)

Zwróć uwagę, że constructorwłaściwość nie istnieje w utworzonych obiektach, ale jest dziedziczona z prototypu.

Objectjest Ewa i Functionjest Adamem, Adam ( Function) używa swojej kości ( Function.prototype) do stworzenia Ewy ( Object). Więc kto stworzył Adama ( Function)? - Wynalazca języka JavaScript :-).

Zgodnie z odpowiedzią utsainy, chcę dodać więcej przydatnych informacji.

Najbardziej zaskakujące było dla mnie odkrycie, że zamiast tego Object.__proto__ wskazuje , ale jestem pewien, że jest ku temu dobry powód :-)Function.prototypeObject.prototype

Nie powinno być. Object.__proto__NIE powinien wskazywać Object.prototype. Zamiast tego wystąpienie Object o, o.__proto__powinno wskazywać na Object.prototype.

(Wybacz mi, że używam terminów classi instanceJavaScript, ale wiesz o tym :-)

Myślę, że Objectsama klasa jest przykładem Function, dlatego Object.__proto__ === Function.prototype. Dlatego: Objectjest Ewa i Functionjest Adamem, Adam ( Function) używa swojej kości ( Function.prototype), aby stworzyć Ewę ( Object).

Co więcej, nawet Functionsama klasa jest instancją Functionsamą w sobie, to znaczy Function.__proto__ === Function.prototype, także dlategoFunction === Function.constructor

Co więcej, zwykła klasa Catjest przykładem Function, to znaczy Cat.__proto__ === Function.prototype.

Powodem tego jest to, że kiedy tworzymy klasę w JavaScript, w rzeczywistości tworzymy funkcję, która powinna być instancją Function. Objecti Functionsą po prostu wyjątkowe, ale nadal są klasami, podczas gdy Catsą zwykłą klasą.

W związku z tym, w silniku JavaScript Google Chrome, następujące 4:

• Function.prototype
• Function.__proto__
• Object.__proto__
• Cat.__proto__

Wszystkie są ===(absolutnie równe) pozostałym trzem, a ich wartość wynosifunction Empty() {}

> Function.prototype
  function Empty() {}
> Function.__proto__
  function Empty() {}
> Object.__proto__
  function Empty() {}
> Cat.__proto__
  function Empty() {}
> Function.prototype === Function.__proto__
  true
> Function.__proto__ === Object.__proto__
  true
> Object.__proto__ === Cat.__proto__
  true

DOBRZE. Więc kto tworzy specjalny function Empty() {}( Function.prototype)? Pomyśl o tym :-)

Naprawdę nie wiem, dlaczego ludzie nie poprawiali cię, gdzie jest rzeczywisty problem w twoim rozumieniu.

To znacznie ułatwiłoby wykrycie problemu

Zobaczmy więc, co się dzieje:

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

Świetnie, więc teraz spójrzmy na to __proto__

Wcześniej pamiętaj o 2 rzeczach dotyczących __proto__ :

1. Kiedy tworzysz obiekt za pomocą newoperatora, jego właściwość wewnętrzna [[Prototype]]/ proto__zostanie ustawiona na prototypewłaściwość (1) jego constructor functionlub „twórcy”, jeśli chcesz.

2. Zakodowany na stałe w JS -: Object.prototype.__proto__jest null.

Nazwijmy te 2 punkty „ 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

Lepszy?

Każda funkcja tworzy jej prototyp. A kiedy utworzymy obiekt za pomocą tego konstruktora funkcji, wówczas właściwość __proto__ mojego obiektu zacznie wskazywać na prototyp tej funkcji.

Jeśli wszystkie te liczby były przytłaczające, spójrzmy, co oznaczają te właściwości.

STH.prototype

Podczas tworzenia nowej funkcji równolegle tworzony jest pusty obiekt połączony z funkcją [[Prototype]]łańcuchem. Aby uzyskać dostęp do tego obiektu, używamy prototypewłaściwości funkcji.

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

Pamiętaj, że prototypewłaściwość jest dostępna tylko dla funkcji.

STH.constructor

Wspomniany powyżej obiekt prototypowy nie ma żadnych właściwości poza jedną - constructor. Ta właściwość reprezentuje funkcję, która utworzyła obiekt prototypowy.

var toy = new Gadget();

Tworząc Gadgetfunkcję, stworzyliśmy również obiekt podobny {constructor: Gadget}- to nic takiego Gadget.prototype. Jak constructorodnosi się do funkcji, która utworzyła prototyp obiektu, toy.constructorreprezentuje Gadgetfunkcję. Piszemy toy.constructor.prototypei {constructor: Gadget}znowu dostajemy .

Dlatego pojawia się błędne koło: możesz używać toy.constructor.prototype.constructor.prototype.constructor.prototype.constructor.prototype.constructor.prototype.constructor.prototype.constructor.prototype.constructor.prototypei zawsze będzie Gadget.prototype.

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

STH .__ proto__

Chociaż prototypejest właściwością specyficzną dla funkcji, __proto__jest dostępna dla wszystkich obiektów, w jakiej się znajduje Object.prototype. Odnosi się do prototypu funkcji, która może stworzyć obiekt.

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

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

Tutaj toy.__proto__jest Gadget.prototype. Tak Gadget.prototypejak obiekt ( {}) i obiekty są tworzone za pomocą Objectfunkcji (patrz przykład powyżej), otrzymujemy Object.prototype. To jest wyższy obiekt w JavaScript i __proto__może tylko wskazywać 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

Krótka odpowiedź: __proto__to odniesienie do prototypewłaściwości konstruktora, który utworzył obiekt.

Obiekty w JavaScript

Obiekt JavaScript jest typem wbudowanym dla zbioru zawierającego zero lub więcej właściwości. Właściwości to kontenery zawierające inne obiekty, wartości pierwotne lub funkcje.

Konstruktory w JavaScript

Funkcje są zwykłymi obiektami (które implementują się [[Call]]w terminach ECMA-262) z dodatkową możliwością wywoływania, ale odgrywają inną rolę w JavaScript: stają się konstruktorami ( fabrykami obiektów), jeśli zostaną wywołane przez newoperatora. Konstruktorzy są więc przybliżonym odpowiednikiem klas w innych językach.

Każda funkcja JavaScript jest w rzeczywistości instancją Functionwbudowanego obiektu funkcji, który ma specjalną właściwość o nazwie prototypeużywaną do implementacji dziedziczenia opartego na prototypach i właściwości wspólnych. Każdy obiekt utworzony przez funkcję konstruktora ma niejawne odniesienie (zwane prototypem lub __proto__) do wartości swojego konstruktora prototype.

Konstruktor prototypejest rodzajem planu budowania obiektów, ponieważ każdy obiekt utworzony przez konstruktora dziedziczy odniesienie do jego prototype.

Łańcuch prototypów

Obiekt określa swój prototyp za pomocą właściwości wewnętrznej [[Prototype]]lub __proto__. Relacja prototypów między dwoma obiektami dotyczy dziedziczenia: każdy obiekt może mieć inny obiekt jako swój prototyp. Prototyp może być nullwartością.

Łańcuch obiektów połączonych __proto__właściwością nazywany jest łańcuchem prototypów . Kiedy odwołuje się do właściwości obiektu, odnosi się ono do właściwości napotkanej w pierwszym obiekcie w łańcuchu prototypów, który zawiera właściwość o tej nazwie. Łańcuch prototypów zachowuje się tak, jakby był pojedynczym obiektem.

Zobacz ten obraz (pobrany z tego bloga ):

Za każdym razem, gdy próbujesz uzyskać dostęp do właściwości w obiekcie, JavaScript rozpoczyna wyszukiwanie jej w tym obiekcie i kontynuuje pracę ze swoim prototypem, prototypem prototypu i tak dalej, aż do napotkania właściwości lub jeśli __proto__zachowa wartość null.

Ten typ dziedziczenia przy użyciu łańcucha prototypów jest często nazywany delegacją, aby uniknąć nieporozumień z innymi językami używającymi łańcucha klas.

Prawie wszystkie obiekty są instancjami Object, ponieważ Object.prototypesą ostatnim w łańcuchu prototypów. Ale Object.prototypenie jest przykładem, Objectponieważ Object.prototype.__proto__ma wartość null.

Możesz także stworzyć obiekt z nullprototypem takim jak ten:

var dict = Object.create(null);

Taki obiekt jest lepsze mapy (słownika) niż dosłownym obiektu, dlatego ten wzór jest czasami nazywany DICT wzór ( dict do słownika).

Uwaga: obiekty literalne utworzone za pomocą {}są instancjami, Objectponieważ ({}).__proto__jest odwołaniem do Object.prototype.