__proto__ В.С. прототип в JavaScript

Цей малюнок ще раз показує, що кожен об’єкт має прототип. Функція конструктора Foo також має свою __proto__функцію, яка є Function.prototype, і яка, у свою чергу, також посилається через свою __proto__властивість знову на Object.prototype. Таким чином, повторимо, Foo.prototype - це явне властивість Foo, яке стосується прототипу об'єктів b і c.

var b = new Foo(20);
var c = new Foo(30);

Які відмінності між __proto__і prototype?

Фігура взята з dmitrysoshnikov.com .

__proto__- це фактичний об'єкт, який використовується у ланцюзі пошуку для вирішення методів тощо prototype. Об'єкт, який використовується для створення __proto__при створенні об'єкта за допомогою new:

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

prototypeє властивістю об'єкта Функції. Це прототип об'єктів, побудованих за допомогою цієї функції.

__proto__є внутрішньою властивістю об'єкта, що вказує на його прототип. Чинні стандарти пропонують еквівалентний Object.getPrototypeOf(O)метод, хоча стандарт де-факто __proto__швидший.

Ви можете знайти instanceofвідносини, порівнюючи функції з ланцюгом prototypeоб'єкта __proto__, і ви можете розірвати ці зв'язки, змінивши 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;

Ось Pointфункція конструктора, вона будує об’єкт (структуру даних) процедурно. myPoint- об'єкт, побудований Point()таким чином, в цей час Point.prototypeзберігається myPoint.__proto__.

Властивість прототипу створюється при оголошенні функції.

Наприклад:

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

Person.prototypeвластивість створюється внутрішньо, коли ви заявляєте вище про функцію. До ресурсу Person.prototype можна додати багато властивостей, якими поділяються екземпляри Person, створені за допомогою нового Person ().

// adds a new method age to the Person.prototype Object.
Person.prototype.age = function(){return date-dob}; 

Варто зазначити, що Person.prototypeце Objectза замовчуванням буквальний (його можна змінити у міру необхідності).

Кожен екземпляр, створений за допомогою, new Person()має __proto__властивість, яка вказує на Person.prototype. Це ланцюг, який використовується для переходу для пошуку властивості конкретного об'єкта.

var person1 = new Person(somedate);
var person2 = new Person(somedate);

створює 2 екземпляри Person , ці 2 об'єкти можна назвати ageметод , Person.prototypeяк person1.age, person2.age.

На наведеному вище малюнку із запитання ви бачите, що Fooце є, Function Objectа тому воно має __proto__посилання на те, Function.prototypeщо в свою чергу є екземпляром Objectі має __proto__посилання наObject.prototype . Протопосилання закінчується __proto__на Object.prototypeвказівці на null.

Будь-який об'єкт може мати доступ до всіх властивостей протопрограми, пов'язаних між собою __proto__, тим самим утворюючи основу для успадкування прототипів.

__proto__не є стандартним способом доступу до прототипу ланцюга, стандартним, але подібним підходом є використання Object.getPrototypeOf(obj).

Нижче код для instanceof оператора дає краще розуміння:

instanceofОператор класу об'єктів повертається, trueколи об'єкт є екземпляром Класу, точніше, якщо Class.prototypeвін знайдений у прото-ланцюзі цього об'єкта, то об'єкт є екземпляром цього Класу.

function instanceOf(Func){
  var obj = this;
  while(obj !== null){
    if(Object.getPrototypeOf(obj) === Func.prototype)
      return true;
    obj = Object.getPrototypeOf(obj);
  }
  return false;
}      

Вищеописаний метод можна назвати так: instanceOf.call(object, Class)який повертає true, якщо об'єкт є екземпляром Class.

Гарний спосіб подумати про це ...

prototypeвикористовується constructor()функціями. Це справді мало би називатися чимось на кшталт "prototypeToInstall", адже саме так воно і є.

і __proto__це "встановлений прототип" на об'єкті (який був створений / встановлений на об'єкті із зазначеної constructor()функції)

Для пояснення створимо функцію

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

Коли JavaScript виконує цей код, він додає prototypeвластивість a, prototypeвластивість - це об'єкт з двома властивостями до нього:

1. constructor
2. __proto__

Так коли ми робимо

a.prototype вона повертається

     constructor: a  // function definition
    __proto__: Object

Тепер, як ви бачите, constructorце не що інше, як aсама функція і __proto__вказує на кореневий рівень ObjectJavaScript.

