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. 继承

• 1. 构造函数继承：只能继承构造函数里的属性和方法
     其实就是在子构造函数里面调用父构造函数（需要修改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原型上的方法

• 2. 原型链继承
     通过上面的例子我们可以看出，构造函数继承并不能继承原型链上的方法。那我们怎么才能继承父构造函数原型上的方法呢？
     我们可以把子构造函数原型指向父构造函数的原型。

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原型的方法。

• 3. 组合继承
     把构造函数继承和组合继承结合起来就是组合继承了。整体代码如下：

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指向

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

• 4. 寄生组合继承

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继承的语法糖。


参考资料：
传智教育 - JavaScript进阶面向对象ES6