1. 创建对象的三个方法
创建一个对象一般有三种方法：
- 字面量创建，
var obj = {}; - 通过Object创建，
var obj = new Object(); - 通过构造函数创建：
function Person(name, age) {
this.name = name;
this.age = age;
}
const jack = new Person('Jack', 18);
上面代码中的 new 在执行时会做四件事情：
- 在内存中创建一个新的空对象。
- 让 this 指向这个对象。
- 执行构造函数的代码。
- 返回这个对象（所以构造函数不需要 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继承的语法糖。
参考资料：
传智教育 - JavaScript进阶面向对象ES6