Давайте подивимося, що відбувається, коли ми використовуємо aфункцію з newключовим словом.

var b = new a ('JavaScript');

Коли JavaScript виконує цей код, він робить 4 речі:

1. Він створює новий об’єкт, порожній об’єкт // {}
2. Він створює __proto__на bі робить це вказує на a.prototypeSob.__proto__ === a.prototype
3. Він виконує a.prototype.constructor(що є визначенням функції a) з новоствореним об'єктом (створеним на кроці # 1) як його контекст (це), отже, nameвластивість, передана як "JavaScript" (яка додається до this), додається до новоствореного об'єкта.
4. Він повертає новостворений об'єкт у (створений на кроці №1), тому var bприсвоюється новоствореному об'єкту.

Тепер якщо ми додамо a.prototype.car = "BMW"і зробимо b.car, з'явиться вихід "BMW".

це тому, що коли JavaScript виконував цей код, він шукав carвластивість b, він не знаходив тоді використовуваний JavaScript b.__proto__(що було зроблено для вказівки на "a.prototype" на кроці №2) і знаходить carвластивість, щоб повернути "BMW".

Прототип В.С. __proto__ В.С. [[Прототип]]

Під час створення функції об'єкт властивості під назвою прототип створюється автоматично (ви його не створили самостійно) і додається до об'єкта функції (the constructor).
Примітка . Цей новий об'єкт- прототип також вказує на або має внутрішньо-приватне посилання на нативний об’єкт JavaScript.

Приклад:

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

Якщо ви створюєте новий об'єкт за Fooдопомогою newключового слова, ви в основному створюєте (серед іншого) новий об'єкт, який має внутрішнє або приватне посилання на Fooпрототип функції, про яку ми говорили раніше:

var b = new Foo();

b.[[Prototype]] === Foo.prototype  // true

Якщо бути більш конкретним, __proto__насправді це функція getter, яка належить до рідного JavaScript Object. Вона повертає внутрішній приватно-прототип ув'язку Як би там не thisзв'язування (повертає [[Prototype]]з b):

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

Варто зазначити, що для початку ECMAScript5, ви також можете використовувати метод getPrototypeOf для отримання внутрішнього приватного зв’язку:

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

Щоб зробити це трохи зрозумілим на додаток до вищезазначених чудових відповідей:

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

var eve = new Person("Eve");

eve.__proto__ == Person.prototype //true

eve.prototype  //undefined

Примірники мають __proto__ , класи мають прототип .

У JavaScript функція може бути використана як конструктор. Це означає, що ми можемо створювати з них об’єкти за допомогою нового ключового слова. Кожна конструкторська функція має вбудований об'єкт, прикований до них. Цей вбудований об'єкт називається прототипом.Instances of a constructor function use __proto__ to access the prototype property of its constructor function.

1. Спочатку ми створили конструктор: function Foo(){}. Щоб було зрозуміло, Foo - це лише інша функція. Але ми можемо створити з нього об’єкт за допомогою нового ключового слова. Тому ми називаємо це функцією конструктора

2. Кожна функція має унікальну властивість, яку називають властивістю прототипу. Отже, функція Constructor Fooмає властивість прототипу, яка вказує на її прототип, який є Foo.prototype(див. Зображення).

3. Функції конструктора самі по собі є функцією, яка є екземпляром конструктора системи, який називається конструктором [[Функція]]. Тож ми можемо це сказатиfunction Foo побудований конструктором [[Функція]]. Отже, __proto__з нашого Foo functionвкажемо на прототип його конструктора, який є Function.prototype.

4. Function.prototypeСам по собі є не що інше, як об'єкт, побудований з іншого конструктора системи, який називається [[Object]]. Отже, [[Object]]є конструктором Function.prototype. Отже, можна сказатиFunction.prototype , це примірник [[Object]]. Тож __proto__з Function.prototypeпунктів до Object.prototype.

5. Object.prototypeє останньою людиною, що стоїть у ланцюзі прототипу. Я маю на увазі, що вона не побудована. Це вже є в системі. Тож його __proto__вказівки на null.

6. Тепер ми приходимо до примірників Foo. Коли ми створюємо екземпляр за допомогою new Foo(), він створює новий об'єкт, який є екземпляром Foo. Це означає, що Fooє конструктором цих примірників. Тут ми створили два екземпляри (x і y). __proto__x і y таким чином вказує на Foo.prototype.

Підсумок:

