L - JavaScript继续

2024年5月1日 181次阅读 来源: None_

类式继续（原型链继续）

完成

function A(){
    this.a='a';
    this.arr=[1,2];
}
A.prototype.funA=function(){
    console.log("我是A的要领");
    
}
function B(){
    this.b='b';
}
B.prototype.funB=function(){
    console.log("我是B的要领");
}
B.prototype=new A();

var b1=new B();

由于A的实例能够接见A.prototype，所以我们能够设置B.prototype指向A的实例。所以B的实例能够接见A的实例以及A.prototype，完成继续

瑕玷：

1.由于对象范例的赋值是援用赋值，假如父类A实例化历程中有援用范例，那末子类B的实例的这个属性都指向统一内存空间。

function A(){
    this.a='a';
    this.arr=[1,2];
}
A.prototype.funA=function(){
    console.log("我是A的要领");
    
}
function B(){
    this.b='b';
}
B.prototype.funB=function(){
    console.log("我是B的要领");
}
B.prototype=new A();

var b1=new B();
var b2=new B();

b1.arr.push(3);
console.log(b1.arr);    // [1, 2, 3]
console.log(b2.arr);    // [1, 2, 3]

2.假如父类的实例须要传入一些参数，那末两个子类实例初始化时某一属性值雷同

function A(year){
    this.year=year;
}
function B(){
    this.b='b';
}
B.prototype=new A(18);

var b1=new B();
var b2=new B();
console.log(b1.color);    // 18
console.log(b2.color);    // 18

3.B.prototype中constructor指向不正确，由于B.prototype指向了一个A的实例，所以本应指向B的constructor指向了A

function A(year){
    this.year=year;
}
function B(){
    this.b='b';
}
B.prototype=new A(18);

var b1=new B();

b1.constructor===A    // true

组织函数继续（借用组织函数继续）

完成

function A(color){
    this.a='a';
    this.arr=[1,2];
    this.color=color;
}
A.prototype.funA=function(){
    console.log("我是A的要领");
    
}
function B(color){
    A.call(this,color);
}
B.prototype.funB=function(){
    console.log("我是B的要领");
}

var b1=new B("red");

console.log(b1)    // {a: "a", arr: Array(2), color: "red"}

优点

处理了援用赋值题目，也能够自定义一些属性了，constructor也指向B了，即处理了类式继续的第一个、第二个题目以及第三个题目

瑕玷

很明显，B除了调用了A这个函数外并没有和A扯上什么关系，原型链是不通的(无法接见到应当作为父类的A的prototype属性)，我以至并不以为这是一种继续体式格局，但它为下面两种要领奠基了基本

b1.__proto__===B.prototype   // true
b1.__proto__.__proto__===Object.prototype    // true

组合继续

说白了，就是将上述两种要领的优点组合到一同，应用原型链完成原型属性和要领的继续，经由过程借用组织函数完成对实例属性的继续

完成

function A(color){
    this.a='a';
    this.arr=[1,2];
    this.color=color;
}
A.prototype.funA=function(){
    console.log("我是A的要领");
    
}
function B(color,age){
    // 经由过程借用组织函数完成对实例属性的继续
    A.apply(this,[color]);
    this.age=age;
}

// 应用原型链完成原型属性和要领的继续
B.prototype=new A();
B.prototype.constructor=B;

var b1=new B('red',18);

优点

既经由过程在原型上定义要领完成了函数复用，又能够保证每一个实例都有它自己的属性

瑕玷

调用了两次父类的组织函数

寄生组合式继续（此要领最好）

完成

function A(color){
    this.a='a';
    this.arr=[1,2];
    this.color=color;
}
A.prototype.funA=function(){
    console.log("我是A的要领");
    
}
function B(color,age){
    A.apply(this,[color]);
    this.age=age;
}

B.prototype=Object.create(A.prototype);
B.prototype.constructor=B;

var b1=new B('red',18);

优点

只需接见一次父类的组织函数,避免了在子类的prototype上建立不必要、过剩的属性

    原文作者：None_
    原文地址: https://segmentfault.com/a/1190000014142967
    本文转自网络文章，转载此文章仅为分享知识，如有侵权，请联系博主进行删除。
点赞