Частные переменные и функции
Если переменные и функции, определенные внутри функции, не предоставляются извне, к ним нельзя получить извне, то есть частные переменные и функции функции.
Кода -копия выглядит следующим образом:
<script type = "text/javascript">
функциональный тест () {
var color = "blue"; // частная переменная
var fn = function () // частная функция
{
}
}
</script>
Таким образом, переменные цвета и FN не могут быть доступны вне теста объекта функции, и они становятся частными:
Кода -копия выглядит следующим образом:
var obj = new Test ();
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>
Переменные экземпляра и функции
В объектно-ориентированном программировании, в дополнение к некоторым библиотечным функциям, мы все еще надеемся определить некоторые свойства и методы одновременно, когда определение объекта, к которым можно получить доступ после экземпляра. JavaScript также может сделать это
Кода -копия выглядит следующим образом:
<script type = "text/javascript">
функция obj () {
this.a = []; // переменная экземпляра
this.fn = function () {// Метод экземпляра
}
}
console.log (typeof obj.a); //неопределенный
console.log (typeof obj.fn); //неопределенный
var o = new obj ();
console.log (typeof oa); //объект
console.log (typeof o.fn); // функция
</script>
Добавить новые методы и свойства к переменным экземпляра и методов
Кода -копия выглядит следующим образом:
<script type = "text/javascript">
функция obj () {
this.a = []; // переменная экземпляра
this.fn = function () {// Метод экземпляра
}
}
var o1 = new obj ();
o1.a.push (1);
o1.fn = {};
console.log (o1.a); // [1]
console.log (typeof o1.fn); //объект
var o2 = new obj ();
console.log (o2.a); // []
console.log (typeof o2.fn); // функция
</script>
A и FN модифицированы в O1, но не в O2. Поскольку массивы и функции являются объектами и являются эталонными типами, это означает, что, хотя свойства и методы в O1 такие же, как и в O2, они не являются ссылкой, а копией свойств и методов, определенных объектом OBJ.
У этого нет проблем со свойствами, но это большая проблема для методов, потому что методы выполняют одинаковую функцию, но есть две копии. Если объект функции имеет тысячи и методы экземпляра, то каждый его экземпляр должен поддерживать копию тысяч методов. Это, очевидно, ненаучно. Что я могу сделать? Прототип возник.
Основные понятия
Каждая функция, которую мы создаем, имеет свойство прототипа, которое является указателем на объект, и его цель состоит в том, чтобы содержать свойства и методы, которые могут быть переданы всеми экземплярами определенного типа. Затем прототип является прототипом объекта экземпляра объекта, созданного путем вызова конструктора.
Преимущество использования прототипа заключается в том, что он позволяет экземпляру объекта делиться свойствами и методами, которые он содержит. То есть вместо добавления информации объекта определения в конструктор вы можете напрямую добавить эту информацию в прототип. Основная проблема с использованием конструкторов заключается в том, что каждый метод должен быть создан один раз в каждом случае.
В 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">
Функция человека (имя) {
this.name = name;
}
Person.prototype.printname = function () {
оповещение (this.name);
}
var person1 = новый человек ('byron');
var person2 = новый человек ('frank');
</script>
Человек Человека 1 содержит атрибут имени, и он автоматически генерирует атрибут __proto__, который указывает на прототип человека, и вы можете получить доступ к методу PrintName, определяемому в прототипе, который, вероятно, похож на это:
Еще один каштан:
Кода -копия выглядит следующим образом:
<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>