关于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
        //因而当前的挪用位置在bar中
        console.log('foo');
    }
    baz(); //<-baz的挪用位置

把挪用栈设想成一个函数挪用链，如上图代码中的款式，然则这类要领异常贫苦而且轻易失足。另一个检察挪用栈的要领是运用浏览器的调试东西。

绑定划定规矩

起首须要找到挪用位置，然后推断追求以下四条划定规矩中的哪一条。

1 默许绑定

起首引见最经常使用的函数挪用范例：自力函数挪用。能够把这条划定规矩看做是没法运用其他划定规矩时的默许划定规矩。

function foo() {
        console.log(this.a); //<-this指向全局作用域
    }
    var a = 2;
    foo(); //<-foo挪用位置

在代码中，foo()是直接运用不带任何润饰的函数援用举行挪用的，因而只能运用默许绑定，没法运用其他划定规矩。

function foz() {
        "use strict";
        console.log(this.a); //<--严厉形式下不能将全局对象用于绑定

    }
    foz(); //TypeError

2 隐蔽绑定

另一条须要斟酌的划定规矩是挪用位置是不是有上下文对象，或许说是不是被某个对象具有或许包括，这类说法有时候会有误导。

function foa() {
        console.log(this.a);
    }
    var foaObj = {
        a: "Hello",
        foa: foa //<--foa函数挪用位置
    }
    foaObj.foa();

foa函数在严厉意义上来讲不属于foaObj对象。但是，挪用位置会运用foaObj上下文来援用函数，因而能够推断为函数挪用时，foaObj对象包括并援用它。

当函数援用有上下文对象时，隐式绑定划定规矩会把函数挪用中的this绑定到这个上下文对象。因而，挪用foa函数时this被绑定到foaObj这个对象上，所以this.a 和 foaObj.a 是一样的。

但是，有一个罕见的this绑定题目就是被隐式绑定的函数会丧失绑定对象，也就是说它会运用默许绑定，从而把this绑定到全局对象或undefined上。

function fob() {
        console.log(this.a);
    }
    var fobObj = {
        a: "Hello",
        fob: fob
    }
    var focObj = fobObj.fob;
    var a = 1; //a是全局对象的属性
    focObj();

focObj援用实际上是fob函数，所以this绑定的是全局对象中的a。

3 显式绑定

就像我们适才看到的那样，在剖析隐式绑定时，我们必须在一个对象内部包括一个指向函数的属性，并经由过程这个属性间接援用函数，从而把this间接绑定到这个对象上。

JavaScript供应的绝大多数函数以及你本身建立的一切函数都能够运用call(…) 和 apply (…) 要领。

这两个要领的第一参数是一个对象，是给this预备的，接着在挪用函数时将其绑定到this。由于你能够直接指定this的绑定对象，因而我们称之为显式绑定。

function fod() {
        console.log(this.a);
    }
    var fodObj = {
        a: 2
    }
    fod.call(fodObj); //2

经由过程fod.call(…)要领，能够强迫把this绑定到fodObj这个对象上。

但是，显现绑定依然没法处理之前提出的丧失绑定题目。

然则显现绑定的一个变种能够处理这个题目。

 function foh() {
        console.log(this.a);
    }
    var fohObj = {
        a: 2
    }
    var baa = function() {
        foh.call(fohObj);
    }
    baa(); //2
    setTimeout(baa, 100); //2
    baa.call(window); //2

我们建立了一个baa函数，并在它的内部手动挪用了foh.call(fohObj)，因而强迫把foh的this绑定到了fohObj上。不管以后怎样挪用函数baa，它总会手动在fohObj上挪用foh。这类绑定是一种显现的强迫绑定，因而我们称之为硬绑定。

硬绑定的典范运用场景就是建立一个包裹函数，担任吸收参数并返回值。

function foi(something) {
        console.log(this.a, something);
        return this.a + something;
    }
    var foiObj = {
        a: 2
    }
    var bae = function() {
        return foi.apply(foiObj, arguments);
    }
    var b = bae(3);
    console.log(b);

另一种运用要领是建立一个能够重复运用的辅佐函数。

function fol(something) {
        console.log(this.a, something);
        return this.a + something;
    }

    function bind(fn, obj) {
        return function() {
            return fn.apply(obj, arguments);
        }
    }
    var folObj = {
        a: 3
    }
    var bac = bind(fol, folObj);
    var c = bac(4);
    console.log(c);

4 new绑定

运用new来挪用函数，或许说发作组织函数挪用时，会自动实行下面的操纵。

1) 建立（或许说组织）一个全新的对象。
2) 这个新对象会被实行Prototype衔接。
3) 这个新对象会绑定到函数挪用的this。
4) 假如函数没有返回其他对象，那末new表达式中的函数挪用会自动返回这个新对象。

function abc(a) {
        this.a = a;
    }
    var x = new abc(10);
    console.log(x.a);