在《你不知道的this》中我们排除了关于this的毛病邃晓，而且邃晓了每一个函数的this是在挪用时绑定的，完整取决于函数的挪用位置。在本节中我们主要引见一下几个主要内容：

1. 什么是挪用位置

2. 绑定划定规矩

3. this词法

挪用位置

挪用位置：就是函数在代码中被挪用的位置(而不是声明位置)。要想回复this究竟援用的是什么？只要仔细剖析挪用位置才回复这个题目。
而剖析挪用位置最主要的就是剖析挪用栈。下面是挪用栈的定义。
挪用栈：就是为了抵达当前实行位置所挪用的一切函数。

    function baz(){
         //当前挪用栈是：baz
         //因而，当前挪用位置是全局作用域
         console.log("baz");
         bar(); //bar的挪用位置
    }
    function bar(){
         //当前挪用栈是：baz -> bar
         //因而，当前挪用位置是在baz中
         console.log("bar");
         foo(); //foo的挪用位置
    }
    function foo(){
         //当前挪用栈是：baz -> bar -> foo
         //因而，当前挪用位置是在baz中
         console.log("foo");
    }
    baz(); // baz的挪用位置

绑定划定规矩

我们的思绪是，经由过程找到函数的挪用位置，然后推断须要应用划定规矩中的哪一条。便可决议this的绑定对象。关于this的绑定划定规矩主要是以下四种：

1. 默许绑定

2. 隐式绑定

3. 显式绑定

4. new绑定

1.默许绑定

默许绑定的典范范例是：自力函数挪用。 思索以下代码：

    function foo(){
             console.log(this.a);
    }
    var a = 2;
    foo(); // 2

挪用foo()时，函数应用了默许绑定，this只想全局对象window(这是在非严厉情势下，如果在严厉情势下会报错)，所以this.a被剖析成了全局变量a。所以，在不应用任何润饰的函数援用举行挪用，只能应用默许绑定，没法应用其他划定规矩。

2.隐式绑定

隐式绑定的罕见情势是在挪用位置具有上下文对象，或许说被某个对象具有或许包括。看以下代码：

     function foo(){
        console.log(this.a);
     }
     var obj = {
          a: 2,
          foo: foo
     };
     obj.foo(); // 2

这里函数foo()是预先定义好的，然后再将其添加为obj对象的援用属性。挪用位置应用obj上下文来援用函数，因而能够说函数被挪用时obj对象“具有”或许“包括”它。
不管你怎样称谓这个情势，当foo()被挪用时，它的前面确实是加上了obj的援用。当函数援用上下文对象时，隐式绑定划定规矩就会把函数挪用中的this绑定到这个上下文对象。所以，this.a和obj.a是一样的。

另一个须要注重的点是：对象属性援用链中只要末了一层在挪用位置起作用

    function foo(){
         console.log(this.a);
    }
    var obj2 = {
         a: 100,
         foo: foo
    };
    var obj1 = {
         a: 1,
         obj2: obj2
    }
    obj1.obj2.foo(); // 100

隐式绑定一个最罕见的题目

一个最罕见的题目就是：隐式绑定的函数会丧失绑定对象。也就是是说它会应用默许绑定，而把this绑定到全局对象或许undifined上，取决于是不是是严厉情势。

    function foo(){
        console.log(this.a);
    }
    var obj ={
        a: 2,
        foo: foo
    }
    var bar = obj.foo; //函数别号
    var a = "global";
    bar(); // "global"

虽然bar是obj.foo的一个援用，但实际上，他援用的是foo函数自身， 因而， 此时的bar()实际上是一个不带任何润饰的函数挪用，因而，它应用了默许绑定。
一种更玄妙，更罕见的而且更出人预料的状况发作在传入回调函数时：

    function foo(){
        console.log(this.a);
    }
    function callBack(fn){
        fn();
    }

    var obj = {
        a: 2,
        foo: foo
    }
    var a = "global";
    callBack(obj.foo); // "global"

参数通报实在就是一种隐式赋值，这句话我们能够用下面的两段代码来细致的解说：

    var a = 1;
    function fn(){
        alert(a); //1
        a = 2;
    }
    fn();
    alert(a); // 2

_ _ _

    var a = 1;
    function fn(a){
          alert(a); //undifined
          a = 2;
    }
    fn();
    alert(a); // 1

思索一下效果是不是与你设想的一致呢？
在第一段代码中：
起首，在全局作用域中，先经由过程变量提拔，找到了标识符a和函数fn，a此时有个默许值为undifined。然后，在实行阶段我们先将变量a赋值为1，紧跟着函数fn()实行。此时，在函数域中，照旧应用变量提拔的划定规矩，然则什么都没找到，接着实行函数内的代码:alert(a),因为在函数中并没有找到变量a。所以，经由过程作用域链向上层的父级作用域中查找，我们找到了a,而且此时a的值已被赋值为1，所以，alert(a)这句的效果就是1。下一句代码：a = 2,注重a的前面没有关键字var, 即这里的a是全局的，也就是说在实行这句代码时，他修正了全局作用域中a的值，即a现在为2。末了在实行alert(a)时，自然而然a的值就是2了。

在第二段代码中：
一样，经由过程变量提拔，我们找到了标识符a和函数fn，a此时的默许值也为undifined。最先实行，a起首被赋值为1。然后，函数实行，这里与第一段代码的不同之处在于，在函数fn中传入了参数a,那末这么做的效果就是：在函数域先应用变量提拔的划定规矩，不会像第一段代码中那样什么都找不到，而是相当于定义了一个值为undifined（挪用的时刻没有传入参数）的变量a,所以当实行函数域中的alert(a)时，效果就为undifined，而不会经由过程作用域链向上去查找，因为本函数中已找到了，只不过是以参数的情势传入的。同理代码(a = 2)会修正a的值，即在函数域中，a的值现在为2（读者能够去尝试在函数中末了面alert一下a的值）。而在函数外实行alert(a),我们获得的效果就是1，因为该句代码是在全局中实行的，即会在全局中去查找变量a,而不会去接见函数域中的a。这也是因为，在JavaSceipt中子作用域能够接见父作用域而反过来却不可的划定规矩。

回到我们this绑定丧失的话题上，说了这么多，我实在就是想说：参数通报实在就是一种隐式赋值，参数通报实在就是一种隐式赋值，参数通报实在就是一种隐式赋值，主要的事说三遍！
我们根据上面的体式格局来剖析代码：在实行callBack(obj.foo)时，在函数作用域经由过程变量提拔找到了参数fn,它的默许值为undifined，然后我们将参数传入，实在相当于(var fn = obj.foo),这就与前面的将其直接赋值给一个变量对等上了，然后再实行fn()，应用默许绑定，此时的this已不指向obj了，而是指向window(严厉情势)。

如果把函数传入内置的函数而不是传入你本身声明的函数，会发作什么呢？效果是一样的，没有区分：

    function foo(){
        console.log(this.a)
    }
    var obj = {
        a: 2,
        foo: foo
    }
    var a = "global";
    setTimeout(obj.foo, 1000); //"global"

JavaSceipt环境中内置的setTimeout()函数完成和下面的伪代码相似：

    function setTimeout(fn, delay){
        //守候delay秒
        fn(); //挪用位置
    }

就向你们看到的那样，回调函数丧失this绑定的状况黑白常罕见的，而且另有一种状况this的行动会出乎我们预料：挪用回调函数的函数可能会修正this。因为没法掌握回调函数的实行体式格局，因而就没有办法掌握挪用位置获得希冀的绑定，下一节我们会引见怎样经由过程牢固this来“修复“这个题目。