摘要：作者陳大魚頭鏈接背景最近高級前端工程師劉小夕在上開了個每個工作日布一個前端相關題的，懷著學習的心態我也參與其中，以下為我的回答，如果有不對的地方，非常歡迎各位指出。當一個函數用作構造函數時使用關鍵字，它的被綁定到正在構造的新對象。

作者：陳大魚頭
github： KRISACHAN
鏈接：github.com/YvetteLau/S…
背景：最近高級前端工程師 劉小夕 在 github 上開了個每個工作日布一個前端相關題的 repo，懷著學習的心態我也參與其中，以下為我的回答，如果有不對的地方，非常歡迎各位指出。

今天我們分享的是第一題：如何正確判斷this的指向？

<script>
    // 瀏覽器正常情況下
    console.log(this === window) // true
script>
<script>
    // 函數調用
    a = 10;
    function fn1 () {
        console.log(this.a)
    }
    fn1() // 10

    b = 2
    console.log(this.b) //2
    function fn2 () {
        this.b = 3
    }
    fn2()
    console.log(this.b) // 3
script>
<script>
    // 方法調用
    function test () {
        console.log(this.x)
    }
    x = 2
    var o = {}
    o.x = 1
    o.m = test
    o.m() // 1
script>
<script>
    // 構造函數調用
    x = 2
    function test () {
        this.x = 1
    }
    var o = new test()
    console.log(x) // 2
script>
<script>
    // apply調用
    x = 0
    function test () {
        console.log(this.x)
    }
    var o = {}
    o.x = 1
    o.m = test
    o.m.apply(o) // 1
script>
<script>
    // 函數 apply調用
    var zz = {};
    zz.a = 1000;

    a = 10;
    function fn1 () {
        console.log(this.a)
    }
    fn1.apply(zz) // 1000

    b = 2
    console.log(this.b) //2
    function fn2 () {
        this.b = 3
    }
    fn2.apply(zz)
    console.log(this.b) // 2
script>
<script>
      // 函數 apply調用
      var qqq = {
        a: 1
      }
      var ttt = {
        a: 2
      }
      var mmm = {
        a: 3
      }
      function fq () {
        console.log(this)
      }
      fq.bind(qqq).bind(ttt).bind(mmm)() // {a: 1}
script>
<script>
    // forEach
    var arr = [1, 2, 3, 4]
    var newarr = [5, 6, 7, 8]
    var newnewarr = [9, 10, 11, 12]

    arr.forEach(function (e, i, a) {
        console.log(this) // newarr
    }, newarr)

    arr.forEach((e, i, a) => {
        console.log(this) // window
    }, newarr)
script>
<script>
    // 立即執行函數
    (function () {
        console.log(this) // window
    })()

    var o = {};
    o.x = 999;

    (function () {
        console.log(this) // {x:999}
    }).apply(o)

    ;(() => {
        console.log(this) // window
    })()

    ;(() => {
        console.log(this) // window
    }).apply(o)
script>
<script>
    "use strict"
    console.log(this === window) // true
script>
<script>
    "use strict"
    var k = {
        a: 1,
        b: 2,
        c: 3
    }
    const fn1 = function () {
        console.log(this)
    }
    fn1() // undefined
    fn1.apply(k) // {a: 1, b: 2, c: 3}
    k.m = fn1
    k.m() // {a: 1, b: 2, c: 3, m: ?}
script>
<script>
    "use strict"
    const o = {
        a: 1,
        b: 2,
        c: 3
    }
    const fn2 = () => {
        console.log(this)
    }
    fn2() // window
    fn2.apply(o) // window
    o.m = fn2
    o.m() // window
script>
<script>
    "use strict"
    const oo = {
        d: function () {
            console.log(this)
        },
        e: () => {
            console.log(this)
        }
    }
    const ooo = {
        a: 1,
        b: 2,
        c: 3
    }
    oo.d() // {d: ?, e: ?}
    oo.e() // window
    oo.d.apply(ooo) // {a: 1, b: 2, c: 3}
    oo.e.apply(ooo) // window

    var xxx = oo.d
    var yyy = oo.e

    xxx() // undefined
    yyy() // window
script>
<script>
    "use strict"
    // forEach
    var arr = [1, 2, 3, 4]
    var newarr = [5, 6, 7, 8]
    var newnewarr = [9, 10, 11, 12]

    arr.forEach(function (e, i, a) {
        console.log(this) // newarr
    }, newarr)

    arr.forEach((e, i, a) => {
        console.log(this) // window
    }, newarr)
script>

上面簡單列了 window 下的幾種情況，但其實在node下的情況也類似。 其實法則總結起來就是下面幾點：

無論是否在嚴格模式下，在全局執行環境中（在任何函數體外部） this 都指向全局對象。

簡單函數調用， this 在一般模式下指向全局對象；嚴格模式下 this 默認為 ndefined 。

call , bind, apply在非箭頭函數下修改 this 值；箭頭函數下無法修改（由于 箭頭函數沒有自己的this指針，通過 call() 或 apply() 方法調用一個函數時，只能傳遞參數），不管call , bind, apply多少次，函數的 this 永遠由第一次的決定。

當函數作為對象里的方法被調用時，它們的 this 是調用該函數的對象。

如果該方法存在于一個對象的原型鏈上，那么this指向的是調用這個方法的對象，就像該方法在對象上一樣。

當一個函數用作構造函數時（使用new關鍵字），它的this被綁定到正在構造的新對象。

在ECMA內， this 會調用 原生方法 ResolveThisBinding() 原生方法ResolveThisBinding使用正在運行的執行上下文的LexicalEnvironment確定關鍵字this的綁定。 ResolveThisBinding執行以下步驟：

設置 envRec 為 GetThisEnvironment()；

返回 envRec.GetThisBinding() 。

原生方法GetThisEnvironment找到當前提供關鍵字 this 綁定的環境記錄。 GetThisEnvironment 執行以下步驟：

設置 lex 為??正在運行的執行上下文的 LexicalEnvironment 。

重復以下行為： a. 設置 envRec 為 lex 的 環境記錄； b. 設置 exists 為 envRec.HasThisBinding() c. 如果 exists 為真，返回出 envRec d.設置 outer 為 lex 的外部環境參考值。 e. 斷言： outer 不是 null f. 設置 lex 為 outer

注意：步驟2中的循環必須終止，因為列表的環境總是以全局環境這個綁定。