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); // 180console.log(jack.height); // undefinedconsole.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; // prototype 里的 this 指向调用原型方法的谁人对象。 } return sum;};console.log([2, 3, 4].sum()); // 95. 继续
- 构造函数继续：只能继续构造函数里的属性和方法
着实就是在子构造函数内里调用父构造函数（须要修改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); // Jackjack.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__属性为protoStudent.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); // functionconsole.log(Person.prototype); // {constructor: ƒ, say: ƒ}console.log(jack.__proto__ === Person.prototype); // trueconsole.log(jack.constructor); // class Person{ ... }console.log(Person.prototype.constructor); // class Person{ ... }说白了，ES6 的类就是ES5继续的语法糖。
参考资料：
传智教导 - JavaScript进阶面向对象ES6 |
