Каждый объект в JavaScript имеет встроенный прототип свойств. Объяснение свойства прототипа объекта в JavaScript: вернуть ссылку на прототип типа объекта. Это означает, что атрибут прототипа содержит ссылку на другой объект JavaScript, который действует как родитель текущего объекта.
Кода -копия выглядит следующим образом:
A.Prototype = new B ();
Понимание прототипа не следует путать с наследством. Прототип А является экземпляром Б. Можно понять, что клонирует все методы и свойства в B. A может использовать методы и свойства B. Что здесь подчеркивается, так это клонирование, а не наследство. Это может произойти: прототип A является экземпляром B, а прототип B также является экземпляром A.
Продолжайте смотреть на следующий анализ:
Частные переменные и функции
Если переменные и функции, определенные внутри функции, не предоставляются извне, к ним нельзя получить извне, то есть частные переменные и функции функции.
Кода -копия выглядит следующим образом:
<script type = "text/javascript">
Функция Box () {
var color = "blue"; // частная переменная
var fn = function () // частная функция
{
}
}
</script>
Таким образом, переменные цвета и FN не могут быть доступны за пределами функционального объекта, и они становятся частными:
Кода -копия выглядит следующим образом:
var obj = new Box ();
Alert (obj.color); // Неопределенное всплывающее окно
Alert (obj.fn); // То же, что и выше
Статические переменные и функции
Когда функция определена, добавленные к ней атрибуты и функции все еще доступны через сам объект, но их примеры не могут быть доступны. Такие переменные и функции называются статическими переменными и статическими функциями соответственно.
Кода -копия выглядит следующим образом:
<script type = "text/javascript">
функция obj () {};
Obj.num = 72; // Статическая переменная
Obj.fn = function () // Статическая функция
{
}
оповещение (obj.num); // 72
Alert (typeof obj.fn) // Функция
var t = new obj ();
Alert (t.name); // не определен
Alert (typeof t.fn); // не определен
</script>
Переменные экземпляра и функции
В объектно-ориентированном программировании, в дополнение к некоторым библиотечным функциям, мы все еще надеемся определить некоторые свойства и методы одновременно в определении объекта, чтобы получить доступ к ним после экземпляра, и JS также может сделать это.
Кода -копия выглядит следующим образом:
<script type = "text/javascript">
Функция Box () {
this.a = []; // переменная экземпляра
this.fn = function () {// Метод экземпляра
}
}
console.log (typeof box.a); //неопределенный
console.log (typeof box.fn); //неопределенный
var box = new Box ();
console.log (typeof box.a); //объект
console.log (typeof box.fn); // функция
</script>
Добавить новые методы и свойства к переменным экземпляра и методов
Кода -копия выглядит следующим образом:
<script type = "text/javascript">
Функция Box () {
this.a = []; // переменная экземпляра
this.fn = function () {// Метод экземпляра
}
}
var box1 = new Box ();
box1.a.push (1);
box1.fn = {};
console.log (box1.a); // [1]
console.log (typeof box1.fn); //объект
var box2 = new Box ();
console.log (box2.a); // []
console.log (typeof box2.fn); // функция
</script>
A и FN были изменены в Box1, но не в Box2. Поскольку массивы и функции являются объектами и являются эталонными типами, это означает, что, хотя свойства и методы в Box1 такие же, как в Box2, они не являются ссылкой, а копией свойств и методов, определенных объектом Box.
У этого нет проблем со свойствами, но это большая проблема для методов, потому что методы выполняют одинаковую функцию, но есть две копии. Если объект функции имеет тысячи и методы экземпляра, то каждый его экземпляр должен поддерживать копию тысяч методов. Это, очевидно, ненаучно. Что я могу сделать? Прототип возник.
Основные понятия
Каждая функция, которую мы создаем, имеет свойство прототипа, которое является указателем на объект, и его цель состоит в том, чтобы содержать свойства и методы, которые могут быть переданы всеми экземплярами определенного типа. Затем прототип является прототипом объекта экземпляра объекта, созданного путем вызова конструктора.
Преимущество использования прототипа заключается в том, что он позволяет экземпляру объекта делиться свойствами и методами, которые он содержит. То есть вместо добавления информации объекта определения в конструктор вы можете напрямую добавить эту информацию в прототип. Основная проблема с использованием конструкторов заключается в том, что каждый метод должен быть создан один раз в каждом случае.
В JavaScript существует два типа значений, исходные значения и значения объектов. Каждый объект имеет внутренний прототип свойств, который мы обычно называем прототипом. Значение прототипа может быть объектом или нулем. Если его значение является объектом, объект также должен иметь свой собственный прототип. Это образует линейную цепь, которую мы называем цепочкой прототипа.
значение
Функции могут использоваться в качестве конструкторов. Кроме того, только функция имеет атрибут прототипа и может быть доступен, но экземпляр объекта не имеет этого атрибута, существует только внутренний недоступный атрибут __proto__. __proto__ - это таинственная связь в объекте с соответствующим прототипом. Согласно стандарту, __proto__ не раскрывается общественности, что означает, что это частная собственность, но двигатель Firefox обнажил его и стал общей собственностью, к которой мы можем получить доступ и установить.
Кода -копия выглядит следующим образом:
<script type = "text/javascript">
var browser = function () {};
Browser.prototype.run = function () {
оповещение («Я геккоре, ядро Firefox»);
}
var bro = new Browser ();
Bro.run ();
</script>
Когда мы называем метод Bro.run (), поскольку в Bro нет такого метода, он будет искать его в своем __proto__, то есть Browser.prototype, поэтому метод run () наконец выполняется. (Здесь капитализированная буква функции представляет конструктор для различения обычных функций)
При вызове конструктора для создания экземпляра экземпляр будет содержать внутренний указатель (__proto__), указывающий на прототип конструктора. Это соединение существует между экземпляром и прототипом конструктора, а не между экземпляром и конструктором.
Кода -копия выглядит следующим образом:
<script type = "text/javascript">
Функция Person (имя) {// Функция конструктора
this.name = name;
}
Person.prototype.printname = function () // Прототип объект
{
оповещение (this.name);
}
var person1 = new Person ('byron'); // создание объекта
Console.log (Person1 .__ Proto __); // человек
console.log (person1.constructor); // Попробуйте сами, чтобы увидеть, что это будет
console.log (person.prototype); // указывать на объект прототипа
var person2 = новый человек ('frank');
</script>
Человек Человека 1 содержит атрибут имени, и он автоматически генерирует атрибут __proto__, который указывает на прототип человека, и вы можете получить доступ к методу PrintName, определяемому в прототипе, который, вероятно, похож на это:
Каждая функция JavaScript имеет атрибут прототипа, который относится к объекту, который является объектом прототипа. Прототип объект пуст при инициализации. Мы можем настроить любые свойства и методы в нем. Эти методы и свойства будут унаследованы объектами, создаваемыми конструктором.
Итак, теперь проблема в том. Какова связь между конструктором, экземпляром и объектом прототипа?
Разница между конструкторами, экземплярами и объектами прототипа
Экземпляр создается через конструктор. Как только экземпляр создается, он имеет атрибут конструктора (указывая на функцию конструктора) и атрибут __proto__ (указывая на объект прототипа).
В конструкторе есть свойство прототипа, которое является указателем на его объект прототипа.
Существует также указатель (свойство конструктора) внутри объекта прототипа, указывающего на конструктор: person.prototype.constructor = person;
Экземпляры могут получить доступ к свойствам и методам, определенным на объекте прототипа.
Здесь Person1 и Person2 являются случаями, а прототип - их прототипные объекты.
Еще один каштан:
Кода -копия выглядит следующим образом:
<script type = "text/javascript">
Функция животного (имя) // Накапливание конструктора
{
this.name = name; // установить свойства объекта
}
Animal.prototype.behavior = function () // Добавить метод поведения к прототипу базового конструктора класса
{
оповещение ("это"+this.name);
}
var dog = новое животное ("собака"); // Создать объект собаки
var cat = new Animal ("cat"); // Создать объект Cat
Dog.behavior (); // Вызовите метод поведения непосредственно через объект собаки
Cat.behavior (); // Вывод "Это кошка"
Alert (dog.behavior == cat.behavior); // вывод true;
</script>
Из результатов программы можно увидеть, что методы, определенные на прототипе конструктора, действительно могут быть вызваны непосредственно через объект, и код обменивается. (Вы можете попытаться удалить свойство прототипа в животном.
Экземпляр объекта массива
Давайте посмотрим на экземпляр объекта массива. Когда мы создаем массив объектов, фактическая модель объекта Array1 в двигателе JavaScript выглядит следующим образом:
Кода -копия выглядит следующим образом:
var array1 = [1,2,3];
Объект Array1 имеет значение атрибута длины 3, но мы можем добавить элементы в Array1 по следующему методу:
Кода -копия выглядит следующим образом:
Array1.push (4);
Метод push происходит от метода, который указывает на объект __proto__ членом Array1 (array.prototye.push ()). Это именно потому, что все объекты массива (созданные через []) содержат элемент __proto__, указывающий на один и тот же объект метода с помощью толкания, реверса и т. Д. (Массив.
Экземпляр объекта функции
Кода -копия выглядит следующим образом:
функция base () {
this.id = "base"
}
Кода -копия выглядит следующим образом:
var obj = new Base ();
Каков результат такого кода? Объектная модель, которую мы видим в двигателе JavaScript:
Что именно сделал новый оператор? На самом деле, это было очень просто, просто сделали три вещи.
Кода -копия выглядит следующим образом:
var obj = {};
obj .__ Proto__ = base.prototype;
Base.call (obj);
Прототип цепочка
Цепочка прототипа: когда свойство или метод извлекается из объекта, если сам объект не имеет такого свойства или метода, оно будет искать связанный с прототипом объектом, с которым вы связываете. Если прототип нет, он будет искать предшественника прототипа, связанного с прототипом. Если их больше нет, продолжайте искать объект, на который ссылается прототип.
Кода -копия выглядит следующим образом:
<script type = "text/javascript">
Функция форма () {
this.name = "shape";
this.ToString = function () {
вернуть это. name;
}
}
функция twoShape () {
this.name = "2 shape";
}
Функциональный треугольник (сторона, высота) {
this.name = "треугольник";
this.side = сторона;
this.height = высота;
this.getarea = function () {
вернуть это.side*this.height/2;
}
}
Wooshape.prototype = new Shape ();
Triangle.prototype = new TwoShape ();
</script>
Здесь новая сущность создается с формой конструктора (), а затем используется для перезаписи прототипа объекта.
Кода -копия выглядит следующим образом:
<script type = "text/javascript">
Функция форма () {
this.name = "shape";
this.ToString = function () {
вернуть это. name;
}
}
функция twoShape () {
this.name = "2 shape";
}
Функциональный треугольник (сторона, высота) {
this.name = "треугольник";
this.side = сторона;
this.height = высота;
this.getarea = function () {
вернуть это.side*this.height/2;
}
}
Wooshape.prototype = new Shape ();
Triangle.prototype = new TwoShape ();
Twoshape.prototype.constructor = twoshape;
Triangle.prototype.constructor = Triangle;
var my = новый треугольник (5,10);
my.getarea ();
my.tostring (); // треугольник
my.constructor; // треугольник (сторона, высота)
</script>
Прототип наследование
Прототип наследование: в конце цепочки прототипа это прототип объекта, на который указывает атрибут прототипа конструктора объекта. Этот объект прототипа является предком всех объектов, и этот предок реализовал методы, которые должны были иметь все объекты, такие как ToString. Другие встроенные конструкторы, такие как функция, логическая, строка, дата и регуляция, унаследованы от этого предка, но каждый из них определяет свои собственные атрибуты и методы, так что их потомки показывают характеристики своих соответствующих кланов.
В Ecmascript метод реализации наследования достигается путем полагательства на цепочку прототипа.
Кода -копия выглядит следующим образом:
<script type = "text/javascript">
Функциональный Box () {// Унаследованная функция называется SuperType (родительский класс, базовый класс)
this.name = "jack";
}
Функция Tree () {// Унаследованные функции называются подтипами (подклассы, полученные классы)
this.age = 300;
}
// наследуют через цепочку прототипа, назначить атрибуты прототипа подтипа
// new Box () передаст информацию в конструкции коробки и информацию в прототипе к дереву
Tree.prototype = new Box (); // Tree Forconing Box и образует цепь через прототип.
var tree = новое дерево ();
Alert (tree.name); // popt jack
</script>
Проблема с прототипом цепочкой: хотя цепочка прототипа очень мощная и может использоваться для реализации наследования, у нее также есть некоторые проблемы. Наиболее важная проблема заключается в прототипе значения, содержащем тип эталона. Атрибуты прототипа, содержащие эталонные типы, разделяются всеми экземплярами; Вот почему атрибуты определены в конструкторах, а не в объектах прототипа. Когда наследование достигается с помощью прототипа, прототип фактически становится экземпляром другого типа. Следовательно, исходный атрибут экземпляра становится атрибутом прототипа.
При создании экземпляра подтипа аргумент не может быть передан в конструктор Supertype. На самом деле, следует сказать, что нет способа передать параметры в конструктор Supertype, не влияя на все экземпляры объекта. В дополнение к проблеме, которая только что обсуждалась из -за включения значений эталонного типа в прототипы, на практике редко используется только цепочки прототипа.
Еще один каштан:
Кода -копия выглядит следующим образом:
<script type = "text/javascript">
Функциональный человек (имя)
{
this.name = name; // установить свойства объекта
};
Person.prototype.company = "Microsoft"; // Установить свойства прототипа
Person.prototype.sayhello = function () // Метод прототипа
{
Alert ("Привет, я"+ this.name+ "из"+ this.company);
};
var billgates = новый человек ("billgates"); // Создать объект человека
Billgates.sayhello (); // наследует содержание прототипа и выходов "Привет, я Биллгейт из Microsoft"
var jobs = новый человек ("Jobs");
Jobs.company = "Apple"; // Установите свой собственный атрибут компании, чтобы скрыть атрибут компании прототипа
Jobs.sayhello = function ()
{
Alert ("Привет" + this.name + "как" + this.company);
};
Jobs.sayhello (); // Свойства и методы, которые вы переопределяете, выводите "Привет, такие работы, как Apple"
Billgates.sayhello (); // Покрытие рабочих
</script>
См. Следующий пример цепочки прототипа:
Кода -копия выглядит следующим образом:
<script type = "text/javascript">
функция года () {
this.value = 21;
}
Год.prototype = {
Метод: function () {
}
};
функция hi () {
};
// установить свойство прототипа HI на объект экземпляра года
HI.Prototype = Новый год ();
Hi.prototype.year = 'hello world';
Hi.prototype.constructor = hi;
var test = new hi (); // Создать новый экземпляр HI
// прототип цепочка
тест [HI пример]
HI.Prototype [пример года]
{Год: «Привет, мир»}
Год. Прототип
{метод:…};
Object.Prototype
{toString: ...};
</script>
Из приведенного выше примера испытательный объект унаследован от HI.Prototype и Year.prototype; Следовательно, он может получить доступ к методу прототипа года, и в то же время он может получить доступ к значению свойства экземпляра
__ptoto__ атрибут
Атрибут __ptoto__ (не поддерживается IE Browser) является указателем на объект прототипа экземпляра. Его функция состоит в том, чтобы указывать на конструктор атрибута прототипа конструктора. Через эти два атрибута вы можете получить доступ к свойствам и методам в прототипе.
Экземпляр объекта в JavaScript по существу состоит из ряда свойств. Среди этих свойств существует внутренняя невидимая специальная собственность - __proto__. Значение этого свойства указывает на прототип экземпляра объекта. Экземпляр объекта имеет только уникальный прототип.
Кода -копия выглядит следующим образом:
<script type = "text/javascript">
Функциональный Box () {// Верхив, представляющий конструктор
Box.prototype.name = "trigkit4"; // атрибуты прототипа
Box.prototype.age = "21";
Box.prototype.run = function () // Метод прототипа
{
вернуть это.
}
}
var box1 = new Box ();
var box2 = new Box ();
оповещение (Box1.constructor); // Создание атрибута, вы можете получить сам конструктор,
// Функция должна быть расположена с помощью указателя прототипа, а затем получить сам конструктор
</script>
Разница между атрибутом __proto__ и атрибутом прототипа
Прототип является собственностью объекта функции.
__proto__ является неявным свойством нормального объекта. Когда это новое, это будет указывать на объект, на который указывает прототип;
__ptoto__ на самом деле является атрибутом определенного объекта объекта, в то время как прототип является атрибутом, принадлежащим конструктору. __ptoto__ может использоваться только в средах обучения или отладки.
Прототип процесса выполнения режима
1. Сначала ищите атрибуты или методы в экземпляре конструктора, и если это так, вернитесь немедленно.
2. Если нет экземпляра конструктора, перейдите к его объекту прототипа и немедленно вернитесь.
Прототип объект
Кода -копия выглядит следующим образом:
<script type = "text/javascript">
Функциональный Box () {// Верхив, представляющий конструктор
Box.prototype.name = "trigkit4"; // атрибуты прототипа
Box.prototype.age = "21";
Box.prototype.run = function () // Метод прототипа
{
вернуть это.
}
}
var box1 = new Box ();
Alert (box1.name); // trigkit4, значение в прототипе
box1.name = "lee";
предупреждение (box1.name); // Ли, перейти к принципу
var box2 = new Box ();
Alert (box2.name); // trigkit4, значение прототипа, не изменяемое Box1
</script>
Конструктор
Кода -копия выглядит следующим образом:
<script type = "text/javascript">
Функция Box () {
this.name = "bill";
}
Box.prototype.name = "trigkit4"; // атрибуты прототипа
Box.prototype.age = "21";
Box.prototype.run = function () // Метод прототипа
{
вернуть это.
}
var box1 = new Box ();
Alert (box1.name); // Счета, значение в прототипе
box1.name = "lee";
предупреждение (box1.name); // Ли, перейти к принципу
</script>
Подводя итог, давайте разберем это:
Кода -копия выглядит следующим образом:
<script type = "text/javascript">
function person () {};
Person.prototype.name = "trigkit4";
Person.prototype.say = function () {
оповещение ("hi");
}
var p1 = new Person (); // Прототип является прототипом объекта P1 и P2
var p2 = new Person (); // p2 - созданный объект, и внутри него есть атрибут __proto__, указывающий на прототип человека
console.log (p1.prototype); // не определено, это свойство является объектом и не может быть доступно
console.log (person.prototype); // человек
console.log (person.prototype.constructor); // Существует также указатель (свойство конструктора) внутри объекта прототипа, указывающего на функцию конструктора
Console.log (p1 .__ Proto __); // Это свойство является указателем, указывающим на объект прототипа прототипа
p1.say (); // экземпляры могут получить доступ к свойствам и методам, определенным на объекте прототипа
</script>
Заводская модель
Кода -копия выглядит следующим образом:
функция createObject (name, age) {
var obj = new Object ();
obj.name = name;
obj.age = возраст;
вернуть OBJ;
}
Заводская шаблон решает проблему крупномасштабного дублирования созданных объектов, но есть другая проблема, то есть невозможно выяснить, какой это экземпляр объекта.
Использование метода конструктора не только решает проблему повторного экземпляра, но и решает проблему распознавания объектов.
Разница между использованием методов конструктора и заводских моделей заключается в том, что:
1. Создать объект (новый объект ()), который не отображается методом конструктора;
2. напрямую назначьте атрибуты и методы этому объекту
3. Нет ответа
Когда используется конструктор и используется новый конструктор (), New Object () выполняется в фоновом режиме;
Это в корпусе функции представляет объект, полученный из нового объекта ()
1. Определите, находится ли свойство в экземпляре конструктора или в прототипе, вы можете использовать функцию `hasownproperty ()`
2. Способ создания литералов используется для создания атрибутов конструктора, не будет указывать на экземпляр, а на объект, а способ создания конструкторов - противоположность.
Зачем указывать объект? Потому что Box.prototype = {}; этот способ написания фактически для создания нового объекта.
Каждый раз, когда создается функция, его прототип будет создан одновременно, и этот объект автоматически получит атрибут конструктора
3. Если это метод экземпляра, другой экземпляр, их адреса метода различны и уникальны.
4. Если это метод прототипа, то их адрес обмен