Почему объекты не имеют значения прототипа, которые относятся к Object.prototype [duplicate]

Мое понимание: __proto__ и прототип служат для прототипа. разница заключается в том, что функции с индексом underscore (например, __proto__) не предназначены для разработчиков, явно вызываемых явно. другими словами, они предназначены только для некоторых механизмов, таких как наследование и т. д., они являются «back-end». но функции, названные без подчеркивания, предназначены для вызывания явно, они являются «front-end».

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

Скажем, существует функция

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

Надеюсь, теперь прототип и прото упрощаются.

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

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

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

ОПРЕДЕЛЕНИЯ

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

prototype - объект, который состоит из: => функции (3) этого конкретного ConstructorFunction.prototype (5), которые доступны каждому объекту (4), созданному или создаваемому через эту конструкторскую функцию (1) => сама конструкторская функция (1) => __proto__ этого объекта (объект-прототип)

__proto__ (dandor proto?) - ссылка МЕЖДУ любым объектом (2), созданным через конкретную конструкторскую функцию (1), и свойства объекта прототипа (5) этого конструктора THAT позволяет каждому созданному объекту (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;

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

__ proto __

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

Я, случается, изучаю прототип из You Do not Know JS: this & amp; Object Prototypes , который является замечательной книгой, чтобы понять дизайн под ним и прояснить так много заблуждений (поэтому я стараюсь избегать использования наследования и таких вещей, как instanceof).

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

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

Объекты в JavaScript имеют внутреннее свойство, обозначенное в спецификации как [[Prototype]], которое является просто ссылкой на другой объект.

Как получить прототип объекта?

через __proto__ или

для этого свойства во время их создания.

f9]

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

So , Arary, Function, Object - все функции. Я должен признать, что это улучшает мое впечатление на JS. Я знаю, что функции являются первоклассными гражданами в JS, но кажется, что он построен на функциях.

В чем разница между __proto__ и prototype?

__proto__ a ссылка ссылается на каждый объект, чтобы ссылаться на его свойство [[Prototype]].

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

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

[/g5]

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

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

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

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

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

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

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

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

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

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

!!! ЭТО ЛУЧШЕЕ ОБЪЯСНЕНИЕ В МИРЕ !!!!!

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

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

в конструкторах функций javascript engine вызывает это q.__proto__ = prototype автоматически, когда мы пишем new Class, а в __proto__ prop set 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

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

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

Например:

 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 литералом по умолчанию ( он может быть изменен по мере необходимости).

Каждый экземпляр, созданный с использованием нового Person (), имеет свойство __proto__, которое указывает на Person.prototype. Это цепочка, которая используется для перемещения, чтобы найти свойство определенного объекта.

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

создает 2 экземпляра Person, эти 2 объекта могут вызывать возрастное свойство Person.prototype как person1.age, person2.age.

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

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

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

Ниже код для instanceof дает лучшее понимание:

object 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, если объект является экземпляром класса.

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

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

и __proto__ - это то, что «установленный прототип» на объекте (который был создан / установлен на объекте из constructor())