__proto__Властивість об'єкта є властивістю , яке відображає наprototype функції конструктора об'єкта. Іншими словами:

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

Це використовується для формування prototype ланцюга предмета. prototypeЛанцюг є механізм пошуку властивостей на об'єкті. Якщо доступ до властивості об'єкта доступний, JavaScript спочатку подивиться на сам об’єкт. Якщо об’єкт не знайдений там, він підніметься аж до protochainтих пір, поки його не знайдуть (чи ні)

Приклад:

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 

Результати нашого першого журналу true- це тому, що, як було сказано__proto__ властивість екземпляра, створеного конструктором, відноситься доprototype властивості конструктора. Пам'ятайте, що в JavaScript функції також є Об'єктами. Об'єкти можуть мати властивості, а типовою властивістю будь-якої функції є одна властивість, названа прототипом.

Потім, коли ця функція буде використана як конструкторська функція, об'єкт, інстанціонований від неї, отримає властивість під назвою __proto__. І ця __proto__властивість відноситься доprototype властивість функції конструктора (яку за замовчуванням має кожна функція).

Чому це корисно?

JavaScript має механізм, коли шукає властивості, за Objectsякими називається "прототипічне успадкування" , ось що в основному це робить:

• По-перше, це перевіряється, чи властивість знаходиться на самому Об'єкті. Якщо так, це властивість повертається.
• Якщо властивість не знаходиться на самому об'єкті, воно буде "підніматися в протокол". Він в основному розглядає об'єкт, на який посилається __proto__властивість. Там він перевіряє, чи є власність доступною для об'єкта, на який посилається __proto__.
• Якщо властивість не знаходиться на __proto__об’єкті, воно підніметься вгору по __proto__ланцюжку, аж доObject об'єкта.
• Якщо він не зможе знайти властивість ніде на об'єкті та його prototypeланцюжку, він повернеться undefined.

Наприклад:

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

let mySelf = new Person('Willem');

console.log(mySelf.__proto__ === Person.prototype);

console.log(mySelf.__proto__.__proto__ === Object.prototype);

У мене трапляється вчитися прототипу від You Don't Know JS: this & Object Prototypes , яка є чудовою книгою, щоб зрозуміти дизайн під ним і уточнити стільки помилок (саме тому я намагаюся уникати використання спадщини та подібних речей instanceof).

Але у мене те саме питання, що тут задавали люди. Кілька відповідей справді корисні та освічуючі. Я також хотів би поділитися своїми розуміннями.

Що таке прототип?

Об'єкти в JavaScript мають внутрішнє властивість, позначене в специфікації як [[Prototype]], яке є просто посиланням на інший об'єкт. Майже всі об’єкти мають nullцінність для цього властивості на момент їх створення.

Як отримати прототип об’єкта?

через __proto__абоObject.getPrototypeOf

var a = { name: "wendi" };
a.__proto__ === Object.prototype // true
Object.getPrototypeOf(a) === Object.prototype // true

function Foo() {};
var b = new Foo();
b.__proto__ === Foo.prototype
b.__proto__.__proto__ === Object.prototype

Що таке prototype?

prototype- об'єкт автоматично створюється як особлива властивість функції , яка використовується для встановлення ланцюга делегування (успадкування), також ланцюга прототипу.

Коли ми створюємо функцію a, prototypeавтоматично створюється як спеціальне властивість увімкнено, aа код функції зберігається як constructorвключений prototype.

function Foo() {};
Foo.prototype // Object {constructor: function}
Foo.prototype.constructor === Foo // true

Я хотів би розглянути цю властивість як місце для зберігання властивостей (включаючи методи) об’єкта функції. Це також причина, чому функції утиліти в JS визначаються як Array.prototype.forEach(),Function.prototype.bind() ,Object.prototype.toString().

Навіщо підкреслювати властивість функції ?

{}.prototype // undefined;
(function(){}).prototype // Object {constructor: function}

// The example above shows object does not have the prototype property.
// But we have Object.prototype, which implies an interesting fact that
typeof Object === "function"
var obj = new Object();

Так Arary, Function, Objectвсі функції. Я повинен визнати, що це освіжає моє враження про JS. Я знаю, що функції є першокласним громадянином в JS, але здається, що він побудований на функціях.

Яка різниця між __proto__і prototype?

__proto__посилання працює на кожен об’єкт для посилання на його [[Prototype]]властивість.

prototype- це об'єкт, автоматично створений як особлива властивість функції , який використовується для зберігання властивостей (включаючи методи) об’єкта функції.

