javascript 类的封装和类的继承及原型和原型链详解

本文主要讲ES5、ES6中类的定义、封装和类的继承，以及一些注意事项，文中除了参考引用一些资料外，也加入了很多自己的理解，如有错误，欢迎读者纠正。

javascript 类的定义

ES5 中的类

在 ES5 中，其实是没有类的概念的，原因是因为 js 的作者当初在设计这门语言的时候认为，一旦像 C++和 Java 一样引入了类，js 就是一种完整的面向对象编程语言了，这好像有点太正式了，而其增加了初学者的入门难度。他当时认为，没必要将 js 设计得很复杂，这种语言只要能够完成一些简单操作就够了，比如判断用户有没有填写表单。因此，有了一些模拟定义类的方法出现。

1. 构造函数法

这个方法相信稍微有些 js 基础的人都能知道。

function People(name) {  this.name = name
}var jack = new People('jack')
People.prototype.constructor === People // truejack.constructor === People // truejack.__proto__ === People.prototype // true

但是这种方法的 protype 上的属性只能在外面定义，不够语义化，也挺麻烦。

People.prototype.species = 'human'

1. Object.create()法

为了解决上述的缺点，ES5 有了 Object.create()的方法来直接传入 prototype。

var People={
  species='human'}var jack=Object.create(People)
jack.name='jack'

显而易见，这种方法的问题是定义实例属性比较麻烦，而且也不能实现私有属性和私有方法。

1. 极简主义法

这种方法用一个对象模拟类，在对象里定义一个函数 createNew()模拟构造函数的功能，来生成实例。

var Creature = {  blood: 'red', //瞎写的，有些生物的血不是红色的:)}var People = {  species: 'human',  createNew: function(name) {    var people = {}
    people.name = name    return people
  },
}

这个方法可以既可以有私有属性和方法，而且也能比较语义化的定义实例的各种属性。但是这个方法有一个缺点，那就是在继承的时候没有用到 prototype 的概念，也就是没有用到 js 自己的原型链的概念。会让人觉得不够直观。

总而言之，ES5 没有类，哪怕是模拟实现了类，也不够完美。

ES6 中的类

ES6 提供了更接近传统语言的写法，引入了 Class（类）这个概念，作为对象的模板。通过 class 关键字，可以定义类。基本上，ES6 的 class 可以看作只是一个语法糖，它的绝大部分功能，ES5 都可以做到，新的 class 写法只是让对象原型的写法更加清晰、更像面向对象编程的语法而已。

//定义类let methodName = 'getArea'class Foo {  constructor(x, y) {    this.x = x    this.y = y
  }

  toString() {    return '(' + this.x + ', ' + this.y + ')'
  }
  [methodName]() {    return 'area_' + this.x + '_' + this.y
  }
}let foo = foo('a', 'b') //报错let foo = new Foo('a', 'b')typeof Foo // 'function'Foo === Foo.prototype.constructor // truefoo.__proto__ === Foo.prototype // truefoo.toString === Foo.prototype.toString //true

可以看到，类的所有方法都定义在类的 prototype 属性上面。在类的实例上面调用方法，其实就是调用原型上的方法。类的属性名，可以采用表达式。类的内部所有定义的方法，都是不可枚举的（non-enumerable）。这一点与 ES5 的行为不一致。类必须使用 new 调用，否则会报错。这是它跟普通构造函数的一个主要区别，后者不用 new 也可以执行。类不存在变量提升（hoist），这一点与 ES5 完全不同。

new.targer 属性

new 是从构造函数生成实例对象的命令。ES6 为 new 命令引入了一个 new.target 属性，该属性一般用在构造函数之中，返回 new 命令作用于的那个构造函数。如果构造函数不是通过 new 命令调用的，new.target 会返回 undefined，因此这个属性可以用来确定构造函数是怎么调用的。

function Person(name) {  if (new.target !== undefined) {    this.name = name
  } else {    throw new Error('必须使用 new 命令生成实例')
  }
}// 另一种写法function Person(name) {  if (new.target === Person) {    this.name = name
  } else {    throw new Error('必须使用 new 命令生成实例')
  }
}var person = new Person('张三') // 正确var notAPerson = Person.call(person, '张三') // 报错

