JavaScript 继承小记

面向对象编程很重要的一个方面，就是对象的继承。A 对象通过继承 B 对象，就能直接拥有 B 对象的所有属性和方法。这对于代码的复用是非常有用的。

大部分面向对象的编程语言，都是通过“类”（class）实现对象的继承。传统上，JavaScript 语言的继承不通过 class(ES6 引入了class 语法)，而是通过“原型对象”（prototype）实现。那么在JS中常见的继承方式有几种呢？

首先我们先来通过 es5 里的方法做一个类，即构造方法，如下：

function Person() {
// 定义参数
this.name = "张三";
this.age = 18;
// 定义方法
this.run = function () {
console.log(this.name + "在运动");
}
}

// 通过原型链扩展属性和方法
Person.prototype.sex = "男";
Person.prototype.work = function () {
console.log(this.name + "在工作");
};
// 通过类添加属性和静态方法
Person.city = "北京";
Person.eat = function () {
console.log(this.name + "在吃")
};

// 实例化 Person
var p = new Person();
p.run(); // 张三在运动
p.work(); // 张三在工作
// p.eat(); // 报错 p.eat is not a function
Person.eat(); // Person在吃  // this 指向发生改变，为全局，该 name 不是 Person 类中定义的 name

在上面的代码中，我们根据构造函数方法创建了一个 Person 类，并通过内部定义参数方法，原型链扩展属性和方法，通过类添加属性和方法。接下来我们就根据这个 Person 类来实现集中继承的方法。

1、对象冒充实现继承

function Person() {
// 定义参数
this.name = "张三";
this.age = 18;
// 定义方法
this.run = function () {
console.log(this.name + "在运动");
}
}

// 通过原型链扩展属性和方法
Person.prototype.sex = "男";
Person.prototype.work = function () {
console.log(this.name + "在工作");
};

function Student() {
Person.call(this);
}
var s = new Student();
console.log(s.name); // 张三
s.run(); // 张三在运动
/**
* 对象冒充继承不能实现
* 父类原型链上的属性和方法
*/
console.log(s.sex); // undefined
s.work(); // 报错 s.work is not a function

在上面的代码中，我们可以通过对象冒充的方法进行继承，但是原型链上的属性和方法是不能被继承的。

2、原型链继承

function Person() {
// 定义参数
this.name = "张三";
this.age = 18;
// 定义方法
this.run = function () {
console.log(this.name + "在运动");
}
}

// 通过原型链扩展属性和方法
Person.prototype.sex = "男";
Person.prototype.work = function () {
console.log(this.name + "在工作");
};
// 通过类添加属性和静态方法
Person.city = "北京";
Person.eat = function () {
console.log(this.name + "在吃")
};

function Student() {

}
Student.prototype = new Person();
var s = new Student();
console.log(s.name); // 张三
s.run(); // 张三在运动
console.log(s.sex); // 男
s.work(); // 张三在工作

在上面的代码中，我们通过原型链的方法进行继承，这样构造方法内的方法和原型链上的方法我们都能继承了，看似很不错，但是其实存在着一些问题，如下：

function Person(name,age) {
// 定义参数
this.name = name;
this.age = age;
// 定义方法
this.run = function () {
console.log(this.name + "在运动");
}
}

// 通过原型链扩展属性和方法
Person.prototype.sex = "男";
Person.prototype.work = function () {
console.log(this.name + "在工作");
};
var p = new Person("张三",18);
p.run(); // 张三在运动
p.work(); // 张三在工作

function Student(name,age) {

}
Student.prototype = new Person();
var s = new Student("李四", '20');
console.log(s.name); // undefined
s.run(); // undefined在运动
console.log(s.sex); // 男
s.work(); // undefined在工作

在上面的代码中，我们可以看出，通过原型链继承，在实例化子类的时候没法给父类进行传参。

3、原型链+对象冒充组合继承

function Person(name, age) {
// 定义参数
this.name = name;
this.age = age;
// 定义方法
this.run = function () {
console.log(this.name + "在运动");
}
}

// 通过原型链扩展属性和方法
Person.prototype.sex = "男";
Person.prototype.work = function () {
console.log(this.name + "在工作");
};
var p = new Person("张三", 18);
p.run(); // 张三在运动
p.work(); // 张三在工作

function Student(name, age) {
Person.call(this, name, age); // 对象冒充
}