З цими двома ми могли б подумки зіставити ланцюжок прототипу. Як показано на цьому малюнку:

function Foo() {}
var b = new Foo();

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

'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

У JavaScript кожен об’єкт (функція теж об’єкт!) Має __proto__властивість, властивість посилається на його прототип.

Коли ми використовуємо newоператор з конструктором для створення нового об’єкта, __proto__властивість нового об'єкта буде встановлена ​​за допомогою конструктораprototype властивістю , тоді конструктор буде викликаний новим об'єктом, в цьому процесі "це" буде посиланням на новий об'єкт в області конструктора нарешті поверніть новий об’єкт.

Прототип конструктора є __proto__власністю, властивість конструктора - prototypeце робота з newоператором.

Конструктор повинен бути функцією, але функція не завжди є конструктором, навіть якщо вона має prototypeвластивість.

Ланцюг прототипу насправді є __proto__властивістю об'єкта посилатися на свій прототип, а __proto__властивість прототипу - посилатися на прототип прототипу тощо, аж до посилання на __proto__властивість прототипу Об'єкта, що посилається на null.

Наприклад:

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

[[Prototype]]а __proto__майно насправді одне й те саме.

Ми можемо використовувати метод getPrototypeOf Object, щоб отримати щось прототип.

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

Будь-яка написана нами функція може бути використана для створення об'єкта з newоператором, тому будь-яка з цих функцій може бути конструктором.

Ще один хороший спосіб зрозуміти це:

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

Лише після того, як IE11 __proto__підтримується. До цієї версії, такі як IE9, ви могли б використовувати , constructorщоб отримати __proto__.

прототип

прототип - властивість функції. Це план створення об'єктів за допомогою функції (конструктор) з новим ключовим словом.

__proto__використовується в ланцюзі пошуку для вирішення методів, властивостей. коли об’єкт створений (використовуючи функцію конструктора з новим ключовим словом), __proto__встановлюється (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

Ось моє (уявне) пояснення, щоб очистити плутанину:

Уявіть, що існує уявний клас (креслення / виріз cookie), пов'язаний з функцією. Цей уявний клас використовується для інстанціювання об'єктів. prototypeце механізм розширення (метод розширення в C # або розширення Swift) для додавання речей до цього уявного класу.

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

Сказане можна уявити як:

// 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;
    }

} 

Тому,

var robot = new Robot();

robot.__proto__ == Robot.prototype
robot.prototype == undefined
robot.__proto__.__proto__ == Object.prototype

Тепер додаємо метод до prototypeроботи:

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)

Сказане можна уявити як розширення класу Robot:

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

Які в свою чергу,

// 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
    };
}

Простіше кажучи:

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

Це дозволяє приєднати властивості до X.prototype ПІСЛЯ об'єктів типу X було створено, і вони все одно отримають доступ до цих нових властивостей через посилання __proto__, яке використовує Javascript-двигун для проходження ланцюга прототипу.

Прототип або Object.prototype є властивістю об'єкта буквалом . Він представляє об'єкт- прототип об'єкта, який ви можете змінити, щоб додати більше властивостей або методів далі по ланцюжку прототипу.

__proto__ - це властивість аксесуара (функція get and set), яка розкриває внутрішній прототип об'єкта, через який він має доступ.

Список літератури:

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

Я знаю, я спізнююсь, але дозвольте спробувати спростити це.

Скажімо, є функція

    function Foo(message){

         this.message = message ; 
     };

     console.log(Foo.prototype);

Функція Foo матиме пов'язаний прототип. Отже, кожного разу, коли ми створюємо функцію в JavaScript, у неї завжди є об'єкт прототипу, пов'язаний з нею.

Тепер давайте продовжимо та створимо два об’єкти за допомогою функції Foo.

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

1. Тепер у нас є два об’єкти, об’єкт a і об'єкт b. Обидва створені за допомогою конструктора Foo. Майте на увазі, конструктор тут просто слово.
2. Обидва об'єкти a і b мають властивість копії повідомлення.
3. Ці два об'єкти a і b пов'язані з прототипом об'єкта конструктора Foo.
4. На об'єктах a і b ми можемо отримати доступ до прототипу Foo, використовуючи прото- властивість у всіх браузерах, а в IE ми можемо використовувати Object.getPrototypeOf (a) або Object.getPrototypeOf (b)

Тепер Foo.prototype, a. прото , і б. proto - позначає один і той же об'єкт.

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