javascript 类的继承

ES5 中类的继承

1. 构造函数绑定

使用 call 或 apply 方法，将父对象的构造函数绑定在子对象上，即在子对象构造函数中加一行：

function Animal() {  this.species = 'animal'}function Cat(name, color) {
  Animal.apply(this, arguments)  this.name = name  this.color = color
}var cat1 = new Cat('miao', 'black')

alert(cat1.species) // 动物

这样能够达到继承的目的，但是问题是，它会为所有的 Cat 实例都创建一个自己的 species 属性，这样会浪费内存，显然是不太优雅的做法

1. 继承 prototype

由于 Animal 对象中，不变的属性都可以直接写入 Animal.prototype。所以，我们也可以让 Cat()跳过 Animal()，直接继承 Animal.prototype。

function Animal() {}
Animal.prototype.species = 'animal'Cat.prototype = Animal.prototype// 因为Cat的prototype直接指向了Animal的prototype,因此它的constructor属性也发生了变化，需要手动纠正Cat的构造函数console.log(Cat.prototype.constructor === Animal) // trueCat.prototype.constructor = Catconsole.log(Animal.prototype.constructor === Cat) // truevar cat1 = new Cat('miao', 'black')

alert(cat1.species) // animal

这里出现了一个问题，由于是直接赋值的，所以 Cat 的 prototype 和 Animal 的 prototype 指向了同一个对象，在修改 Cat 的 prototype.constructor 的时候，Animal.prototype.constructor 也随之被更改。因此可以采用一个中间量过渡。

var F = function() {}
F.prototype = Animal.prototype
Cat.prototype = new F()
Cat.prototype.constructor = Catconsole.log(Cat.prototype === Animal.prototype) // false

这样，就能解决上述问题了。

ES6 中类的继承

Class 可以通过extends关键字实现继承，这比 ES5 的通过修改原型链实现继承，要清晰和方便很多。

class Foo {  constructor(x, y) {    this.x = x    this.y = y
  }  static hello(){    console.log('hello world')
  }

  toString() {    return '(' + this.x + ', ' + this.y + ')'
  }
}class ChildFoo extends Foo {  constructor(x, y, z) {    this.z=z //报错
    super(x, y); // 调用父类的constructor(x, y)
    this.z = z;
  }

  toString() {    return this.z + ' ' + super.toString(); // 调用父类的toString()
  }
}console.log(ChildFoo.hello===ChildFoo.__proto__.hello) // trueconsole.log(ChildFoo.hello===Foo.hello) // true

子类必须在constructor方法中调用super方法，否则新建实例时会报错。这是因为子类没有自己的this对象，而是继承父类的this对象，然后对其进行加工。如果不调用super方法，子类就得不到this对象。此时子类调用this对象，就会报错。
ES5 的继承，实质是先创造子类的实例对象this，然后再将父类的方法添加到this上面（Parent.apply(this)）。ES6 的继承机制完全不同，实质是先创造父类的实例对象this（所以必须先调用super方法），然后再用子类的构造函数修改this。
最后，父类的静态方法，也会被子类继承。

javascript 原型和原型链，以及prototype和proto

什么是原型？
每个javascript对象都有一个私有属性,称之为Prototype(注意这里只是一个称谓，非一个属性)，翻译过来就是原型，它被现今大多数浏览器实现为proto属性。这个proto属性，指向对象的类（构造函数）的prototype属性，这个属性也被称之为原型对象(注意和前面的原型不是一个概念)。每一个对象(null除外)在创建的时候就会从原型"继承"它所有的属性。
上述用代码表示就是：

function Person(name) {  this.name=name
}let person = new Person();// 实例化之后的对象，这个对象的原型指向它的类的原型对象console.log(person.__proto__===Person.prototype) // true

