Концепция наследования JS
Следующие два метода наследования, обычно используемые в JS:
Прототип цепочки наследования (наследование между объектами)
Классическое наследование (наследование между конструкторами)
Поскольку JS не является действительно объектно-ориентированным языком, таким как Java, JS основан на объекте и не имеет концепции классов. Поэтому, если вы хотите реализовать наследование, вы можете использовать прототип прототипа механизма JS или использовать методы применения и вызова для его реализации
На объектно-ориентированном языке мы используем классы для создания пользовательского объекта. Тем не менее, все в JS является объектом, поэтому какой метод можно использовать для создания пользовательского объекта? Это требует прототипа JS:
Мы можем просто рассматривать прототип как шаблон. Недавно созданные пользовательские объекты - это копия этого шаблона (прототип) (на самом деле не копия, а ссылка, но этот вид ссылки невидима. Внутри вновь созданный объект существует невидимый указатель __proto__).
JS может имитировать и реализовать функции классов с помощью конструкторов и прототипов. Кроме того, реализация наследования типа JS также достигается путем полагательства на прототипы цепочек.
Прототип наследование и наследование класса
Классическое наследование - это призыв супертипа конструктора внутри подтипа конструктора.
Строгое наследование класса не очень распространено и обычно используется в комбинации:
Кода -копия выглядит следующим образом:
функция super () {
this.colors = ["red", "blue"];
}
функция sub () {
Super.call (это);
}
Прототип наследование состоит в том, чтобы создать новый объект с помощью существующих объектов и указывать прототип подкласса на родительский класс, что эквивалентно добавлению цепочки прототипа родительского класса.
Прототип цепочка наследования
Для того чтобы дочерний класс унаследовал свойства родительского класса (включая методы), сначала необходим конструктор. Затем назначьте новый экземпляр родительского класса прототипу конструктора. Код заключается в следующем:
Кода -копия выглядит следующим образом:
<Скрипт>
function parent () {
this.name = 'mike';
}
function child () {
this.age = 12;
}
Child.prototype = new Parent (); // Child наследует родительский и образует цепь через прототип.
var test = new Child ();
оповещение (test.age);
Alert (test.name); // получить наследственные атрибуты
// продолжать наследовать цепочку прототипа
Функция Brother () {// Brother Construct
this.weight = 60;
}
Brother.prototype = new Child (); // продолжать прототип цепочки наследования
var brother = new Brother ();
предупреждение (брат.
оповещение (Brother.age); // pop 12
</script>
Приведенное выше прототипное наследование по -прежнему не хватает одной связи, то есть объекта, и все конструкторы наследуются от объекта. Унаследовательный объект автоматически завершается и не требует ручного наследства самим. Так каковы их подчиненные отношения?
Определить взаимосвязь между прототипом и экземпляром
Есть два способа определить взаимосвязь между прототипом и экземпляром. Методы оператора и ISPrototypeof ():
Кода -копия выглядит следующим образом:
Alert (брат экземпляр объекта) // true
предупреждение (тест брата); // ложный тест - это суперкласс брата
предупреждение (брат экземпляр ребенка); // true
предупреждение (брат экземпляр родителя); // true
Пока это прототип, который появляется в цепочке прототипа, можно сказать, что он является прототипом экземпляра, полученного из цепочки прототипа. Следовательно, метод iSprototypeof () также вернет true.
В JS унаследованная функция называется супертипом (родительский класс, базовый класс, а также), а унаследованная функция называется подтипом (подкласс, полученный класс). Использование прототипа наследования в основном включает в себя две проблемы:
Во -первых, буквальное переписывание прототипов нарушает отношения, использует прототип опорного типа, а подтип не может передавать параметры в супертип.
Pseudo-Class решает проблему обмена ссылками и супертипов, которые не могут передать аргументы. Мы можем использовать технологию «заимствовать конструктор».
Конструктор заимствования (классическое наследование)
Кода -копия выглядит следующим образом:
<Скрипт>
Функция родина (возраст) {
this.name = ['mike', 'jack', 'smith'];
this.age = возраст;
}
Функция ребенка (возраст) {
Parent.call (это, возраст);
}
тест var = новый ребенок (21);
оповещение (test.age); // 21
Alert (test.name); // Майк, Джек, Смит
test.name.push ('bill');
Alert (test.name); // Майк, Джек, Смит, Билл
</script>
Хотя заимствование конструкторов решило две проблемы только сейчас, без прототипов, нет способа повторного использования, поэтому нам нужен прототип цепочки + заимствовать конструкцию. Этот шаблон называется комбинацией наследования.
Комбинация наследования
Кода -копия выглядит следующим образом:
<Скрипт>
Функция родина (возраст) {
this.name = ['mike', 'jack', 'smith'];
this.age = возраст;
}
Parent.prototype.run = function () {
вернуть это. name + 'оба' + this.age;
};
Функция ребенка (возраст) {
Parent.call (это, возраст); // объект выдает себя и передает параметры супертипам
}
Child.prototype = new Parent (); // Прототип цепочки наследование
var test = новый ребенок (21); // написание нового родителя (21) в порядке
Alert (test.run ()); // Майк, Джек, Смит оба 21
</script>
Комбинация наследования является относительно часто используемым методом наследования. Идея, лежащая в основе этого, состоит в том, чтобы использовать цепочку прототипов для реализации наследования свойств и методов прототипа, а также реализации наследования свойств экземпляра заимствованием конструкторов. Таким образом, мультиплексирование функций достигается путем определения методов на прототипе и обеспечения того, чтобы каждый экземпляр обладал своими собственными свойствами.
Использование Call (): вызовите метод объекта и замените текущий объект другим объектом.
Кода -копия выглядит следующим образом:
Call ([thisobj [, arg1 [, arg2 [, [, .argn]]]]])
Прототип наследование
Этот способ унаследовать создание новых объектов, основанных на существующих объектах без создания пользовательских типов, называется прототипом наследование
Кода -копия выглядит следующим образом:
<Скрипт>
функция obj (o) {
Функция f () {}
F.Prototype = O;
вернуть новый f ();
}
var box = {
Имя: 'trigkit4',
Arr: ['Brother', 'сестра', 'baba']
};
var b1 = obj (box);
Alert (b1.name); // trigkit4
b1.name = 'mike';
оповещение (b1.name); // Майк
Блюдо (B1.ARR); // Брат, сестра, Баба
b1.arr.push («родители»);
Блюдо (B1.ARR); // Брат, сестра, Баба, родители
var b2 = obj (box);
Alert (b2.name); // trigkit4
Блюдо (b2.arr); // брат, сестра, Баба, родители
</script>
Прототип наследование сначала создает временный конструктор внутри функции obj (), затем использует переданный объект в качестве прототипа конструктора и, наконец, возвращает новый экземпляр этого временного типа.
Паразитическое наследование
Этот метод наследования объединяет модель прототипа + заводской модели с целью процесса создания инкапсуляции.
Кода -копия выглядит следующим образом:
<Скрипт>
функция создать (o) {
var f = obj (o);
f.run = function () {
вернуть это.arr; // Аналогично, ссылки будут обменены
};
возврат F;
}
</script>
Небольшие проблемы с комбинацией наследования
Комбинированное наследование является наиболее часто используемым режимом наследования в JS, но супертип комбинированного наследования будет вызоваться дважды во время использования; Однажды при создании подтипа, а другой находится внутри конструктора подтипа.
Кода -копия выглядит следующим образом:
<Скрипт>
Функция Parent (имя) {
this.name = name;
this.arr = [«брат», «сестра», «родители»];
}
Parent.prototype.run = function () {
вернуть это. name;
};
Функция ребенка (имя, возраст) {
Parent.call (это, возраст); // второй вызов
this.age = возраст;
}
Child.prototype = new Parent (); // Первый вызов
</script>
Приведенный выше код представляет собой предыдущее наследование комбинации, поэтому паразитарное наследство решает проблему двух вызовов.
Паразитарная комбинация наследования
Кода -копия выглядит следующим образом:
<Скрипт>
функция obj (o) {
Функция f () {}
F.Prototype = O;
вернуть новый f ();
}
Функция создать (родитель, тест) {
var f = obj (parent.prototype); // Создать объект
f.constructor = test; // Улучшенный объект
}
Функция Parent (имя) {
this.name = name;
this.arr = [«брат», «сестра», «родители»];
}
Parent.prototype.run = function () {
вернуть это. name;
};
Функция ребенка (имя, возраст) {
Parent.call (это, имя);
this.age = возраст;
}
Унаследованпрототип (родитель, ребенок); // наследство реализуется через
var test = new Child ('trigkit4', 21);
test.arr.push ('племянник');
предупреждение (test.arr); //
Alert (test.run ()); // Только метод общий
var test2 = новый ребенок ('Jack', 22);
предупреждение (test2.arr); // Решение проблемы цитирования
</script>
позвонить и применить
Глобальные функции применяются, и вызов может использоваться для изменения указания на это в функции следующим образом:
Кода -копия выглядит следующим образом:
// определить глобальную функцию
функция foo () {
console.log (this.fruit);
}
// определить глобальную переменную
var fruit = "Apple";
// Настроить объект
var pack = {
фрукты: "апельсин"
};
// эквивалентно window.foo ();
foo.apply (окно); // "Apple", это равно
// это === Пакет в foo
foo.apply (pack); // "апельсин"