对象的创建
理解对象实例化的过程是理解集中对象创建方式的基础，在学习创建方式前，首先要明白在new一个对象的时候发生了什么？
参考：《你不知道的JS上卷》JS new一个对象的过程
1.创建了一个新的对象
2.这个新对象会被执行prototype连接
3.同时把构造函数作用域赋给了这个新的对象，执行构造函数
4.返回这个对象：如果此时有返回值就返回相应的返回值，如果没有返回值，会默认返回this，也就是创建的这个新对象。
用代码实现为：
function NEW(fn) {
return function() {
var o = new Object();
//o = Object.create(fn.prototype)
//o = Object.setPrototypeOf(o, fn.prototype);
o.__proto__ = fn.prototype;
fn.apply(o, arguments);
return o;
}
}
var personn = NEW(Person)('zhansan', 50);
console.log(Object.getPrototypeOf(personn))
上述代码虽然模仿的很像，但是还是有不少出入的：
其中一点，看下面代码：
function Person3() {
return {
hh: 00
};
}
var personkk = new Person3();
console.log(personkk);//{hh: 00}
上述的输出和我们自定义的输出不一样，自定义的输出会仍旧返回this对象，也就是写死在闭包函数里的o对象。有兴趣的同学可以继续研究。
工厂模式
function person(name, age) {
var o = new Object();
o.name = name;
o.age = age;
o.sayName = function() {
return this.name;
}
return o;
}
构造函数模式
function Person(name, age) {
this.name = name;
this.age = age;
//有没有效果是一样的
//return this;
}
原型模式
function Person(name, age) {
this.name = name;
this.age = age;
}
Person.prototype.sayName = function() {
return this.name;
}
动态原型模式
function Person (name, age) {
this.name = name;
this.age = age;
if(typeof this.sayName !== 'function') {
Person.prototype.sayName = function() {
return this.name;
}
}
}
寄生构造函数模式（类似工厂模式）
function Person(name, age) {
var o = new Object();
o.name = name;
o.age = age;
o.sayName = function() {
return this.name;
}
return o;
}
使用方式：
var person1 = new Person('zhangsan','12');
person1 instanceof Person //false
上述的测试案例页说明了寄生构造函数模式的局限性，但是这种模式却是实现简单工厂模式的思路。
继承
继承分为原型继承和构造函数继承。这里主要介绍原型继承。
原型继承原理
原型继承就是把父类的一个实例赋值给了子类的原型，打破了子类原型原有的逻辑。典型的例子是，字面量形式创建对象。
对于构造函数Object来说，它会有一个自己的prototype，并且这个prototype的constructor就是Object，这个prototype也需要有一个自己的原型_proto_，来实现原型链。新的原型实质上是一个普通对象，它的[[prototype]]（也就是上图的_proto_,因为这个属性是不可枚举的，所以是浅色的）其实就是Object.prototype，而它的构造函数就是Object.prototype.constructor(即Object)。
而现在，我们用这种方式来实现继承，假设有一个对象实例instance1，这个对象实例的原型有构造函数，构造函数又指向原型，整个流程是完整的。
我们把父类的实例赋值给这个实例instance1的原型。
var Parents = function(name) {this.parentName = name;}
var Children = function(name) {this.childName = name;}
Children.prototype = new Parents();
Children.prototype.age = '13';
这个时候，我们再去实现子类的实例，子类的实例会指向子类的原型。子类的原型又是父类的实例。
var child1 = new Children();
那么，在访问属性或者方法的时候，子类的实例会先搜索自己实例内部有没有相应的方法，再去搜索自己原型中是不是有对应的方法，而自己的原型此时包括了原有原型，还有父类的构造函数中的属性，还有父类的原型中的属性。
这也是原型链的本质。
原型继承中慎用字面量
根据以上描述，我们要知道：
- 子类继承了父类，我们利用了对象字面量的形式，在此之后，我们就不应该再次使用对象字面量创建任何方法和属性，因为我们会重写子类的原型，导致继承无效。
- 由于字面量赋值把一个对象的原型完全覆盖了，所以之前定义在字面量上的内容会统统失效。
字面量是一个很好的工具，它的破坏性也相当大。
但这并不是原型继承的问题。
原型继承的局限性
- 正如之前提到的，子类的实例继承了父对象，我们会发现，父对象实例中的属性会出现在子类的原型中，正如我们之前创建对象时的分析：
如果仅仅使用原型方法添加属性，会导致所有属性全局只有一份。普通属性还可以接受，但是引用类型的属性就不能接受了，比如一个数组，全局只有一份，一个改了，全都改了。
原型继承面对也是同样的问题，父类的属性出现在了子类的原型中，我们在创建子类实例的时候，子类的实例们会全局共享所有的原型属性。引用类型的属性则完全不能够私有，一个改了，所有的都变了。 - 子类无法向父类传递参数。
实例：