все вище повернеться правдою.

Як ми знаємо, в JavaScript властивості можна додавати динамічно. Ми можемо додати властивість до об’єкта

    Foo.prototype.Greet = function(){

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

Як ви бачите, ми додали метод Greet () у Foo.prototype, але він доступний у a і b або будь-якому іншому об'єкті, побудованому за допомогою Foo.

Під час виконання a.Greet () JavaScript спочатку здійснить пошук Greet в об'єкті a у списку властивостей. Якщо не знайти, він підніметься в прото- ланцюжку a. З а. proto і Foo.prototype - той самий об'єкт, JavaScript знайде метод Greet () та виконає його.

Сподіваюсь, тепер прототип і proto трохи спрощені.

Пояснювальний приклад:

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

let myPuppie = new Dog()

Тепер у myPupppie є __proto__властивість, яка вказує на Dog.prototype.

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

але myPuppie НЕ має властивості прототипу.

> myPuppie.prototype
>> undefined

Отже, __proto__mypuppie - це посилання на властивість .prototype функції конструктора, яке було використано для інстанціювання цього об’єкта (і поточний об'єкт myPuppie має відношення до цього "делегувати"__proto__ об'єкта), тоді як .prototype властивість myPuppie просто відсутня (оскільки ми його не встановлювали).

Добре пояснення MPJ тут: proto vs prototype - Створення об'єктів у JavaScript

Я зробив для себе невеликий малюнок, який представляє такий фрагмент коду:

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

У мене є класичний фон OO, тому було корисно представити ієрархію таким чином. Щоб прочитати цю діаграму, розгляньте прямокутники на зображенні як об’єкти JavaScript. І так, функції також є об'єктами. ;)

Об'єкти в JavaScript мають властивості і __proto__є лише одним з них.

Ідея, що стоїть за цією властивістю, полягає в тому, щоб вказати на об'єкт-предка в (спадкової) ієрархії.

Кореневим об'єктом у JavaScript є, Object.prototypeа всі інші об'єкти є нащадками цього. __proto__Властивість кореневого об'єктаnull , який являє собою кінець успадкування ланцюга.

Ви помітите, що prototypeце властивість функцій. Catє функцією, але також є Functionі Objectє (рідною) функцією.tomне є функцією, тому вона не має цієї властивості.

Ідея цієї властивості полягає в тому, щоб вказати на об'єкт, який буде використовуватися в побудові, тобто коли ви викликаєте newоператора цієї функції.

Зауважте, що об’єкти прототипу (жовті прямокутники) мають ще одне властивість, constructorяке називається, яке вказує на відповідний об'єкт функції. З огляду на стислість це не було зображено.

Дійсно, коли ми створюємо tomоб'єкт за допомогою new Cat(), створений об’єкт матиме __proto__властивість, встановлену для prototypeоб'єкта функції конструктора.

Зрештою, давайте трохи пограємо з цією діаграмою. Наступні твердження вірні:

• tom.__proto__властивість вказує на той самий об'єкт, що і Cat.prototype.

• Cat.__proto__вказує на Function.prototypeоб’єкт, як Function.__proto__і Object.__proto__робити.

• Cat.prototype.__proto__і tom.__proto__.__proto__вказують на той самий об’єкт, і це Object.prototype.

Ура!

ВИЗНАЧЕННЯ

(число в круглих дужках () - це "посилання" на код, який написано нижче)

prototype- об'єкт, який складається з:
=> функцій (3) цього конкретного ConstructorFunction.prototype(5), доступних кожному об'єкту (4), створеному або створюваному за допомогою цієї функції конструктора (1)
=> сама функція конструктора (1 )
=> __proto__цього конкретного об'єкта (прототипного об'єкта)

__proto__(dandor proto?) - посилання між будь-яким об'єктом (2), створеним за допомогою певної функції конструктора (1), а властивості об'єкта-прототипу (5) цього конструктора, що дозволяє кожному створеному об'єкту (2) отримати доступ до функцій прототипу та методи (4) ( __proto__за замовчуванням включений у кожен об'єкт JS)

КЛАФІКАЦІЯ КОДУ

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;

Я спробую пояснити 4-й клас:

Речі дуже прості. А prototypeє прикладом того, як щось потрібно будувати. Тому:

• Я functionі будую нові об'єкти, подібні до моїхprototype

• Я є, objectі я був побудований, використовуючи свій __proto__приклад

доказ :

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

