Этот рисунок снова показывает, что у каждого объекта есть прототип. Функция-конструктор 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__
отличается отconstructor.prototype
?Ответы:
__proto__
фактический объект, который используется в цепочке поиска для разрешения методов и т. д.prototype
- это объект, который используется для построения__proto__
при создании объекта с помощьюnew
:источник
prototype
недоступно для самих экземпляров (или других объектов), но только для функций конструктора.prototype
доступен только на функциях , так как они получены изFunction
,Function
и ,Object
но ни в чем другом это не так . Однако__proto__
доступен везде.__proto__
же самое относится и к реальному объекту, который сохраняется и используется в качестве прототипа, в то время какMyconstructure.prototype
это просто чертеж, для__proto__
которого он влияет на фактический объект, сохраненный и используемый в качестве прототипа. Следовательно,myobject.prototype
не может быть свойством реального объекта, потому что это просто временная вещь, используемая функцией конструктора для описания того, какmyobject.__proto__
должен выглядеть.__proto__
свойство объекта является указателем наprototype
свойство функции конструктора объекта? то есть foo .__ proto__ === foo.constructor.prototypenewCar.__proto__
ЭтоCar.prototype
не примерCar.prototype
. В то время какCar.protoype
IS экземплярobject
.Car.prototype
это не то , что даетnewCar
какие - либо свойства или структуру, он просто IS следующегоobject
В менюnewCar
«сек прототип цепи.Car.prototype
не временныйobject
. Это - то,object
что установлено как значение__proto__
свойства любых новыхobject
s, сделанных с использованиемCar
в качествеconstructor
. Если вы хотите думать о чем-либо как о проектеobject
, подумайте оCar
проекте для новых автомобилейobject
.prototype
является свойством объекта Function. Это прототип объектов, созданных этой функцией.__proto__
является внутренним свойством объекта, указывающим на его прототип. Существующие стандарты предоставляют эквивалентныйObject.getPrototypeOf(O)
метод, хотя де-факто стандарт__proto__
быстрее.Вы можете найти
instanceof
отношения, сравнивая функцииprototype
с__proto__
цепочкой объектов , и вы можете разорвать эти отношения, изменив ихprototype
.Вот
Point
функция конструктора, она строит объект (структуру данных) процедурно.myPoint
это объект, созданныйPoint()
таким образом, чтобы бытьPoint.prototype
сохраненнымmyPoint.__proto__
в это время.источник
__proto__
свойство объекта, он изменяет объект, для которого выполняются поиски прототипа. Например, вы можете добавить объект методов в качестве функции,__proto__
чтобы иметь своего рода вызываемый объект экземпляра.console.log(obj1.call) // [Function: call]
obj1.call()
// TypeError: obj1.call не является функцией. Я сделалobj.__proto__ = Function.__proto__
myFn.__proto__ = {foo: 'bar'}
Свойство прототипа создается при объявлении функции.
Например:
Person.prototype
свойство создается внутри, как только вы объявляете вышеуказанную функцию. Многие свойства могут быть добавлены в Person.prototype, которые совместно используются экземплярами Person, созданными с использованием new Person ().Стоит отметить, что по умолчанию
Person.prototype
этоObject
литерал (его можно изменить при необходимости).Каждый экземпляр, созданный с использованием,
new Person()
имеет__proto__
свойство, которое указывает наPerson.prototype
. Эта цепочка используется для поиска свойства определенного объекта.создает 2 экземпляра
Person
, эти 2 объекта можно назватьage
метод ,Person.prototype
какperson1.age
,person2.age
.На приведенном выше рисунке из вашего вопроса вы можете видеть, что
Foo
это a,Function Object
и поэтому у него есть__proto__
ссылка на тот,Function.prototype
который в свою очередь является экземпляромObject
и имеет__proto__
ссылку наObject.prototype
. Проты тяги здесь с__proto__
вObject.prototype
указывающем наnull
.Любой объект может иметь доступ ко всем свойствам в своей цепочке прототипов, которые связаны между собой
__proto__
, тем самым формируя основу для наследования прототипов.__proto__
это не стандартный способ доступа к цепочке прототипов, а стандартный, но схожий подходObject.getPrototypeOf(obj)
.Ниже код для
instanceof
оператора дает лучшее понимание:instanceof
Оператор класса объекта возвращается,true
когда объект является экземпляром класса, более конкретно, если онClass.prototype
находится в цепочке протоколов этого объекта, тогда объект является экземпляром этого класса.Вышеуказанный метод может быть вызван как:
instanceOf.call(object, Class)
который возвращает истину, если объект является экземпляром класса.источник
prototype
объект был создан внутренне в первую очередь? Можно ли просто назначить статические методы самому объекту функции. напримерfunction f(a){this.a = a}; f.increment = function(){return ++this.a}
? Почему этот способ не был выбран вместо добавления методов кprototype
объекту? Это будет работать, еслиf.__proto__ = g
где g - базовый класс.prototype
объект был выбран для совместного использования, потому что только исключительные свойства конструктора функции могут быть сохранены в объекте конструктора функции.instanceof
это привело({}) instanceof Function === true
бы к невозможности провести различие между прототипами, еслиprototype
свойство будет удалено.new
ключевое слово для создания экземпляра, свойства и методы не были бы скопированы над.Хороший способ думать об этом ...
prototype
используетсяconstructor()
функциями. Это должно было действительно называться как-то"prototypeToInstall"
, так как это то, что есть.и
__proto__
является ли этот «установленный прототип» на объекте (который был создан / установлен на объекте из указаннойconstructor()
функции)источник
constructor()
функции» на «функции конструктора», так как это может привести к путанице с «__proto__.constructor()
функциями». Я считаю это важным, поскольку __proto __. Конструктор фактически не вызывается, когда используетсяnew
ключевое слово.Чтобы объяснить, давайте создадим функцию
Когда JavaScript выполняет этот код, он добавляет
prototype
свойствоa
,prototype
свойство - это объект с двумя свойствами:constructor
__proto__
Итак, когда мы делаем
a.prototype
это возвращаетсяТеперь, как вы можете видеть,
constructor
это не что иное, какa
сама функция ,__proto__
указывающая на корневой уровеньObject
JavaScript.Давайте посмотрим, что происходит, когда мы используем
a
функцию сnew
ключевым словом.Когда JavaScript выполняет этот код, он выполняет 4 вещи:
__proto__
наb
и делает это указывает наa.prototype
Sob.__proto__ === a.prototype
a.prototype.constructor
(что является определением функцииa
) с вновь созданным объектом (созданным на шаге 1) в качестве его контекста (this), поэтомуname
свойство, переданное как «JavaScript» (которое добавляетсяthis
), добавляется к вновь созданному объекту.b
присваивается вновь созданному объекту.Теперь, если мы добавим
a.prototype.car = "BMW"
и сделаемb.car
, появится вывод «BMW».это потому, что когда JavaScript выполнял этот код, он искал
car
свойство onb
, он не находил используемый тогда JavaScriptb.__proto__
(который был создан для указания на «a.prototype» на шаге # 2) и находилcar
свойство, поэтому возвращал «BMW».источник
constructor
не возвращаетсяa()
! Это возвращаетсяa
. 2.__proto__
возвращаетObject.prototype
, а не корневой объект в Javascript.Прототип VS. __proto__ VS. [[Прототип]]
При создании функции объект свойства с именем prototype создается автоматически (вы сами его не создавали) и присоединяется к объекту функции (the
constructor
).Примечание . Этот новый объект- прототип также указывает или имеет внутренне-частную ссылку на собственный объект JavaScript.
Пример:
Если вы создаете новый объект,
Foo
используяnew
ключевое слово, вы в основном создаете (среди прочего) новый объект, который имеет внутреннюю или личную ссылку наFoo
прототип функции, который мы обсуждали ранее:Частная связь с объектом этой функции назвала двойные скобки прототипа или просто
[[Prototype]]
. Многие браузеры предоставляют нам общедоступную ссылку, которая называется__proto__
!Чтобы быть более конкретным,
__proto__
на самом деле это функция получения , принадлежащая нативному объекту JavaScript. Он возвращает внутренне-частную связь прототипа любойthis
привязки (возвращает[[Prototype]]
ofb
):Стоит отметить, что для начала
ECMAScript5
вы также можете использовать метод getPrototypeOf для получения внутренней частной связи:Примечание: этот ответ не намерен охватить весь процесс создания новых объектов или новые конструкторов, но , чтобы лучше понять , что такое
__proto__
,prototype
и[[Prototype]]
и как она работает.источник
Чтобы сделать это немного яснее в дополнение к вышеупомянутым отличным ответам:
Экземпляры имеют __proto__ , классы имеют прототип .
источник
В JavaScript функция может использоваться как конструктор. Это означает, что мы можем создавать объекты из них, используя ключевое слово new. Каждая функция конструктора поставляется со встроенным объектом, связанным с ними. Этот встроенный объект называется прототипом.
Instances of a constructor function use __proto__ to access the prototype property of its constructor function.
Сначала мы создали конструктор:
function Foo(){}
. Чтобы быть понятным, Foo это просто еще одна функция. Но мы можем создать объект из него с новым ключевым словом. Вот почему мы называем это функцией конструктораКаждая функция имеет уникальное свойство, которое называется свойством прототипа. Итак, функция Constructor
Foo
имеет свойство prototype, которое указывает на его прототипFoo.prototype
(см. Изображение).Функции-конструкторы сами являются функцией, которая является экземпляром системного конструктора, называемого конструктором [[Function]]. Таким образом, мы можем сказать, что
function Foo
он построен конструктором [[Function]]. Итак,__proto__
о нашемFoo function
укажем на прототип его конструктора, который естьFunction.prototype
.Function.prototype
сам по себе является ничем иным, как объектом, который создается из другого системного конструктора с именем[[Object]]
. Итак,[[Object]]
это конструкторFunction.prototype
. Таким образом, мы можем сказатьFunction.prototype
, это пример[[Object]]
. Поэтому__proto__
изFunction.prototype
пунктов вObject.prototype
.Object.prototype
последний человек, стоящий в цепи прототипов. Я имею в виду, что это не было построено. Это уже есть в системе. Так что это__proto__
указывает наnull
.Теперь мы подошли к случаям
Foo
. Когда мы создаем экземпляр с помощьюnew Foo()
, он создает новый объект, который является экземпляромFoo
. Это означаетFoo
, что конструктор этих экземпляров. Здесь мы создали два экземпляра (x и y).__proto__
х и у, таким образом, указывает наFoo.prototype
.источник
Резюме:
__proto__
Свойство объекта является свойством , которое отображает вprototype
функции конструктора объекта. Другими словами:instance.__proto__ === constructor.prototype // true
Это используется для формирования
prototype
цепочки объекта.prototype
Цепь представляет собой механизм поиска свойств на объекте. При обращении к свойству объекта JavaScript сначала будет смотреть на сам объект. Если свойство там не найдено, оно будет подниматься доprotochain
тех пор, пока не будет найдено (или нет)Пример:
Наш первый журнал приводит к тому
true
, что, как уже упоминалось,__proto__
свойство экземпляра, созданного конструктором, ссылается наprototype
свойство конструктора. Помните, что в JavaScript функции также являются объектами. Объекты могут иметь свойства, а свойство по умолчанию любой функции - это одно свойство с именем prototype.Затем, когда эта функция используется в качестве функции-конструктора, объект, созданный из нее, получит свойство с именем
__proto__
. И это__proto__
свойство относится кprototype
свойству функции конструктора (которая по умолчанию есть в каждой функции).Почему это полезно?
JavaScript имеет механизм поиска свойств,
Objects
который называется «наследование прототипа» , вот что он делает в основном:__proto__
свойство. Там он проверяет, доступно ли свойство для объекта, на который ссылается__proto__
.__proto__
объекте, оно будет подниматься вверх по__proto__
цепочке вплоть доObject
объекта.prototype
цепочки, он вернетсяundefined
.Например:
источник
Мне довелось изучать прототип из You Not Know JS: this & Object Prototypes , который является замечательной книгой, чтобы понять дизайн и объяснить множество заблуждений (вот почему я стараюсь избегать использования наследования и тому подобное
instanceof
).Но у меня тот же вопрос, что и здесь. Несколько ответов действительно полезны и поучительны. Я также хотел бы поделиться своим пониманием.
Что такое прототип?
У объектов в JavaScript есть внутреннее свойство, обозначенное в спецификации как
[[Prototype]]
, которое является просто ссылкой на другой объект. Почти всем объектам присваиваетсяnull
значение для этого свойства во время их создания.Как получить прототип объекта?
через
__proto__
илиObject.getPrototypeOf
Что это
prototype
?prototype
является объектом, автоматически создаваемым как специальное свойство функции , которое используется для создания цепочки делегирования (наследования), то есть цепочки прототипов.Когда мы создаем функцию
a
,prototype
она автоматически создается как специальное свойство ona
и сохраняет код функции какconstructor
onprototype
.Я хотел бы рассмотреть это свойство как место для хранения свойств (включая методы) функционального объекта. Это также причина , почему функция полезности в JS определяется как
Array.prototype.forEach()
,Function.prototype.bind()
,Object.prototype.toString().
Зачем подчеркивать свойство функции ?
Так
Arary
,Function
,Object
все функции. Я должен признать, что это освежает мое впечатление о JS. Я знаю, что функции - это первоклассный гражданин в JS, но кажется, что он построен на функциях.Какая разница между
__proto__
аprototype
?__proto__
ссылка работает на каждый объект, чтобы ссылаться на его[[Prototype]]
свойство.prototype
является объектом, автоматически создаваемым как специальное свойство функции , которое используется для хранения свойств (включая методы) объекта функции.С этими двумя мы могли мысленно наметить цепочку прототипов. Как эта картина иллюстрирует:
источник
В JavaScript каждый объект (функция тоже является объектом!) Имеет
__proto__
свойство, свойство является ссылкой на его прототип.Когда мы используем
new
оператор с конструктором для создания нового объекта,__proto__
свойство нового объекта будет установлено соprototype
свойством конструктора , тогда конструктор будет вызывать новый объект, в этом процессе «this» будет ссылкой на новый объект в области конструктора, наконец, верните новый объект.Прототип конструктора - это
__proto__
свойство, свойство конструктораprototype
- работа сnew
оператором.Конструктор должен быть функцией, но функция не всегда является конструктором, даже если она имеет
prototype
свойство.Цепочка прототипа фактически является
__proto__
свойством объекта для ссылки на его прототип, а__proto__
свойство прототипа для ссылки на прототип прототипа и т. Д. До тех пор, пока не будет ссылки на__proto__
свойство прототипа объекта, которое ссылается на null.Например:
[[Prototype]]
и__proto__
собственность на самом деле это то же самое.Мы можем использовать метод getPrototypeOf объекта, чтобы получить прототип чего-либо.
Любая написанная нами функция может быть использована для создания объекта с
new
оператором, поэтому любая из этих функций может быть конструктором.источник
Еще один хороший способ понять это:
Только после того, как IE11
__proto__
поддерживается. До этой версии, такой как IE9, вы могли использоватьconstructor
для получения__proto__
.источник
прототип
Прототип является свойством функции. Это план создания объектов с использованием этой функции (конструктора) с ключевым словом new.
__proto__
используется в цепочке поиска для разрешения методов, свойств. при создании объекта (с использованием функции конструктора с новым ключевым словом)__proto__
устанавливается значение (конструктор) Function.prototypeВот мое (воображаемое) объяснение, чтобы убрать путаницу:
Представьте себе, что существует некий воображаемый класс (планер / резак), связанный с функцией. Этот воображаемый класс используется для создания объектов.
prototype
это механизм расширения (метод расширения в C # или Swift Extension) для добавления вещей в этот воображаемый класс.Вышеизложенное можно представить как:
Так,
Теперь добавляем метод для
prototype
робота:Вышеизложенное можно представить как расширение класса Robot:
Которые в свою очередь,
источник
__proto__
и прототипах. может быть прототип и наследство?prototype
и того и__proto__
другого следует избегать. У нас сейчас класс, и мне нравится ООП.Проще говоря:
Это позволяет вам присоединять свойства к X.prototype. Объекты AFTER типа X были созданы, и они по-прежнему будут получать доступ к этим новым свойствам через ссылку __proto__, которую Javascript-движок использует для прохождения по цепочке прототипов.
источник
Prototype или Object.prototype - это свойство литерала объекта. Он представляет объект- прототип Object, который вы можете переопределить, чтобы добавить дополнительные свойства или методы дальше по цепочке прототипов.
__proto__ - это свойство метода доступа (функция get и set), предоставляющее внутренний прототип объекта, к которому осуществляется доступ.
Ссылки:
http://www.w3schools.com/js/js_object_prototypes.asp
https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/proto
источник
Object.prototype
не является свойством литерала объекта, попытка распечатать{}.prototype
возвращает undefined; однако, это может быть получено через{}.__proto__
, который возвращаетObject.prototype
.Я знаю, я опоздал, но позвольте мне попытаться упростить это.
Допустим, есть функция
Функция Foo будет связана с объектом-прототипом. Поэтому всякий раз, когда мы создаем функцию в JavaScript, с ней всегда связан объект-прототип.
Теперь давайте продолжим и создадим два объекта, используя функцию Foo.
Теперь, Foo.prototype, a. прото и б. Прото все обозначает один и тот же объект.
все вышеперечисленное вернет истину.
Как известно, в JavaScript свойства могут добавляться динамически. Мы можем добавить свойство к объекту
Как вы видите, мы добавили метод Greet () в Foo.prototype, но он доступен в a и b или любом другом объекте, который построен с использованием Foo.
При выполнении a.Greet () JavaScript сначала будет искать Greet в объекте a в списке свойств. Не найдя, он перейдет в прото- цепочку. Так как Прото и Foo.prototype это один и тот же объект, JavaScript найдет метод Greet () и выполнит его.
Надеюсь, теперь прототип и прото немного упрощены.
источник
Пояснительный пример:
Теперь у myPupppie есть
__proto__
свойство, которое указывает на Dog.prototype.но myPuppie НЕ имеет свойства прототипа.
Таким образом,
__proto__
mypuppie является ссылкой на свойство .prototype функции конструктора, которая использовалась для создания экземпляра этого объекта (а текущий объект myPuppie имеет отношение «делегаты» к этому__proto__
объекту), в то время как свойство .prototype в myPuppie просто отсутствует (поскольку мы его не ставили).Хорошее объяснение MPJ здесь: proto против prototype - создание объектов в JavaScript
источник
Я сделал для себя небольшой рисунок, представляющий следующий фрагмент кода:
У меня есть классическое OO, поэтому было полезно представить иерархию таким образом. Чтобы помочь вам прочитать эту схему, рассматривайте прямоугольники на изображении как объекты JavaScript. И да, функции также являются объектами. ;)
Объекты в JavaScript имеют свойства и
__proto__
являются лишь одним из них.Идея этого свойства состоит в том, чтобы указывать на объект-предок в иерархии (наследования).
Корневой объект в JavaScript есть,
Object.prototype
а все остальные объекты являются его потомками.__proto__
Свойство корневого объектаnull
, который представляет собой конец наследования цепи.Вы заметите, что
prototype
это свойство функций.Cat
является функцией, но такжеFunction
иObject
являются (родными) функциями.tom
не является функцией, поэтому у него нет этого свойства.Идея этого свойства состоит в том, чтобы указать на объект, который будет использоваться в конструкции, т.е. когда вы вызываете
new
оператор для этой функции.Действительно, когда мы создаем
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
.Ура!
источник
tom.__proto__
иCat.prototype
строго равны, так что,tom.__proto__ === Cat.prototype
иCat.prototype === tom.__proto__
это правда. Итак, что вы имели в виду под стрелкой на изображении ??prototype
как и свойствоCat
объекта (из вашего вопроса).ОПРЕДЕЛЕНИЯ
(число внутри круглых скобок () является «ссылкой» на код, который написан ниже)
prototype
- объект, который состоит из:=> функций (3) этого конкретного
ConstructorFunction.prototype
(5), которые доступны каждому объекту (4), созданному или созданному с помощью этой функции конструктора (1)=> самой функции конструктора (1) )
=>
__proto__
этого конкретного объекта (прототип объекта)__proto__
(dandor proto?) - ссылка между любым объектом (2), созданным с помощью определенной функции-конструктора (1), И свойствами (5) объекта-прототипа этого конструктора, что позволяет каждому созданному объекту (2) иметь доступ к функциям прототипа и методы (4) (__proto__
по умолчанию включены в каждый объект в JS)РАЗЪЯСНЕНИЕ КОДА
1.
2.
3.
4.
5.
источник
Я попробую объяснение 4-го класса:
Все очень просто. А
prototype
является примером того, как что-то должно быть построено. Так:Я
function
и я строю новые объекты, похожие на моиprototype
Я
object
и я был построен, используя мой__proto__
в качестве примерадоказательство :
источник
prototype
ни в__proto__
любое время не используются в качестве проекта или около того, чтобы создать какой-либо объект. Это миф, представленный размытымclass
синтаксисом и его предшественниками. Как говорится в посте с ответом, он используется только для поисковой цепочки и, в случае необходимости,prototype
для идентификацииconstructor
с нимnew
(что является частью того механизма «притворяйся классным», который сбивает с толку многих пользователей, включая меня).Каждая созданная вами функция имеет свойство с именем
prototype
, и она начинает свою жизнь как пустой объект. Это свойство бесполезно, пока вы не используете эту функцию в качестве функции конструктора, то есть с ключевым словом «new».Это часто путают со
__proto__
свойством объекта. Некоторые могут запутаться и, за исключением того, чтоprototype
свойство объекта может сделать их прототипом объекта. Но это не так.prototype
используется для получения__proto__
объекта, созданного из конструктора функции.В приведенном выше примере:
Я надеюсь, что это имеет смысл.
источник
prototype
не используется для создания__proto__
объекта.__proto__
при доступе просто предоставляет ссылку наprototype
объект.Как насчет использования
__proto__
для статических методов?источник
__proto__
VS.prototype
в JavaScript» ?Попробуйте этот код, чтобы понять
источник
Существует только один объект, который используется для создания прототипа. Этот объект, очевидно, имеет имя и значение:
__proto__
это его имя иprototype
его значение. Это все.чтобы было еще проще понять, посмотрите на диаграмму в верхней части этого поста (Диаграмма Дмитрия Сошникова), вы никогда не найдете
__proto__
точек на что-то другое, кромеprototype
как в качестве его значения.Суть заключается в следующем:
__proto__
это имя, которое ссылается на объект-прототип, иprototype
является фактическим объектом-прототипом.Это как сказать:
x
это имя объекта (указатель) и{name: 'john'}
фактический объект (значение данных).ПРИМЕЧАНИЕ: это просто упрощенный намек на то, как они связаны на высоком уровне.
Обновление: вот простой конкретный пример javascript для лучшей иллюстрации:
Это означает , что , когда
Object.getPrototypeOf(x)
получает нас фактическое значениеx
(которое является его прототипом), является именно то , что__proto__
изx
указывает на. Поэтому__proto__
действительно указывает на прототипx
. Таким образом,__proto__
ссылкиx
(указательx
) иprototype
является значениемx
(его прототип).Надеюсь, теперь это немного понятно.
источник
Это очень важный вопрос для любого, кто хочет понять прототип наследования. Из того, что я понимаю, прототип назначается по умолчанию, когда объект создается с новым из функции, потому что функция имеет объект-прототип по определению:
Когда мы создаем обычный объект без нового, то есть явно из функции, у него нет прототипа, но у него есть пустой прототип, которому можно назначить прототип.
Мы можем использовать Object.create, чтобы явно связать объект.
источник
__proto__
является основой для конструированияprototype
и функцией конструктора, например:function human(){}
has,prototype
которая используется совместно__proto__
в новом экземпляре функции конструктора. Более подробно читайте здесьисточник
Как это правильно сказано
Далее мы можем заметить, что
__proto__
свойство объекта, созданного с помощью конструктора функции, указывает на область памяти, на которую указывает свойство prototype этого соответствующего конструктора.Если мы изменим расположение в памяти прототипа функции конструктора,
__proto__
производный объект все равно будет продолжать указывать на исходное адресное пространство. Поэтому, чтобы сделать общее свойство доступным по цепочке наследования, всегда добавляйте свойство к прототипу функции конструктора , а не повторно инициализируйте его (что изменит его адрес памяти).Рассмотрим следующий пример:
источник
Насколько я понимаю, __proto__ и прототип все служат для цепочки прототипов. разница в том, что функции с именами подчеркивания (например, __proto__) вообще не предназначены для разработчиков, вызываемых явно. другими словами, они просто для некоторых механизмов, таких как наследование и т. д., они являются «бэк-эндами». но функции, названные без подчеркивания, предназначены для вызова в явном виде, они 'front-end'.
источник
__proto__
иprototype
, чем просто именование. Они могут указывать или не указывать на один и тот же объект. Смотрите ответ @zyklus.!!! Это лучшее объяснение в мире !!!!!
в конструкторах функций Javascript Engine вызывает это
q.__proto__ = prototype
автоматически, когда мы пишемnew Class
, и в__proto__
наборе опорClass.prototype
Наслаждаться %)
источник