构造函数、原型链、继承简单理解(创建对象的三个方法是什么)

1. 创建对象的三个方法

创建一个对象一般有三种方法:

  1. 字面量创建, var obj = {};
  2. 通过Object创建, var obj = new Object();
  3. 通过构造函数创建:
function Person(name, age) {
    this.name = name;
    this.age = age;
}
const jack = new Person('Jack', 18);

上面代码中的 new 在执行时会做四件事情:

  1. 在内存中创建一个新的空对象。
  2. 让 this 指向这个对象。
  3. 执行构造函数的代码。
  4. 返回这个对象(所以构造函数不需要 return)。

2. 静态成员与实例成员

function Person(name, age) {
  this.name = name; // 实例成员
  this.age = age;
  this.sing = function () {
    console.log('我在唱歌');
  };
}

Person.height = 180; // 静态成员

const jack = new Person('Jack', 22);
const lily = new Person('Lily', 22);

console.log(Person.height); // 180
console.log(jack.height); // undefined
console.log(jack.sing === lily.sing); // false  这里可以看出,多个实例调用相同的方法,会造成内存浪费

上面代码可以看出:
静态成员只能使用构造函数调用,不能通过实例调用。
多个实例调用同样的实例成员函数,会各自存储一份,造成内存浪费。
那么,如何解决呢?

3. 原型和原型链

构造函数存在内存浪费的情况,可以通过原型对象上定义属性、方法解决。构造函数原型上的方法,能够被构造函数实例调用。
每一个构造函数都有一个 prototype 属性,指向一个对象。这个对象的所有属性和方法都会被构造函数所拥有。
我们可以把那些不变的方法直接定义到 prototype 上,这样所有的实例都可以共享这些方法。
代码如下:

Person.prototype.say = function () {
  console.log('我在说话');
};
jack.say();
lily.say();
console.log(jack.say === lily.say);

每个对象都会有一个__proto__属性,指向其构造函数的原型对象。也就是说,对象的__proto__属性和构造函数的 prototype 属性是等价的。
实例对象和原型对象都有一个constructor属性,指向构造函数本身。
我们调用一个函数的属性时,编译器会先看对象本身是否有这个属性,如果没有就到对象的__proto__属性上去找,如果还找不到,继续找__proto__的__proto__属性,直到 null 为止。
把构造函数、实例对象、原型对象的关系用图画出来,如下:

构造函数、原型链、继承简单理解

这就是原型链。

其实构造函数是Function的实例,Function的原型是一个对象,是Object的实例。我们继续拓展,把图画下来。如下:

构造函数、原型链、继承简单理解

4. 使用原型扩展内置对象方法

我们可以使用原型来扩展内置对象的方法。比如,我们可以这样扩展数组的内置方法:

Array.prototype.sum = function () {
  let sum = 0;
  for (let i = 0; i < this.length; i++) {
    sum += this[i]; // prototype 里的 this 指向调用原型方法的那个对象。
  }
  return sum;
};

console.log([2, 3, 4].sum()); // 9

5. 继承

  • 构造函数继承:只能继承构造函数里的属性和方法
    其实就是在子构造函数里面调用父构造函数(需要修改this指向),这样就把父构造函数里的属性和方法放到了子构造函数里了。
function Person(name, age) {
  this.name = name;
  this.age = age;
  this.say = function () {
    console.log('你好');
  };
}
Person.prototype.sing = function () {
  console.log('唱歌');
};

function Student(name, age, score) {
  Person.call(this, name, age); // 由于Person里的this指向为Person的实例,这里修改this指向为Student的实例
  this.score = score;
}

const jack = new Student('Jack', 18, 100);
console.log(jack.name); // Jack
jack.say(); // 你好
jack.sing(); // 无结果,Student没有继承Person原型上的方法
  • 原型链继承
    通过上面的例子我们可以看出,构造函数继承并不能继承原型链上的方法。那我们怎么才能继承父构造函数原型上的方法呢?我们可以把子构造函数原型指向父构造函数的原型。
