Dieser Artikel stellt hauptsächlich die detaillierte Erklärung der Vererbungsmethoden in JavaScript vor. In diesem Artikel werden die Konzepte der js-Vererbung, der Prototypenvererbung und der Klassenvererbung, der Prototypenkettenvererbung, der Klassenvererbung, der Kombinationsvererbung, der Prototypenvererbung usw. erläutert Siehe das Konzept der
js-Vererbung
Die folgenden zwei Vererbungsmethoden werden häufig in js verwendet:
Prototypkettenvererbung (Vererbung zwischen Objekten)
Klassenvererbung ( Vererbung zwischen Konstruktoren )
Da js keine echte objektorientierte Sprache wie Java ist, basiert js auf Objekten, es gibt kein Konzept dafür Klassen. Wenn Sie also die Vererbung implementieren möchten, können Sie den Prototypmechanismus von js oder die Apply- und Call-Methoden verwenden, um
In objektorientierten Sprachen verwenden wir Klassen, um ein benutzerdefiniertes Objekt zu erstellen. Allerdings ist alles in js ein Objekt. Wie erstellt man also ein benutzerdefiniertes Objekt? Dies erfordert die Verwendung von js Prototyp:
Wir können uns den Prototyp einfach als Vorlage vorstellen, und die neu erstellten benutzerdefinierten Objekte sind alle Kopien dieser Vorlage (Prototyp) (eigentlich keine Kopie, sondern eine Kopie). Link, aber dieser Link ist unsichtbar. Es gibt einen unsichtbaren Proto-Zeiger im neu instanziierten Objekt, der auf das Prototyp-Objekt zeigt.
JS kann die Funktionen von Klassen durch Konstruktoren und Prototypen simulieren. Darüber hinaus basiert die Implementierung der JS-Klassenvererbung auch auf der Prototypenkette.
Prototypische Vererbung und Klassenvererbung
Die Klassenvererbung besteht darin, den Supertyp-Konstruktor innerhalb des Subtyp-Konstruktors aufzurufen.
Strikte Klassenvererbung ist nicht sehr verbreitet und wird normalerweise in Kombination verwendet:
Der Code lautet wie folgt:
function Super(){
this.colors=["red","blue"];
}
function Sub(){
Super.call(this);
}
Prototypische Vererbung basiert auf Vorhanden Erstellen Sie ein neues Objekt aus dem Objekt und verweisen Sie den Prototyp der Unterklasse auf die übergeordnete Klasse. Dies entspricht dem Beitritt zur Prototypkette der übergeordneten Klasse
Vererbung der Prototypkette
Damit eine Unterklasse die Attribute (einschließlich Methoden) der übergeordneten Klasse erbt, muss sie zunächst einen Konstruktor definieren. Weisen Sie dann die neue Instanz der übergeordneten Klasse dem Prototyp des Konstruktors zu. Der Code lautet wie folgt:
Der Code lautet wie folgt:
<script>
function Parent(){
this.name = 'mike';
}
function Child(){
this.age = 12;
}
Child.prototype = new Parent();//Child继承Parent，通过原型，形成链条
var test = new Child();
alert(test.age);
alert(test.name);//得到被继承的属性
//继续原型链继承
function Brother(){ //brother构造
this.weight = 60;
}
Brother.prototype = new Child();//继续原型链继承
var brother = new Brother();
alert(brother.name);//继承了Parent和Child,弹出mike
alert(brother.age);//弹出12
</script>Der obigen Prototypkettenvererbung fehlt ein Link, nämlich Objekt, und alle Konstruktoren erben von Objekt . Die Vererbung von Objekten erfolgt automatisch und erfordert keine manuelle Vererbung. Was ist also ihre Zugehörigkeit?
Bestimmung der Beziehung zwischen Prototypen und Instanzen
Die Beziehung zwischen Prototypen und Instanzen kann auf zwei Arten bestimmt werden. Operator-Instanceof- und isPrototypeof()-Methoden:alert(brother instanceof Object)//true alert(test instanceof Brother);//false,test 是brother的超类 alert(brother instanceof Child);//true alert(brother instanceof Parent);//true
Erstens wird durch das wörtliche Umschreiben des Prototyps die Beziehung unterbrochen, wobei der Prototyp des Referenztyps verwendet wird und der Untertyp keine Parameter an den Obertyp übergeben kann.
Pseudoklassen lösen das Problem der Referenzfreigabe und der Unfähigkeit, Parameter von Supertypen zu übergeben. Wir können die „geliehene Konstruktor“-Technologie verwenden
Geliehener Konstruktor (Klassenvererbung)
Der Code lautet wie folgt:
Obwohl der geliehene Konstruktor gerade die beiden Probleme löst, ist eine Wiederverwendung ohne Prototyp nicht möglich, daher benötigen wir einen Prototyp Kette + geliehener Konstruktor Funktionsmuster, dieses Muster wird kombinierte Vererbung genannt
<script>
function Parent(age){
this.name = ['mike','jack','smith'];
this.age = age;
}
function Child(age){
Parent.call(this,age);
}
var test = new Child(21);
alert(test.age);//21
alert(test.name);//mike,jack,smith
test.name.push('bill');
alert(test.name);//mike,jack,smith,bill
</script>Kombinierte Vererbung
Der Code lautet wie folgt:
Kombinierte Vererbung ist eine häufiger verwendete Vererbungsmethode. Die Idee dahinter besteht darin, die Prototypenkette zu verwenden, um die Vererbung von Prototyp-
-Eigenschaften und -Methoden<script>
function Parent(age){
this.name = ['mike','jack','smith'];
this.age = age;
}
Parent.prototype.run = function () {
return this.name + ' are both' + this.age;
};
function Child(age){
Parent.call(this,age);//对象冒充，给超类型传参
}
Child.prototype = new Parent();//原型链继承
var test = new Child(21);//写new Parent(21)也行
alert(test.run());//mike,jack,smith are both21
</script>Der Code lautet wie folgt:
call([thisObj[,arg1[, arg2[, [,.argN]]]]])
Diese Vererbung verwendet Prototypen und basiert auf vorhandenen Objekte Die Möglichkeit, ein neues Objekt zu erstellen, ohne einen benutzerdefinierten Typ zu erstellen, wird als prototypische Vererbung bezeichnet.
Die prototypische Vererbung erstellt zunächst ein temporäres Objekt innerhalb der obj()-Funktion Der Konstruktor verwendet dann das übergebene Objekt als Prototyp dieses Konstruktors und gibt schließlich eine neue Instanz dieses temporären Typs zurück.
<script>
function obj(o){
function F(){}
F.prototype = o;
return new F();
}
var box = {
name : 'trigkit4',
arr : ['brother','sister','baba']
};
var b1 = obj(box);
alert(b1.name);//trigkit4
b1.name = 'mike';
alert(b1.name);//mike
alert(b1.arr);//brother,sister,baba
b1.arr.push('parents');
alert(b1.arr);//brother,sister,baba,parents
var b2 = obj(box);
alert(b2.name);//trigkit4
alert(b2.arr);//brother,sister,baba,parents
</script>Parasitäre Vererbung
Diese Vererbungsmethode kombiniert Prototyp +Factory-Muster
, um den Erstellungsprozess zu kapseln. Kleines Problem mit kombinierter Vererbung<script>
function create(o){
var f= obj(o);
f.run = function () {
return this.arr;//同样，会共享引用
};
return f;
}
</script>组合式继承是js最常用的继承模式，但组合继承的超类型在使用过程中会被调用两次；一次是创建子类型的时候，另一次是在子类型构造函数的内部
代码如下:
<script>
function Parent(name){
this.name = name;
this.arr = ['哥哥','妹妹','父母'];
}
Parent.prototype.run = function () {
return this.name;
};
function Child(name,age){
Parent.call(this,age);//第二次调用
this.age = age;
}
Child.prototype = new Parent();//第一次调用
</script>以上代码是之前的组合继承，那么寄生组合继承，解决了两次调用的问题。
寄生组合式继承
代码如下:
<script>
function obj(o){
function F(){}
F.prototype = o;
return new F();
}
function create(parent,test){
var f = obj(parent.prototype);//创建对象
f.constructor = test;//增强对象
}
function Parent(name){
this.name = name;
this.arr = ['brother','sister','parents'];
}
Parent.prototype.run = function () {
return this.name;
};
function Child(name,age){
Parent.call(this,name);
this.age =age;
}
inheritPrototype(Parent,Child);//通过这里实现继承
var test = new Child('trigkit4',21);
test.arr.push('nephew');
alert(test.arr);//
alert(test.run());//只共享了方法
var test2 = new Child('jack',22);
alert(test2.arr);//引用问题解决
</script>call和apply
全局函数apply和call可以用来改变函数中this的指向，如下：
代码如下:
// 定义一个全局函数
function foo() {
console.log(this.fruit);
}
// 定义一个全局变量
var fruit = "apple";
// 自定义一个对象
var pack = {
fruit: "orange"
};
// 等价于window.foo();
foo.apply(window); // "apple",此时this等于window
// 此时foo中的this === pack
foo.apply(pack); // "orange"Das obige ist der detaillierte Inhalt vonDetaillierte Erläuterung der Vererbungsmethoden in JS. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
![[Web-Frontend] Node.js-Schnellstart](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