什么是原型链？
JavaScript 对象有一个指向一个原型对象的链。当试图访问一个对象的属性时，它不仅仅在该对象上搜寻，还会搜寻该对象的原型，以及该对象的原型的原型，依次层层向上搜索，直到找到一个名字匹配的属性或到达原型链的末尾。
上述用代码表示就是：

function Creature(){}
Creature.prototype.blood='red'function Person(name) {  this.name=name
}// 将Person作为Creature的子类Person.prototype=new Creature()let person = new Person();// 注意，下面是两段伪代码，实际运行后不会得到true，原因很简单，本文就不讨论了，请自行思考 :)// 沿着等号往后走，这就是一条原型链。console.log(person.blood===person.__proto__.blood=== Person.prototype.blood===Person.prototype.__proto__.blood===Creature.prototype.blood) // true// 这是一个在原型链上没有找到指定属性的例子，原型链会一直延伸到最末端console.log(person.tail===person.__proto__.tail=== Person.prototype.tail===Person.prototype.__proto__.tail===Creature.prototype.tail===Creature.prototype.__proto__.tail===Object.prototype.tail===undefined)

代码中可以看到，当访问person对象的blood属性的时候，显然本地是没有这个属性的，那么就会去寻找它的原型(即proto，也即Person.prototype)是否有这个属性，结果它的原型也没有这个属性。它的原型Person.prototype本身同样也是一个对象，那么它也有自己的原型，此时它会在自己的原型上继续寻找这个属性，也就是Person.prototype.__proto__,而Person.prototype.__proto__指向的是Creature.prototype，在Creature.prototype上找到了blood这个属性，原型链结束。

有关 prototype 的方法

使用proto是有争议的，官方也不鼓励使用它。因为它从来没有被包括在EcmaScript语言规范中，但是现代浏览器都实现了它。
不过proto属性已在ECMAScript 6语言规范中标准化，用于确保Web浏览器的兼容性，因此它未来将被支持。
但是官方依然不推荐使用它，而是推出了一系列的有关原型的方法。

Object.getPrototypeOf(object)

此方法放回给定对象的原型，注意这里的原型是指proto，而非prototype属性。

var proto = {};var obj = Object.create(proto);Object.getPrototypeOf(obj) === proto; // true

Object.setPrototypeOf(obj,prototype)

此方法可以重新设置一个对象的原型，同样，这里的原型依然指的是proto，其实就基本等同于Object.create()方法。

var proto={}var obj={}Object.setPrototypeOf(obj,proto)
obj.__proto__===proto

prototypeObj.prototype.isPrototypeOf(object)

此方法用来检查一个对象是否是另一个对象的原型，可以理解为等同于

prototypeObj.prototype===object.__proto__

私有方法/属性、静态方法/属性、公共方法/属性、实例方法/属性

经常会听到体积一些私有属性公有属性，静态属性静态方法之类的词汇，趁此机会，也对这些概念做一个系统的梳理。

私有方法/属性

指在类的内部运算使用的方法和属性，而其他人无论是通过这个类还是通过这个类的实例都无法访问。
其实很好理解为什么ES6的类没有私有属性和私有方法，因为它没有目前提供这个语法。
给一个变量赋值，无非两种方法，一种是等号，一种是声明式的，而ES6的类内部的语法很有限，并不能通过任何方法来进行一个变量赋值，等号的话不能识别，而直接声明的函数又会被解析为公有方法。
所以那些模拟的私有方法和属性也就容易理解了，其实就是要达到在类的内部能够全局使用，而脱离了这个类就无法访问的目的。

静态方法/属性

是指这个类自己的属性和方法，不会被继承，而是通过类本身来调用。比如Creature这个类，那么他的静态方法可以通过Creature.someProperty这样的方式访问到

公共方法/属性

其实就可以简单的理解为原型对象(prototype)上的方法和属性，所有的实例化的对象都是能继承到的和共享的。

实例方法/属性

就是constructor函数里this后面的一些赋值的方法和属性，是没有实例自己私有的。

作者：会飞小超人
链接：https://www.jianshu.com/p/6c35ee6d65ae