Student.prototype = Person.prototype; // - 原始版 缺陷:Student的原型改变导致Person原型改变,因此不可取

原型一样,自然能够继承原型上的方法。
但是这样一来就会出现问题,原型是个对象,是引用类型数据,我们再修改Student.prototype会导致Person.prototype的变化。这是不合理的。比如:

Student.prototype.dance = function () {
  console.log('跳舞');
};

const jack = new Person('Jack', 18);
jack.dance(); // 跳舞    Person的原型上是没有dance方法的。这里是因为我们扩展了Student的原型导致Person原型变化

常用的解决办法是,我们将子构造函数的原型指向福构造函数的一个实例。

Student.prototype = new Person();
构造函数、原型链、继承简单理解

前面说过,调用一个函数的属性时,编译器会先看对象本身是否有这个属性,如果没有就到对象的__proto__属性上去找,如果还找不到,继续找__proto__的__proto__属性,直到 null 为止。这样一来,Student实例就能够调用Person实例的方法,从而调用Person原型的方法。

  • 组合继承
    把构造函数继承和组合继承结合起来就是组合继承了。整体代码如下:
function Person(name, age) {
  this.name = name;
  this.age = age;
  this.say = function () {
    console.log('你好');
  };
}
Person.prototype.sing = function () {
  console.log('唱歌');
};

function Student(name, age, score) {
  Person.call(this, name, age);
  this.score = score;
}
Student.prototype = new Person();
Student.prototype.constructor = Student; // 修改constructor指向

组合继承调用了两次父构造函数,且每创建一个子构造函数,都会生成一个父构造函数实例。还是不够完美。

  • 寄生组合继承
function Person(name, age) {
  this.name = name;
  this.age = age;
  this.say = function () {
    console.log('你好');
  };
}
Person.prototype.sing = function () {
  console.log('唱歌');
};

function Student(name, age, score) {
  Person.call(this, name, age);
  this.score = score;
}
Student.prototype = Object.create(Person.prototype); // Object.create(proto)创建一个对象,这个对象的__proto__属性为proto
Student.prototype.constructor = Student; // 修改constructor指向
构造函数、原型链、继承简单理解

Student实例能够调用Student原型上的方法,而Student原型又可以通过__proto__获取Person原型上的方法。这样就实现了Student继承Person原型上的方法。
也可以自己写一个类似Object.create(proto)的方法。

function objectCreate(proto) {
  function Temp() {}
  Temp.prototype = proto;
  return new Temp();
}
Student.prototype = objectCreate(Person.prototype);
Student.prototype.constructor = Student; // 修改constructor指向

6. 类的本质

当然,要实现继承最好写最好用的还是ES6里面的类。探究一下会发现:

  • 类的本质还是函数。
  • 类也有prototype属性
  • 类创建的实例,也有__proto__属性,且指向类的 prototype 属性
  • 类创建的实例的constructor指向类本身
  • 类的prototype的constructor也是指向类本身
class Person {
  constructor(name, age) {
    this.name = name;
    this.age = age;
  }
  say() {
    console.log('说话');
  }
}

const jack = new Person('Jack', 18);

console.log(typeof Person); // function
console.log(Person.prototype); // {constructor: ƒ, say: ƒ}
console.log(jack.__proto__ === Person.prototype); // true
console.log(jack.constructor); // class Person{ ... }
console.log(Person.prototype.constructor); // class Person{ ... }

总结:ES6 的类就是ES5继承的语法糖。

本文链接:https://www.dzdvip.com/35881.html 版权声明:本文内容均来源于互联网。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌抄袭侵权/违法违规的内容, 请发送邮件至 395045033@qq.com,一经查实,本站将立刻删除。
(0)
打赏 微信扫一扫 微信扫一扫 支付宝扫一扫 支付宝扫一扫
上一篇 2022年7月25日 23:14
下一篇 2022年7月25日 23:35

相关推荐

发表评论

您的电子邮箱地址不会被公开。