diff --git "a/09\351\231\210\347\203\275\346\235\260/\344\275\234\344\270\232/10.31\345\234\243\346\235\257\346\250\241\345\274\217.md" "b/09\351\231\210\347\203\275\346\235\260/\344\275\234\344\270\232/10.31\345\234\243\346\235\257\346\250\241\345\274\217.md"
new file mode 100644
index 0000000000000000000000000000000000000000..ced5c3fe3fcbb9a691548ca05a70025d2caecfa6
--- /dev/null
+++ "b/09\351\231\210\347\203\275\346\235\260/\344\275\234\344\270\232/10.31\345\234\243\346\235\257\346\250\241\345\274\217.md"
@@ -0,0 +1,84 @@
+
+
+1.  ```
+    <script>
+        //1. 
+            function Test(name,age){
+                this.name = name;
+                this.age = age;
+            }
+            obj = {
+            name:'张三',
+            age:18
+            }
+        	// 分别使用call，apply为obj添加name，age属性
+        	// Test.call(obj,'张三',18)
+        	Test.apply(obj,['张三',18])
+        	console.log(obj);
+             
+        //2.
+         function ca(car,color,disp){
+                this.car=car
+                this.color=color
+                this.disp=disp
+            }
+            
+            function Per(name,car,color,disp){
+                ca.call(this,car,color,disp)
+                this.name=name
+            }
+    
+    
+        Per.prototype.sayHi=function(){
+    
+        console.log(this.name+'买了一辆'+this.color+this.disp+this.car);            
+    
+    }
+            var cc=new Per('周','宝马','蓝色','2.0')
+    
+           cc.sayHi(); function ca(car,color,disp){
+                this.car=car
+                this.color=color
+                this.disp=disp
+            }
+            
+            function Per(name,car,color,disp){
+                ca.call(this,car,color,disp)
+                this.name=name
+            }
+    
+    
+        Per.prototype.sayHi=function(){
+    
+        console.log(this.name+'买了一辆'+this.color+this.disp+this.car);            
+    
+    }
+            var cc=new Per('周','宝马','蓝色','2.0')
+    
+           cc.sayHi();
+        
+               
+    	// 3.使用圣杯模式实现：
+    	// 父类：Shape
+    	// 子类:Circle（求圆面积）
+        	function Shape(){
+            this.pai=3.14           
+            }
+            function Circle(){}
+            
+            function inherit(Target,Origin){
+                function F(){}
+                F.prototype=Origin.prototype
+                Target.prototype=new F();
+                Target.prototype.construcotor=Origin
+    
+            }
+            inherit(Circle,Shape)
+            
+            var c=new Circle();
+            var s=new Shape();
+            Circle.prototype.r=5
+            console.log('圆的面积是'+c.r*s.pai*c.r);
+    ```
+
+    
diff --git "a/09\351\231\210\347\203\275\346\235\260/\344\275\234\344\270\232/11.01\350\277\233\351\230\266\345\234\243\346\235\257\347\273\247\346\211\277.md" "b/09\351\231\210\347\203\275\346\235\260/\344\275\234\344\270\232/11.01\350\277\233\351\230\266\345\234\243\346\235\257\347\273\247\346\211\277.md"
new file mode 100644
index 0000000000000000000000000000000000000000..14599ef41dad610f44a453fbaddd762de5b2809a
--- /dev/null
+++ "b/09\351\231\210\347\203\275\346\235\260/\344\275\234\344\270\232/11.01\350\277\233\351\230\266\345\234\243\346\235\257\347\273\247\346\211\277.md"
@@ -0,0 +1,132 @@
+
+
+​    //    function fun(n,o) {
+​    //     console.log(o);
+​    //     return{
+​    //        fun: function(m) {
+​    //             return fun(m,n)
+​    //         }
+​    //     }
+​    //    } 
+
+​    //    var a=fun(0);//undefined
+​    //    a.fun(1);//0
+​    //    a.fun(2);//0
+​    //    a.fun(3);//0
+​    //    var b=fun(0).fun(1).fun(2).fun(3);// undefined 0 1 2
+​    //    var c=fun(0).fun(1);//undefined 0
+​    //    c.fun(2);//1
+​    //    c.fun(3);//1
+
+
+// 编写一个类和类继承，类名为Person，属性name,age,方法sayHello.
+// 一个Student类，继承自Person，自有属性score,自有方法study
+
+// 请使用   原型链   构造函数继承  圣杯模式   class继承分别实现
+
+// 原型链
+// function Person(name,age) {
+//     this.name=name;
+//     this.age=age;
+// }
+
+// Person.prototype.sayHello=function()
+// {
+//     console.log("我是Person");
+// }
+// function Student(score) {
+
+//     this.score=score;
+// }
+
+// Student.prototype.study=function()
+// {
+//     console.log("我是study");
+// }
+
+// Student.prototype=new Person('猴子',18)
+// // Student.prototype=Object.create(Person.prototype)
+
+// var s=new Student(89)
+
+// console.log(s.name);
+
+// class
+// class Person {
+//     constructor(name,age)
+//      {
+//         this.name=name;
+//         this.age=age;
+//      }
+//     sayHello(){
+//     console.log("我是Person");
+//     }
+
+// }
+// class Student extends Person{
+    
+//     constructor(name,age,score)
+//      {
+//         super(name,age)
+//         this.score=score;       
+//      }
+//      study(){
+//         console.log(this.name);
+//      }
+// }
+// var p=new Person();
+// var s=new Student('猴子',18,89);
+// s.study()
+// 构造函数继承 
+// function Person(name,age) {
+//     this.name=name;
+//     this.age=age;
+//     this.sayHello=function()
+// {
+//     console.log("我是Person");
+// }
+// }
+
+// function Student(score,name,age) {
+
+//     this.score=score;
+//     Person.call(this,name,age)
+//     this.study=function()
+// {
+//     console.log("我是study"+this.name);
+// }
+// }
+// var s=new Student(89,'猴子',18)
+// s.study();
+// console.log(s.name);
+//  圣杯模式 
+function Person(name,age) {
+    this.name=name;
+    this.age=age;
+}
+Person.prototype.name ='猴子'
+Person.prototype.age=18
+Person.prototype.sayHello=function()
+{
+    console.log("我是Person");
+}
+function Student(score) {
+
+​    this.score=score;
+}
+
+function inherit(c,s) {
+    function f() {}
+    f.prototype = s.prototype
+    c.prototype = new f()
+    c.prototype.constructor= c
+    c.prototype.uber = s.prototype;
+}
+inherit(Student,Person)
+Student.prototype.study=function()
+{
+    console.log("我是study"+this.name);
+}
+var p = new Person()
+var s=new Student(89)
+s.study()
diff --git "a/09\351\231\210\347\203\275\346\235\260/\344\275\234\344\270\232/11.02this.md" "b/09\351\231\210\347\203\275\346\235\260/\344\275\234\344\270\232/11.02this.md"
new file mode 100644
index 0000000000000000000000000000000000000000..7adde4ee477ba0a67a180b813e657130fdedae8c
--- /dev/null
+++ "b/09\351\231\210\347\203\275\346\235\260/\344\275\234\344\270\232/11.02this.md"
@@ -0,0 +1,47 @@
+ // function foo(b) {
+        //     this.a = b;
+        // }
+        // var obj1 = {};
+        // var bar = foo.bind(obj1);
+        // bar(2);
+
+​        // console.log(obj1.a);//2
+​        // var baz = new bar(3);
+​        // console.log(obj1.a);//2
+​        // console.log(baz.a);//3
+
+
+​        // var name = 'window';
+​        // var obj1 = {
+​        //     name:'1',
+​        //     fn1:function (){
+​        //         console.log(this.name);//1
+​        //     },
+​        //     fn2:()=>console.log(this.name),//window
+​        //     fn3: function (){
+​        //         return function (){
+​        //             console.log(this.name);//1
+​        //         }
+​        //     },
+​        //     fn4: function(){
+​        //         return () => console.log(this.name);//window
+​        //     }
+​        // };
+​        // var obj2 = {
+​        //     name: '2'
+​        // };
+​        // obj1.fn1();//1
+​        // obj1.fn1.call(obj2);//2
+
+​        // obj1.fn2();//window
+​        // obj1.fn2.call(obj2);//window
+
+​        // obj1.fn3()();//window
+​        // obj1.fn3().call(obj2);//2
+​        // obj1.fn3.call(obj2)();//window
+
+​        // obj1.fn4()();//1
+​        // obj1.fn4().call(obj2);//1
+​        // obj1.fn4.call(obj2)();//2
+
+ 	
diff --git "a/09\351\231\210\347\203\275\346\235\260/\347\254\224\350\256\260/10.31\345\234\243\346\235\257\346\250\241\345\274\217\357\274\210\345\234\243\346\235\257\346\210\230\344\272\211\357\274\211.md" "b/09\351\231\210\347\203\275\346\235\260/\347\254\224\350\256\260/10.31\345\234\243\346\235\257\346\250\241\345\274\217\357\274\210\345\234\243\346\235\257\346\210\230\344\272\211\357\274\211.md"
new file mode 100644
index 0000000000000000000000000000000000000000..cc1578cb94931dbea5fdbe9b18c939c640236e0e
--- /dev/null
+++ "b/09\351\231\210\347\203\275\346\235\260/\347\254\224\350\256\260/10.31\345\234\243\346\235\257\346\250\241\345\274\217\357\274\210\345\234\243\346\235\257\346\210\230\344\272\211\357\274\211.md"
@@ -0,0 +1,158 @@
+# ——你就是我的Master吗？ 
+
+# vivo50领取Fate
+
+# 继承
+
+#### 一、继承的分类
+
+原型链继承
+
+构造函数继承
+
+共享原型继承
+
+圣杯模式继承
+
+#### 二、原型链继承
+
+缺点：继承过多的没用属性，子类会将父类的所有属性继承下来
+
+<script>
+    	//一个父类
+    	function Father(){  
+            this.name='张三'
+            this.age=18
+        }
+    	//一个子类
+     	function Child(){
+            this.hobby='跑步'
+            this.sex='男'
+        }
+    	//子类的原型等于父类的原型
+        Child.prototype=new Father()
+        var child=new Child()
+        console.log(child);
+
+
+
+#### 三、构造函数继承
+
+缺点：只是借用了其他函数的用法，不能使用构造函数的原型
+
+<script>
+    	//一个父类
+        function Pro(name,age,sex){
+            this.name='张三'
+            this.age=18
+            this.sex='男'
+        }
+		//一个子类
+        function Son(name,age,sex,salary){
+            //借助call
+            Pro.call(this,name,age,sex)
+            //借助apply 是以数组的形式
+            //Pro.apply(this,[name,age,sex])
+            this.salary=20000
+        }
+​        var son =new Son()
+​        console.log(son);
+
+#### 四、共享原型继承
+
+缺点:共用一个原型，子类新添加一个属性，父类也会被改变
+
+<script>
+      	//一个父类
+ 	  	function Father(){}
+        Father.prototype.name='李四'
+		//一个子类
+        function Son(){}
+		//共享的函数代码
+        function inherit(Target,Origin){
+        Target.prototype=Origin.prototype
+        }
+    	//先放子类，后放父类
+        inherit(Son,Father)
+    	//实例化两个对象
+        var son=new Son()
+        var father=new Father()
+        Father.prototype.hobby='跑步'
+        Son.prototype.sex='男'
+    	//输出的两个对象的原型相同
+        console.log(father);
+        console.log(son);
+
+#### 五、圣杯模式
+
+圣杯模式的本质在于，中间生成了一个对象，起到了隔离的作用，后面为Son.prototype添加属性时，全部都会加在这个对象里面,不会对父级产生影响。而子类向上查找是沿着__proto__查找，可以顺利查找到父级的属性，实现继承。
+
+<script>
+    	//一个父类
+ 	  	function Father(){}
+        Father.prototype.name='李四'
+		//一个子类
+        function Son(){}
+		//共享的函数代码
+        function inherit(Target,Origin){
+        //声明一个私有构造函数F
+        function F(){}
+        //私有函数先继承
+        F.prototype=Origin.prototype
+        //再来实例化Target
+        Target.prototype=new F();
+        //归位
+        Target.prototype.constructor=Target;
+        //可有可无:超类uber
+        Target.prototype.uber = Origin.prototype;
+        }
+    	//先放子类，后放父类
+        inherit(Son,Father)
+    	//实例化两个对象
+        var son=new Son()
+        var father=new Father()
+        Father.prototype.hobby='跑步'
+        Son.prototype.sex='男'
+    	//子类继承了父类的原型，但修改子类时不会影响父类
+        console.log(father);
+        console.log(son);
+
+##  Call与Apply(继承)
+
+1、call，apply都属于Function.prototype的一个方法，它是JavaScript引擎内在实现的，因为属于Function.prototype，所以每个Function对象实例(就是每个方法)都有call，apply属性。既然作为方法的属性，那它们的使用就当然是针对方法的了，这两个方法是容易混淆的，因为它们的作用一样，只是使用方式不同。
+
+2、语法：foo.call(this, arg1,arg2,arg3) == foo.apply(this, [arg1,arg2,arg3])
+
+ 区别就是apply装的是数组
+
+3、相同点：两个方法产生的作用是完全一样的。
+
+4、不同点：方法传递的参数不同。
+
+## 共享原型
+
+Teacher.prototype.gender = '男';
+Function Teacher(){}
+FUnction Student(){}
+//创建共享原型
+function inherit(Target,Origin){
+    Target.prototype = Origin.prototype;
+}
+
+//inherit(Student,Teacher)
+var son = new Son();
+//弊端：共享一个原型，你改动，我改动
+
+## 圣杯模式（圣杯战争）重点
+
+
+
+​        //  为了son继承father原型上的东西，还可以修改自己原型上的东西，对father原型不影响。
+​        function inherit(Target,Origin){ 
+​            function F (){};// 函数F作为一个中间层，上连father，下连Son，使两函数互不干扰
+​            F.prototype = Origin.prototype;
+​            Target.prototype = new F();
+​            Target.prototype.constuctor = Target;
+​            // son原型归位
+​            Target.prototype.uber = Origin.prototype;   
+​        }
diff --git "a/09\351\231\210\347\203\275\346\235\260/\347\254\224\350\256\260/11.01\350\277\233\351\230\266\345\234\243\346\235\257\347\273\247\346\211\277.md" "b/09\351\231\210\347\203\275\346\235\260/\347\254\224\350\256\260/11.01\350\277\233\351\230\266\345\234\243\346\235\257\347\273\247\346\211\277.md"
new file mode 100644
index 0000000000000000000000000000000000000000..008a376e1a533c23b21e0f572419388cd7448428
--- /dev/null
+++ "b/09\351\231\210\347\203\275\346\235\260/\347\254\224\350\256\260/11.01\350\277\233\351\230\266\345\234\243\346\235\257\347\273\247\346\211\277.md"
@@ -0,0 +1,205 @@
+1.  #### 一、进阶圣杯模式
+    
+    与圣杯模式的区别
+    
+    区别就在于进阶的圣杯模式使用一个立即执行函数将圣杯模式的代码包裹住并返回
+    
+    <script>
+        		//两个函数Person(父)、Student(子)
+    			function Person(){
+                }
+    ​            Person.prototype.name='张三'
+    ​            Person.prototype.age=18
+    ​            Person.prototype.sayHello=function(){
+    ​            }
+    ​            function Student(){
+    ​                this.score=99
+    ​            }
+    ​    		//声明一个立即执行函数，在函数里面return返回圣杯模式的代码
+    ​            var inherit=(function(){
+    ​            return  function inherit(Target,Origin){
+    ​                 function F(){}
+    ​                 F.prototype=Origin.prototype
+    ​                 Target.prototype=new F();
+    ​                //归位
+    ​        		 Target.prototype.constructor=Target 
+    ​                //可有可无:超类uber
+     		         Target.prototype.uber = Origin.prototype;
+    ​                }
+    ​			})()
+    ​            inherit(Student,Person)
+    ​            Student.prototype.study=function(){               
+    ​            console.log(this.name+'年龄为'+this.age+'的成绩是'+this.score);
+    ​               }
+    ​            Student.prototype.score=99
+    ​            var student=new Student()
+    ​            var person=new Person()
+    ​            student.study()
+    
+    #### 二、class继承
+    
+1.  ####  链式调用
+    
+    对象的连续输出
+    
+    //链式调用
+    var plan = {
+        mon: function () {
+            console.log('吃饭');
+            //return undefined
+            return this;
+        },
+        tue: function () {
+            console.log('睡觉');
+            return this;
+        },
+        wed: function () {
+            console.log('打豆豆');
+            return this;
+        },
+        thu: function () {
+            console.log('学习');
+            return this;
+        },
+        fri: function () {
+            console.log('锻炼');
+            return this;
+        },
+        sat: function () {
+            console.log('逛街');
+            return this;
+        }
+    }
+    //plan
+    	plan.mon().tue().wed().thu().fri().sat();
+    plan.mon(). 返回的是一个plan  //this  
+    指代本身
+    
+    // function GetName(){
+    //     'use strict'
+    //     this.name = '周飘'
+    //     this.age = 18        
+    // }
+    // GetName();
+    
+    #### class语法糖(super)
+    
+    能够**减少代码量、增加程序的可读性**，从而减少程序代码出错的机会。
+    
+    指的是在计算机语言中添加的某种语法，能更方便程序员使用该语言。
+    
+    1.由于class本质还是一个function 因此它就会拥有一个prototype属性，
+    
+    当new一个class时，会把class的porototype属性赋值给这个新对象的 **proto**属性。
+    
+    （prototype是函数的一个属性，它是一个指针。对于构造函数来说，prototype是作为构造函数的属性。prototype也可以是一个对象，prototype是对象实例的原型对象。所以prototype即是属性，又是对象。在new一个对象时,可以理解为一个对象没有ptototype属性，所以把ptototype给一个对象的 **proto**。
+    
+    class：语法糖 =>基于原型和原型链, 默认是在use strict 的模式下进行的
+     class Shape{
+         //构造函数 必须存在
+         constructor(){
+             this.pro = '图形';
+         }
+         
+         Draw(){
+             console.log('我是一个图形');
+         }
+     }
+    
+     //子类  必须在constructor方法中调用super方法
+     // extends 继承
+     class Circle extends Shape{
+         
+         constructor(center,r){
+             super(); //必填的
+             
+             this.r = r;
+             this.x = center[0];
+             this.y = center[1];
+         }
+         
+         //计算面积
+         getArea(){
+             return (Math.PI*this.r*this.r).toFixed(2); //保留小数几位
+         }
+         
+         //5,5
+         move(x,y){
+             this.x += x;
+             this.y += y;
+         }
+         
+         //位置输出
+         position(){
+             console.log('我的位置在'+this.x+','+this.y);
+         }
+     }
+    
+    //实例化
+     var circle =new Circle([0,0],5);
+    
+     // console.log(circle.getArea());
+     // console.log(circle.pro);
+     circle.position();
+     circle.move(5,5);
+     circle.position();
+    
+    子类有constructor 子类必须在constructor方法中调用super方法，否则new实例时会报错。
+    
+    因为子类没有自己的this对象，而是继承父类的this对象。如果不调用super函数，子类就得不到this对象。super()作为父类的构造函数，只能出现在子类的constructor()中；但是super指向父类的原型对象，可以调用父类的属性和方法。
+    
+    #### for...in 与 for...of(遍历键值对，是否为可迭代对象)
+    
+    - `for...in`语句以任意顺序迭代对象的可枚举属性
+    - `for...of`语句遍历可迭代对象定义要迭代的数据
+    
+    //for of
+     var obj ={
+         'No1' : '第一',
+         'No2' : '第二',
+         'No3' : '第三'
+     }
+    
+     //遍历键值对
+     for(let e in obj){
+         console.log(e+':'+obj[e]);
+     }
+    //输出：No1:第一  No2:第二  No3:第三
+    
+     //. [] :    .  ==>  []
+     for(let i = 1; i<=3;i++){
+         console.log(obj['No'+i]);  //obj.No1 obj.No2 obj
+     }
+    //输出：第一  第二  第三
+    
+    //遍历
+    //不是可迭代对象
+    
+    let arr = ['a', 'b', 'c']
+    Array.prototype.ufo = '张三'
+    for(let item in arr) {
+      console.log(item)
+    }
+    // 输出 0 1 2 ufo
+    
+    for(let item of arr) {
+      console.log(item)
+    }
+    // 输出 a b c
+    //通过Array.prototype添加了ufo属性，由于继承和原型链，所以arr也继承了ufo属性，属于可枚举属性，所以for...in会遍历出来，而for...of则不会。
+    
+    #### in 和 hasOwnProperty() 的用法
+    
+    var obj = {
+        name:'周飘',
+        age:18
+    }
+    obj.__proto__.gender = '女';
+            
+    console.log('name' in obj); //false true
+    console.log('gender' in obj); //true
+    console.log('title' in obj);
+    //需要找 自己本身带有的属性
+    console.log(obj.hasOwnProperty('name'));
+    //这是原型属性，不是本身自带的，所以是false
+    console.log(obj.hasOwnProperty('gender'));
diff --git "a/09\351\231\210\347\203\275\346\235\260/\347\254\224\350\256\260/11.02this.md" "b/09\351\231\210\347\203\275\346\235\260/\347\254\224\350\256\260/11.02this.md"
new file mode 100644
index 0000000000000000000000000000000000000000..20b3bcef737aa5376b59a3d5ff9da60387ba8d01
--- /dev/null
+++ "b/09\351\231\210\347\203\275\346\235\260/\347\254\224\350\256\260/11.02this.md"
@@ -0,0 +1,166 @@
+1.  ### 一，this指向
+    
+    #### 1，概念
+    
+    this的意思为“这个;当前”，**是一个指针型变量，它动态指向当前函数的运行环境**
+    
+    #### 2，指向情况
+    
+    **优先级new 显示 >隐式>默认**
+    
+    在全局范围内，this指向全局对象**（浏览器下指window对象）
+    
+    对象函数调用时，this指向当前对象
+    
+    全局函数调用时，应该是指向调用全局函数的对象
+    
+    使用new关键字实例化对象时，this指向新创建的对象
+    
+    当用apply和call上下文调用的时候指向传入的第一个参数
+    
+1.  ###  this默认绑定
+    
+    this默认绑定我们可以理解为函数调用时无任何调用前缀的情景，它无法应对我们后面要介绍的另外四种情况，所以称之为默认绑定，默认绑定时this指向全局对象（非严格模式）：在严格模式环境中，默认绑定的this指向undefined
+    
+    function fn1() {
+        let fn2 = function () {
+            console.log(this); //window
+            fn3();
+        };
+        console.log(this); //window
+        fn2();
+    };
+    
+    function fn3() {
+        console.log(this); //window
+    };
+    
+    fn1();
+    
+    ### 隐式绑定
+    
+    什么是隐式绑定呢，如果函数调用时，前面存在调用它的对象，那么this就会隐式绑定到这个对象上，看个例子：
+    
+    ```
+    function fn() {
+        console.log(this.name);
+    };
+    let obj = {
+        name: '听风是风',
+        func: fn
+    };
+    obj.func() //听风是风
+    ```
+    
+    如果函数调用前存在多个对象，this指向距离调用自己最近的对象， 即使那个对象没有那个属性
+    
+    ```
+    function fn() {
+        console.log(this.name);
+    };
+    let obj = {
+        func: fn,
+    };
+    let obj1 = {
+        name: '听风是风',
+        o: obj
+    };
+    obj1.o.func() //undefined
+    ```
+    
+    ### this显式绑定
+    
+    显式绑定是指我们通过call、apply以及bind方法改变this的行为，相比隐式绑定，我们能清楚的感知 this 指向变化过程。来看个例子：
+    
+    ```
+    let obj1 = {
+        name: '听风是风'
+    };
+    let obj2 = {
+        name: '时间跳跃'
+    };
+    let obj3 = {
+        name: 'echo'
+    }
+    var name = '行星飞行';
+    
+    function fn() {
+        console.log(this.name);
+    };
+    fn(); //行星飞行
+    fn.call(obj1); //听风是风
+    fn.apply(obj2); //时间跳跃
+    fn.bind(obj3)(); //echo
+    ```
+    
+    比如在上述代码中，我们分别通过call、apply、bind改变了函数fn的this指向。
+    
+    在js中，当我们调用一个函数时，我们习惯称之为函数调用，函数处于一个被动的状态；而call与apply让函数从被动变主动，函数能主动选择自己的上下文，所以这种写法我们又称之为函数应用。
+    
+    注意，如果在使用call之类的方法改变this指向时，指向参数提供的是null或者undefined，那么 this 将指向全局对象。
+
+    另外，在js API中部分方法也内置了显式绑定，以forEach为例：
+    
+    let obj = {
+        name: '听风是风'
+    };
+    
+    [1, 2, 3].forEach(function () {
+        console.log(this.name);//听风是风*3
+    }, obj);
+    
+    ### call、apply与bind有什么区别？
+    
+    1.call、apply与bind都用于改变this绑定，但call、apply在改变this指向的同时还会执行函数，而bind在改变this后是返回一个全新的boundFcuntion绑定函数，这也是为什么上方例子中bind后还加了一对括号 ()的原因。
+    
+    2.bind属于硬绑定，返回的 boundFunction 的 this 指向无法再次通过bind、apply或 call 修改；call与apply的绑定只适用当前调用，调用完就没了，下次要用还得再次绑。
+    
+    3.call与apply功能完全相同，唯一不同的是call方法传递函数调用形参是以散列形式，而apply方法的形参是一个数组。在传参的情况下，call的性能要高于apply，因为apply在执行时还要多一步解析数组。
+    
+    ### new绑定
+    
+    准确来说，js中的构造函数只是使用new 调用的普通函数，它并不是一个类，最终返回的对象也不是一个实例，只是为了便于理解习惯这么说罢了。
+    
+    那么new一个函数究竟发生了什么呢，大致分为三步：
+    
+    1.以构造器的prototype属性为原型，创建新对象；
+    
+    2.将this(可以理解为上句创建的新对象)和调用参数传给构造器，执行；
+    
+    3.如果构造器没有手动返回对象，则返回第一步创建的对象
+    
+    ### this绑定优先级
+    
+    this绑定优先级为：
+    
+    显式绑定 > 隐式绑定 > 默认绑定
+    
+    new绑定 > 隐式绑定 > 默认绑定
+    
+    为什么显式绑定不和new绑定比较呢？因为不存在这种绑定同时生效的情景，如果同时写这两种代码会直接抛错，所以大家只用记住上面的规律即可。
+    
+    ### 箭头函数的this
+    
+    ES6的箭头函数是另类的存在，为什么要单独说呢，这是因为箭头函数中的this不适用上面介绍的四种绑定规则。
+    
+    准确来说，箭头函数中没有this，箭头函数的this指向取决于外层作用域中的this，外层作用域或函数的this指向谁，箭头函数中的this便指向谁。有点吃软饭的嫌疑，一点都不硬朗，我们来看个例子：
+    
+    function fn() {
+        return () => {
+            console.log(this.name);
+        };
+    }
+    let obj1 = {
+        name: '听风是风'
+    };
+    let obj2 = {
+        name: '时间跳跃'
+    };
+    let bar = fn.call(obj1); // fn this指向obj1
+    bar.call(obj2); //听风是风
+    
+    为啥我们第一次绑定this并返回箭头函数后，再次改变this指向没生效呢？
+    
+    前面说了，箭头函数的this取决于外层作用域的this，fn函数执行时this指向了obj1，所以箭头函数的this也指向obj1。除此之外，箭头函数this还有一个特性，那就是一旦箭头函数的this绑定成功，也无法被再次修改，有点硬绑定的意思。
+    
+    当然，箭头函数的this也不是真的无法修改，我们知道箭头函数的this就像作用域继承一样从上层作用域找，因此我们可以修改外层函数this指向达到间接修改箭头函数this的目的。