Кожна створена вами функція має властивість, яку називають prototype, і вона починає своє життя як порожній об'єкт. Це властивість не приносить користі, поки ви не будете використовувати цю функцію як конструкторську функцію, тобто з ключовим словом "new".

Це часто плутають із __proto__властивістю об’єкта. Деякі можуть заплутатися, за винятком того, що prototypeвластивість об'єкта може змусити їх стати прототипом об'єкта. Але це не так. prototypeвикористовується для отримання__proto__ об'єкта, створеного з конструктора функцій.

У наведеному вище прикладі:

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__

Сподіваюся, це має сенс.

Що з використанням __proto__статичних методів?

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

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

Спробуйте цей код, щоб зрозуміти

Існує лише один об'єкт, який використовується для пропіпального ланцюга. Цей об'єкт, очевидно, має ім'я та значення: __proto__це його ім'я та prototypeйого значення. Це все.

щоб зробити його ще простіше зрозуміти, подивіться на діаграму вгорі цього повідомлення (Діаграма Дмитра Сошнікова), ви ніколи не знайдете вказівки __proto__на щось інше, крімprototype як на його значення.

Суть у цьому: __proto__це ім'я, на яке посилається прототипний об'єкт, і prototypeє власне прототипним об'єктом.

Це як сказати:

let x = {name: 'john'};

x- це ім'я об'єкта (вказівник) і {name: 'john'}є фактичним об'єктом (значення даних).

ПРИМІТКА. Це просто масово спрощений натяк на те, як вони пов'язані на високому рівні.

Оновлення: Ось простий конкретний приклад javascript для кращої ілюстрації:

let x = new String("testing") // Or any other javascript object you want to create

Object.getPrototypeOf(x) === x.__proto__; // true

Це означає , що , коли Object.getPrototypeOf(x)отримує нас фактичне значення x(яке є його прототипом), є саме те , що __proto__з xвказує на. Тому __proto__дійсно вказує на прототип x. Таким чином, __proto__посилання x(покажчик на x), і prototypeє значенням x(його прототип).

Я сподіваюся, що це зараз трохи зрозуміло.

Це дуже важливе питання, актуальне для всіх, хто хоче зрозуміти прототипне успадкування. З того, що я розумію, прототип призначається за замовчуванням, коли об’єкт створюється новим з функції, оскільки функція має об’єкт прототипу за визначенням:

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

Коли ми створюємо звичайний об'єкт без нового, тобто явно з функції, він не має прототипу, але у нього є порожній прото, якому можна призначити прототип.

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

Ми можемо використовувати Object.create для явного зв'язку об'єкта.

// 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`

__proto__є базою для побудови prototypeта функцією конструктора, наприклад: function human(){}має, prototypeяку поділяють через __proto__в новому екземплярі функції конструктора. Детальніше читайте тут

Як це правильно сказано

__proto__є фактичним об'єктом, який використовується в ланцюзі пошуку для вирішення методів тощо. Прототипом є об'єкт, який використовується для створення __proto__при створенні об'єкта з новим:

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

Далі можна відзначити, що __proto__властивість об'єкта, створеного за допомогою конструктора функцій, вказує на місце пам'яті, вказане прототипом властивість відповідного конструктора.

Якщо ми змінимо місце пам'яті прототипу функції конструктора, __proto__похідний об'єкт все ще буде вказувати на вихідний адресний простір. Тому, щоб зробити загальну властивість доступною по ланцюжку успадкування, завжди додайте властивість до прототипу функції конструктора , а не повторно ініціалізуючи його (що змінило б його адресу пам'яті).

Розглянемо наступний приклад:

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

моє розуміння таке: __proto__ і прототип усі подаються для ланцюгової техніки прототипу. Різниця полягає в тому, що функції, названі підкресленням (наприклад, __proto__), взагалі не спрямовані на те, щоб розробники посилалися явно. Іншими словами, вони є лише для деяких механізмів, таких як успадкування і т. д. вони є "бек-ендом". але функції, названі без підкреслення, призначені для явного виклику, вони є "передній".

!!! ЦЕ НАЙКРАЩЕ ПОЯСНЕННЯ В СВІТІ !!!!!

var q = {}
var prototype = {prop: 11}

q.prop // undefined
q.__proto__ = prototype
q.prop // 11

у конструкторах функцій JavaScript-движок викликає це q.__proto__ = prototypeавтоматично, коли ми пишемо new Class, і в __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

Насолоджуйтесь%)