it-swarm.com.ru

__proto__ VS. прототип в 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?

enter image description here

Цифра взята из здесь .

664
0x90

__proto__ - это фактический объект, который используется в цепочке поиска для разрешения методов и т. д. prototype - это объект, который используется для построения __proto__ при создании объекта с new:

( new Foo ).__proto__ === Foo.prototype;
( new Foo ).prototype === undefined;
652
Mark Kahn

prototype является свойством объекта Function. Это прототип объектов, созданных этой функцией.

__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__ в это время.

304
Imp

Свойство прототипа создается при объявлении функции. 

Например:

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

Свойство Person.prototype создается внутри, как только вы объявляете вышеуказанную функцию . Многие свойства могут быть добавлены в Person.prototype, которые совместно используются экземплярами Person, созданными с помощью new 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 объекта могут вызывать возрастное свойство Person.prototype как person1.age, person2.age.

На приведенном выше рисунке вы можете видеть, что Foo является объектом-функцией, и поэтому он имеет ссылку __proto__ на Function.prototype, который, в свою очередь, является экземпляром Object и имеет ссылку __proto__ на Object.prototype. Прото-ссылка заканчивается здесь __proto__ в Object.prototype, указывающем на ноль.

Любой объект может иметь доступ ко всем свойствам в своей цепочке прототипов, связанным с помощью __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, если объект является экземпляром класса.

104
sid_k_reddy

Хороший способ думать об этом ...

prototype используется функциями constructor(). На самом деле это должно было называться что-то вроде "prototypeToInstall", потому что это так.

и __proto__ - это тот "установленный прототип" на объекте (который был создан/установлен на объекте из указанной функции constructor())

60
sarink

Прототип VS. __proto__ VS. [[Прототип]]

При создании функции объект свойства с именем prototype создается автоматически (вы не создавали его самостоятельно) и присоединяется к объекту функции (constructor).
Note: Этот новый объект prototype также указывает или имеет внутренне-частную ссылку на собственный объект 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


Связь private с объектом этой функции называется прототипом в двойных скобках или просто [[Prototype]]. Многие браузеры предоставляют нам ссылку public, которая называется __proto__!

Чтобы быть более конкретным, __proto__ на самом деле является функцией получения , которые принадлежат нативному объекту JavaScript. Он возвращает внутренне-частную связь прототипа любой привязки this (возвращает [[Prototype]] из b):

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

Стоит отметить, что начиная с ECMAScript5, вы также можете использовать метод getPrototypeOf для получения внутренней частной связи:

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


ПРИМЕЧАНИЕ: этот ответ не предназначен для того, чтобы охватить весь процесс создания новых объектов или новых конструкторов, но чтобы помочь лучше понять, что такое __proto__, prototype и [[Prototype]] и как он работает.

43
Lior Elrom

Чтобы объяснить, давайте создадим функцию

 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__ указывает на корневой уровень Object JavaScript.

Давайте посмотрим, что происходит, когда мы используем функцию a с ключом new Word.

var b = new a ('JavaScript');

Когда JavaScript выполняет этот код, он выполняет 4 вещи:

  1. Создает новый объект, пустой объект // {}
  2. Он создает __proto__ для b и делает его указателем на a.prototype, поэтому b.__proto__ === a.prototype
  3. Он выполняет a.prototype.constructor (который является определением функции a) с вновь созданным объектом (созданным на шаге 1) в качестве его контекста (this), поэтому свойство 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» ,.

41
Manishz90

Чтобы сделать это немного яснее в дополнение к вышеупомянутым отличным ответам:

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

var eve = new Person("Eve");

eve.__proto__ == Person.prototype //true

eve.prototype  //undefined

Экземпляры имеют_PROTO_, классы имеют прототип .

24
serkan

В JavaScript функция может использоваться как конструктор. Это означает, что мы можем создавать объекты из них, используя ключевое слово new. Каждая функция конструктора поставляется со встроенным объектом, связанным с ними. Этот встроенный объект называется прототипом. Instances of a constructor function use __proto__ to access the prototype property of its constructor function.

 prototype diagram

  1. Сначала мы создали конструктор: function Foo(){}. Чтобы быть понятным, Foo это просто еще одна функция. Но мы можем создать объект из него с новым ключевым словом. Вот почему мы называем это функцией конструктора

  2. Каждая функция имеет уникальное свойство, которое называется свойством прототипа. Итак, функция Constructor Foo имеет свойство prototype, которое указывает на его прототип, то есть Foo.prototype (см. Изображение).

  3. Конструктивные функции сами являются функцией, которая является экземпляром системного конструктора, называемого конструктором [[Function]]. Таким образом, мы можем сказать, что function Foo создается конструктором [[Function]]. Итак, __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.

