原型/原型链，继承，事件流，闭包，

1.原型/原型链

一、什么是原型：
任何对象都有一个原型对象，这个原型对象由对象的内置属性_proto_指向它的构造函数的prototype指向的对象，即任何对象都是由一个构造函数创建的，但是不是每一个对象都有prototype，只有方法才有prototype。

function Person() {
}
var p = new Person();
//方法才有prototype,普通对象无prototype
console.log(Person.prototype); // Object{} 
console.log(p.prototype); // undifined

//任何对象都是有构造函数的,Person这种方法的构造函数是Function。
//备注:constructor很容易被改变，一般不用它，此处只是打印下列对象的构造函数是什么。
console.log(p.constructor); //function Person(){}  
console.log(Person.constructor); //function Function(){} 
console.log({}.constructor); // function Object(){}
console.log(Object.constructor); // function Function() {}
console.log([].constructor);  //function Array(){} 
那什么是构造函数呢？

用function声明的都是函数，而如果直接调用的话，那么Person()就是一个普通函数，只有用函数new产生对象时，这个函数才是new出来对象的构造函数。

三、原型链

1）什么是原型链？

原型链的核心就是依赖对象的_proto_的指向，当自身不存在的属性时，就一层层的扒出创建对象的构造函数，直至到Object时，就没有_proto_指向了。

2）如何分析原型链?

因为_proto_实质找的是prototype，所以我们只要找这个链条上的构造函数的prototype。其中Object.prototype是没有_proto_属性的，它==null。

3.1、最简单的原型链分析

function Person(name){
        this.name = name;
 }
 var p = new Person();
 //p ---> Person.prototype --->Object.prototype---->null
 属性搜索原则：
 1.当访问一个对象的成员的时候，会现在自身找有没有,如果找到直接使用。
 2.如果没有找到，则去原型链指向的对象的构造函数的prototype中找，找到直接使用，没找到就返回undifined或报错。

2.继承
　想要继承，就必须要提供个父类（继承谁，提供继承的属性）

一、原型链继承

重点：让新实例的原型等于父类的实例。

特点：1、实例可继承的属性有：实例的构造函数的属性，父类构造函数属性，父类原型的属性。（新实例不会继承父类实例的属性！）

缺点：1、新实例无法向父类构造函数传参。

2、继承单一。

3、所有新实例都会共享父类实例的属性。（原型上的属性是共享的，一个实例修改了原型属性，另一个实例的原型属性也会被修改！）

二、借用构造函数继承

重点：用.call()和.apply()将父类构造函数引入子类函数（在子类函数中做了父类函数的自执行（复制））

特点：1、只继承了父类构造函数的属性，没有继承父类原型的属性。

2、解决了原型链继承缺点1、2、3。

3、可以继承多个构造函数属性（call多个）。

4、在子实例中可向父实例传参。

缺点：1、只能继承父类构造函数的属性。

2、无法实现构造函数的复用。（每次用每次都要重新调用）

3、每个新实例都有父类构造函数的副本，臃肿。

三、组合继承（组合原型链继承和借用构造函数继承）（常用）

重点：结合了两种模式的优点，传参和复用

特点：1、可以继承父类原型上的属性，可以传参，可复用。

2、每个新实例引入的构造函数属性是私有的。

缺点：调用了两次父类构造函数（耗内存），子类的构造函数会代替原型上的那个父类构造函数。

四、原型式继承

重点：用一个函数包装一个对象，然后返回这个函数的调用，这个函数就变成了个可以随意增添属性的实例或对象。object.create()就是这个原理。

特点：类似于复制一个对象，用函数来包装。

缺点：1、所有实例都会继承原型上的属性。

2、无法实现复用。（新实例属性都是后面添加的）

五、寄生式继承

重点：就是给原型式继承外面套了个壳子。

优点：没有创建自定义类型，因为只是套了个壳子返回对象（这个），这个函数顺理成章就成了创建的新对象。

缺点：没用到原型，无法复用。

六、寄生组合式继承（常用）

寄生：在函数内返回对象然后调用

组合：1、函数的原型等于另一个实例。2、在函数中用apply或者call引入另一个构造函数，可传参

重点：修复了组合继承的问题

–	–

3.事件流/事件机制

一、JavaScript事件流

js是一门基于对象和事件驱动的具有安全性的客户端脚本语言。

事件是连接JavaScript和DOM的桥梁，为js提供交互行为提供方式；事件绑定于DOM对象上，可用于用户触发而执行相对应的处理程序。

事件流包括三个阶段，分别是捕获阶段，目标阶段，冒泡阶段。

在阐述时间流的三个阶段之前，我们先了解一下js对象的事件监听。

所谓事件监听，即使为DOM绑定相对应触发事件；

绑定事件监听的三种方法分别为：

1.element.addEventListener(type,function,useCapture);//useCapture为ture，事件句柄在捕获阶段执行，反之在冒泡阶段执行；Mozilla中；
2.element.attachEvent(“on”+type,function)；//IE中
element.on+type=function(){};

3.element.addEventListener(type,function,useCapture);//useCapture为ture，事件句柄在捕获阶段执行，反之在冒泡阶段执行；Mozilla中；
element.attachEvent(“on”+type,function)；//IE中
element.on+type=function(){};
绑定事件之后，当用户触发到某元素的事件之时，则会从document开始一级一级的向下查找到对应的元素，该阶段为捕获阶段；到达目标之后则为目标阶段；触发目标的处理程序之后，则从目标一级一级的向上直到document，该阶段为冒泡阶段。

如今一般都是使用冒泡事件流来进行事件的处理；

事件冒泡的作用主要是允许多个操作被集中处理，例如一个列表的每一个字段点击都会出现相应的处理反应，则可以直接为所有字段的上一级元素绑定处理程序；

但是有些程序相反需要取消冒泡机制带来的弊端，此时可以使用阻止事件冒泡的方法，evet.stopPropagation();

<2017-09-11增添>

js事件机制包括：事件绑定、事件监听、事件委托。

1）事件绑定：

方式：

1.DOM元素上直接绑定

1

2.js中绑定

2）事件监听

方法：addEventListener、attachEvent

W3C规范：

element.addEventListener(event, function, useCapture);

event:事件名；

function:回调函数；

useCapture:指定阶段（捕获或冒泡）；ture：捕获；false：冒泡；默认：false；

IE规范：

element.attachEvent（event，function）；

冒泡阶段执行

3）事件委托

原理：利用冒泡，在所有需要绑定相同事件的子元素的父元素上绑定对应事件。

优点：提高性能，减少事件的注册；动态添加的元素依旧绑定对应事件。

–	–

4.闭包

闭包
函数会形成私有作用域，保护里面的变量不受外界的污染，但函数可访问它上一级作用域的变量，从而外界可通过闭包的方式拿到函数里的变量，如：
函数A返回函数B，函数B引用了函数A的变量，函数B就称为闭包
闭包应用在ajax请求成功回调，事件绑定回调方法等
题目
for ( var i=1; i<=5; i++) {
setTimeout( function timer() {
console.log( i );
}, i*1000 );
}

首先因为 setTimeout 是个异步函数，所有会先把循环全部执行完毕，这时候 i 就是 6 了，根据定时器，每隔1s输出1个6，所以每会输出5个 6。

//闭包解决
for (var i = 1; i <= 5; i++) {
(function(j) {
setTimeout(function timer() {
console.log(j);
}, j * 1000);
})(i);
}