Student.prototype = new Person();
var s = new Student("李四", '20');
console.log(s.name); // 李四
s.run(); // 李四在运动
console.log(s.sex); // 男
s.work(); // 李四在工作

上面的代码中我们通过原型链继承+对象冒充的组合方式实现了继承，不过也存在缺点就是无论在什么情况下，都会调用两次构造函数：一次是在创建子类型原型的时候，另一次是在子类型构造函数的内部，子类型最终会包含父类型对象的全部实例属性，但我们不得不在调用子类构造函数时重写这些属性。

4、组合继承优化

function Person(name, age) {
// 定义参数
this.name = name;
this.age = age;
// 定义方法
this.run = function () {
console.log(this.name + "在运动");
}
}

// 通过原型链扩展属性和方法
Person.prototype.sex = "男";
Person.prototype.work = function () {
console.log(this.name + "在工作");
};
var p = new Person("张三", 18);
p.run(); // 张三在运动
p.work(); // 张三在工作

function Student(name, age) {
Person.call(this, name, age); // 对象冒充
}

/**
* 可以只继承 Person 的原型链
* 因为上面已经通过对象冒充继承了 Person 构造方法
*/
Student.prototype = Person.prototype;
var s = new Student("李四", '20');
console.log(s.name); // 李四
s.run(); // 李四在运动
console.log(s.sex); // 男
s.work(); // 李四在工作

console.log(s instanceof Student, s instanceof Person); //true true
console.log(s.constructor); //Person

这种方式通过父类原型和子类原型指向同一对象，子类可以继承到父类的公有方法当做自己的公有方法，而且不会初始化两次实例方法/属性，避免的组合继承的缺点。

但是这种方法没办法辨别是实例是子类还是父类创造的，子类和父类的构造函数指向是同一个。

5、组合继承继续优化

function Person(name, age) {
// 定义参数
this.name = name;
this.age = age;
// 定义方法
this.run = function () {
console.log(this.name + "在运动");
}
}

// 通过原型链扩展属性和方法
Person.prototype.sex = "男";
Person.prototype.work = function () {
console.log(this.name + "在工作");
};
var p = new Person("张三", 18);
p.run(); // 张三在运动
p.work(); // 张三在工作

function Student(name, age) {
Person.call(this, name, age); // 对象冒充
}

Student.prototype = Object.create(Person.prototype);
Student.prototype.constructor = Student;
var s = new Student("李四", '20');
console.log(s.name); // 李四
s.run(); // 李四在运动
console.log(s.sex); // 男
s.work(); // 李四在工作

console.log(s instanceof Student, s instanceof Person); // true true
console.log(s.constructor); // Student

在上面的代码中，我们通过借助原型可以基于已有的对象来创建对象， var B = Object.create(A)  以A对象为原型，生成了B对象。B继承了A的所有属性和方法。

同样的，Student 继承了所有的 Person 原型对象的属性和方法。目前来说，最完美的继承方法！

上面的代码我们都是基于 ES5 的特性进行的继承，在 ES6 中为我们提供了 class 类来帮助我们更快更好的实现继承。

ES6中引入了class关键字，class可以通过extends关键字实现继承，还可以通过static关键字定义类的静态方法,这比 ES5 的通过修改原型链实现继承，要清晰和方便很多。

ES5 的继承，实质是先创造子类的实例对象this，然后再将父类的方法添加到this上面（Parent.call(this)）。ES6 的继承机制完全不同，实质是先将父类实例对象的属性和方法，加到this上面（所以必须先调用super方法），然后再用子类的构造函数修改this。

需要注意的是，class关键字只是原型的语法糖，JavaScript继承仍然是基于原型实现的。

class Person {
//调用类的构造方法
constructor(name, age) {
this.name = name;
this.age = age;
}

//定义方法
run() {
console.log(this.name + "在运动");
}
}

let p = new Person('张三', 18);
console.log(p); // Person { name: '张三', age: 18 }

//定义一个子类
class Student extends Person {
constructor(name, age) {
//通过super调用父类的构造方法
super(name, age)
}

//在子类自身定义方法
work() {
console.log(this.name + "在工作");
}
}

let s = new Student('李四', 18);
console.log(s); // Student { name: '李四', age: 18 }
s.run(); // 李四在运动
s.work(); // 李四在工作

上面通过 class 关键字所创建的类的继承简单易懂，是未来 JS 的发展方向。