this的指向

看完视频后，https://www.bilibili.com/video/BV167411v7bB?p=1  的总结。

this的指向：

　　1.默认绑定，            分别对应函数的四种调用：  ----独立调用

　　2.隐式绑定，　　　　　　　　　　　　　　　　----方法调用

　　3.显示绑定，　　　　　　　　　　　　　　　　----间接调用

　　4.new绑定，　　　　　　　　　　　　　　　　 ----构造函数调用

　　5.严格模式下this的指向

　　6.隐式丢失。（*—*）　　　　　　　　

1.默认绑定（本质都是独立调用嘛）-----  独立调用(this指向window)

　　1>　　全局环境下，this指向的window

<script type="text/javascript">
   console.log(this)   //window
</script>

　　2 >　　函数被独立调用时，内部的this指向window

<script type="text/javascript">
    function fn(){
         console.log(this);
    }
    fn(); //window
</script>

　　3>　　被嵌套的函数在独立调用的时候，this指向的是window

<script type="text/javascript">
   var a = 100; 
   var obj = {
      a : 0 ,
      hello : function(){
          function fine(){
               console.log(this.a)
          }
          fine()  //独立调用
      }
   }
   obj.hello()  //100
</script>

　　4>　　自执行，被嵌套的自执行，函数中的this指向window

<script type="text/javascript">
    (function (){
           console.log(this);
     })()             //window
        
    var b=100;
    function hello(){
        var b =10;
        (function fine(){   //自执行嵌套进函数内部
            console.log(this.b);       //100
        })()
    }
    hello();
</script>

　　5>　　闭包函数的this指向window

<script type="text/javascript">
    var k=100;
    var obj = {    
         k :0,
         hello : function(){
            function fine(){
            console.log(this); //window
            return k ;    //100
                }
            return fine()
        }
    }
    console.log( obj.hello());
</script>    

2.隐式绑定  ---- 方法调用（看调用this的对象直接指向了谁,那么this就直接指向了谁）

　　1>　　作为对象的方法被调用时，指向的是对象

<script type="text/javascript">
　　var a = 100;
　　function hello(){
　　　　console.log(this.a);
　　}
　　var obj = {
　　　　a :0,
　　　　fine:hello,
　　}
　　obj.fine(); //0
</script>

　　具体看清楚到底是谁在调用

<script type="text/javascript">
     var a = 100;
     function hello(){
        console.log(this.a);
     }
     var obj = {
        a :0,
        fine:hello,    
        obj2:{
           a:200,
           fine:hello
         }
     }
      obj.fine();   //0
      obj.obj2.fine(); //200
</script>

3.显示绑定  ------  间接调用

　　1>　　通过call() ,     apply(),   bind()  把对象绑定到this上

<script type="text/javascript">
    var a = 100;
    function hello(){
        console.log(this.a)
    }
    var obj ={
        a:0
    }
    hello(); //100 
        hello.call(obj);  //0
    hello.apply(obj); //0
       var fn = hello.bind(obj);
       fn();  //0
</script>

　　2>　　硬绑定 ，this不能再被改变了

<script type="text/javascript">
    var a = 100;
    function hello(){
        console.log(this.a)
    }
    var obj ={
        a:0
    }
    var bar = function(){
        hello.call(obj) //硬绑定到obj
    }
    bar(); // 0
    bar.call(window);  //0 ,不会被改变
</script>

　　看懂了上面，再来看 call() ,     apply(),   bind()   的具体用法：https://www.runoob.com/w3cnote/js-call-apply-bind.html

　　https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Function/apply

       apply（）一个很强大的功能——能将一个数组默认转化为参数列表！！！

　　再来思考一下：

　　https://www.nowcoder.com/questionTerminal/d47b482e7148497582c7a995df51f393?f=discussion

　　其中：Array.prototype.slice()：

　　https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Array/slice

　　3>　　js中很多内置函数也有显示绑定的作用

4.new绑定   -------构造函数调用　　

　　1>　　new实例化

<script type="text/javascript">
    function fn(){
        console.log(this);
    }
    fn();      //window
    var mynew = new fn();   
    console.log(mynew);       //fn , 用new来执行函数，this指向的是当前实例化的对象即fn
</script>

<script type="text/javascript">
    var person = {   
        fav : function (){return this;} 
    }
    console.log(person.fav());   //打印的是person对象 
    var   p = new person.fav(); 
     console.log(p);//打印的是fav对象,因为实例化的是fav,this指向实例化的对象
</script>

　　2>　　return的对象也是实例化的对象

5.严格模式下this的指向

　　1>　　严格模式下，独立调用的函数内部的this指向了undefined。

　　2>　　严格模式下，函数apply() 和 call()内部的this始终指向它们的第一个参数。

6.隐式丢失  *—*

　　被隐式绑定的函数丢失了绑定对象后，this默认绑定到window

　　1>　　函数别名

<script type="text/javascript">
    var a = 100;
    function fine(){
        console.log(this.a);
    }
    var obj = {
        a:0,
        hello:fine
    }
    obj.hello();   //0
    var bar =obj.hello; // bar被赋值为obj.hello。bar和obj毫无关系,this隐式丢失
    bar(); //100 ,隐式丢失,默认this指向的是window
</script>

　　2>　　参数传递

<script type="text/javascript">
        var a = 100;
    function hello(){
        console.log(this.a); 
    }
    function bar (fn){ 
        fn();
    }
    var obj = {
        a:0,
        fine:hello
    }
    obj.fine();  //0 , 是一个对象的方法
    bar(obj.fine);//100  把obj.fine作为参数传递，obj和bar毫无关系,this丢失了它的绑定对象，指向window
</script>        

　　3>　　内置函数

　　( setTimeout() 和 setInterval() 等函数，它们的第一个参数的回调函数中的this默认指向的是window )

<script type="text/javascript">
    var a =100;
    function hello(){
        console.log(this.a);
    }
    var obj = {
        a:0,
        fine:hello
    }
    setTimeout(obj.fine,1000); //100
</script>

　　4>　　间接调用

<script type="text/javascript">
    var a =100;
    function hello(){
        console.log(this.a);
    }
    var obj = {
        a:0,
        fine:hello
    }
    var p ={a:7};
    obj.fine();  //0
    (p.fine = obj.fine) (); // 100  立即执行,obj.fine赋值给了p的fine函数,立即执行,this指向了window.
    p.fine(); //7 , 间接调用,this指向的是调用它的对象
</script>

总原则：在非严格模式下，如果函数没有通过构造函数调用，直接作为普通函数使用，this指向window，在严格模式下，this指向undefined。

改变this的指向：

1>隐式绑定，调用this的对象直接指向了谁，this就指向谁。

2>显示绑定，apply,call,bind.

3>new实例化对象，this指向的是当前实例化的对象。