8
AL-zami

Еще один хороший способ понять это:

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__.

6
Yad Smood

Я изучаю прототип из You Not 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 - это объект, автоматически создаваемый как специальное свойство function, которое используется для создания цепочки делегирования (наследования), то есть цепочки прототипов.

Когда мы создаем функцию 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__a работает на каждый объект для ссылки на его свойство [[Prototype]].

prototype - это объект, автоматически создаваемый как специальное свойство function, которое используется для хранения свойств (включая методы) объекта функции.

С этими двумя мы могли мысленно наметить цепочку прототипов. Как эта картина иллюстрирует:

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

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

Проще говоря:

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

Это позволяет вам присоединять свойства к X.prototype. Объекты AFTER типа X были созданы, и они по-прежнему будут получать доступ к этим новым свойствам через ссылку __proto__, которую Javascript-движок использует для прохождения по цепочке прототипов.

4
Andreas Bergström

прототип

прототип является свойством функции. Это план создания объектов с использованием этой функции (конструктора) с ключевым словом new.

__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

Вот мое (воображаемое) объяснение, чтобы убрать путаницу:

Представьте себе, что существует некий воображаемый класс (планер/резак), связанный с функцией. Этот воображаемый класс используется для создания объектов. prototype - это механизм расширения (метод расширения в C # или Swift Extension) для добавления объектов в этот воображаемый класс. 

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
    };
}
4
Hassan Tareq

Я знаю, я опоздал, но позвольте мне попытаться упростить это. 

Допустим, есть функция 

    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, используя свойство proto во всех браузерах, а в IE мы можем использовать Object.getPrototypeOf (a) или Object.getPrototypeOf (b).

Теперь Foo.prototype, a. proto и b. proto все обозначают один и тот же объект. 

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

все вышеперечисленное вернет true. 

Как известно, в 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 в списке свойств. Если он не найден, он поднимется в proto chain of. Поскольку a. proto и Foo.prototype - это один и тот же объект, JavaScript найдет метод Greet () и выполнит его. 

Надеюсь, теперь prototype и protoнемного упрощены. 

3
debugmode

Prototype или Object.prototype - это свойство литерала объекта. Он представляет собой объект-прототип Object, который можно переопределить, чтобы добавить дополнительные свойства или методы дальше по цепочке прототипов. 

_PROTO_ - это свойство метода доступа (функция get и 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

3
akodevs

Резюме:

Свойство __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 функции также являются объектами. Объекты могут иметь свойства, а свойство по умолчанию для любой функции - это одно свойство с именем prototype.

Затем, когда эта функция используется в качестве функции-конструктора, объект, созданный из нее, получит свойство с именем __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);

2
Willem van der Veen

ОПРЕДЕЛЕНИЯ

(число внутри круглых скобок () является «ссылкой» на код, который написан ниже)

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;
2
Eduard

Каждая созданная вами функция имеет свойство с именем 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__

Я надеюсь, что это имеет смысл.

1
Malkeet Singh

Пояснительный пример: 

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

1
Nitin Jadhav

Я попробую объяснение 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
1
vladCovaliov

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

1
Jyoti Duhan

  JavaScript prototype vs __prototype__

'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 конструктора, Тогда конструктор будет вызываться новым объектом, В этом Процесс «this» будет ссылкой на новый объект в области конструктора, и, наконец, вернет новый объект.

Прототип конструктора - это свойство __proto__, свойство конструктора prototype работает с оператором new.

Конструктор должен быть функцией, но функция не всегда является конструктором, даже если она имеет свойство prototype.

Цепочка прототипов фактически является свойством объекта __proto__ для ссылки на его прототип, И свойством прототипа __proto__ для ссылки на прототип прототипа и т.д., .__, пока не будет ссылаться на свойство __proto__ прототипа объекта, которое ссылается на нуль.

Например:

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 объекта, чтобы получить прототип чего-либо.

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

Любая написанная нами функция может использоваться для создания объекта с оператором new, , Поэтому любая из этих функций может быть конструктором.

1
林奕忠

Как насчет использования __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
0
Barrard

(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) 
    })()

Попробуйте этот код, чтобы понять

0
Timur