js基礎梳理-如何理解作用域和作用域鏈？

煉心發表於2018-12-09
JS

本文重點是要梳理執行上下文的生命週期中的建立作用域鏈，在此之前，先回顧下關於作用域的一些知識。

1.什麼是作用域(scope)？

在《JavaScritp高階程式設計》中並沒有找到確切的關於作用域的定義，只是在“4.2執行環境及作用域”中簡單說了下執行環境（execution context）的概念。而執行環境其實就是之前部落格：js基礎梳理-究竟什麼是執行上下文棧（執行棧），執行上下文(可執行程式碼）？中的執行上下文。

而在《JavaScript權威指南》中，對作用域的描述為：

變數作用域：一個變數的作用域（scope）是程式原始碼中定義這個變數的區域

在《你不知道的Javascript·上卷》中對作用域的描述則為：

負責收集並維護由所有生命的識別符號（變數）組成的一系列查詢，並實施一套非常嚴格的規則，確定當前執行的程式碼對這些識別符號的訪問許可權。

簡單來講，作用域（scope）就是變數訪問規則的有效範圍。

  • 作用域外，無法引用作用域內的變數；
  • 離開作用域後，作用域的變數的記憶體空間會被清除，比如執行完函式或者關閉瀏覽器
  • 作用域與執行上下文是完全不同的兩個概念。我曾經也混淆過他們，但是一定要仔細區分。

JavaScript程式碼的整個執行過程，分為兩個階段，程式碼編譯階段與程式碼執行階段。編譯階段由編譯器完成，將程式碼翻譯成可執行程式碼，這個階段作用域規則會確定。執行階段由引擎完成，主要任務是執行可執行程式碼，執行上下文在這個階段建立。

說得很深奧的樣子，其實上面這段話重點用函式作用域與函式執行上下文來區分是最好不過的了。函式作用域是在函式宣告的時候就已經確定了，而函式執行上下文是在函式呼叫時建立的。假如一個函式被呼叫多次，那麼它就會建立多個函式執行上下文，但是函式作用域顯然不會跟著函式被呼叫的次數而發生什麼變化。

1.1 全域性作用域

var foo = `foo`;
console.log(window.foo);   // => `foo`

在瀏覽器環境中宣告變數，該變數會預設成為window物件下的屬性。

function foo() {
    name = "bar"
}
foo();
console.log(window.name) // bar

在函式中，如果不加 var 宣告一個變數，那麼這個變數會預設被宣告為全域性變數，如果是嚴格模式，則會報錯。

全域性變數會造成命名汙染，如果在多處對同一個全域性變數進行操作，那麼久會覆蓋全域性變數的定義。同時全域性變數數量過多，非常不方便管理。

這也是為什麼jquery要在全域性建立變數 $，其餘私有方法屬性掛在 $ 下的原因。

1.2 函式作用域

假如在函式中定義一個區域性變數，那麼該變數只可以在該函式作用域中被訪問。

function doSomething () {
    var thing = `吃早餐`;
}
console.log(thing); // Uncaught ReferenceError: thing is not defined

巢狀函式作用域：

function outer () {
    var thing = `吃早餐`;
    function inner () {
        console.log(thing);
    }
    inner();
}

outer();  // 吃早餐

在外層函式中，巢狀一個內層函式，那麼這個內層函式可以向上訪問到外層函式中的變數。

既然內層函式可以訪問到外層函式的變數，那如果把內層函式return出來會怎樣？

function outer () {
    var thing = `吃早餐`;
    
    function inner () {
        console.log(thing);
    }
    
    return inner;
}

var foo = outer();
foo();  // 吃早餐

前面提到，函式執行完後，函式作用域的變數就會被垃圾回收。而這段程式碼看出當返回了一個訪問了外部函式變數的內部函式，最後外部函式的變數得以儲存。

這種當變數存在的函式已經執行結束，但扔可以再次被訪問到的方式就是“閉包”。後期會繼續對閉包進行梳理。

1.3 塊級作用域

很多書上都有一句話，javascript沒有塊級作用域的概念。所謂塊級作用域，就是{}包裹的區域。但是在ES6出來以後，這句話並不那麼正確了。因為可以用 let 或者 const 宣告一個塊級作用域的變數或常量。

比如：

for (let i = 0; i < 10; i++) {
    // ...
}
console.log(i); // Uncaught ReferenceError: i is not defined

發現這個例子就會和函式作用域中的第一個例子一樣的錯誤提示。因為變數i只可以在 for迴圈的{ }塊級作用域中被訪問了。

擴散思考：

究竟什麼時候該用let？什麼時候該用const？

預設使用 const，只有當確實需要改變變數的值的時候才使用let。因為大部分的變數的值在初始化之後不應再改變，而預料之外的變數的修改是很多bug的源頭。

1.4 詞法作用域

詞法作用域，也可以叫做靜態作用域。意思是無論函式在哪裡呼叫，詞法作用域都只在由函式被宣告時所處的位置決定。
既然有靜態作用域，那麼也有動態作用域。
而動態作用域的作用域則是由函式被呼叫時執行的位置所決定。

var a = 123;
function fn1 () {
    console.log(a);
}
function fn2 () {
    var a = 456;
    fn1();
}
fn2();   // 123

以上程式碼，最後輸出結果 a 的值，來自於 fn1 宣告時所在位置訪問到的 a 值 123。
所以JS的作用域是靜態作用域，也叫詞法作用域。

上面的1.1-1.3可以看做作用域的型別。而這一小節，其實跟上面三小節還是有差別的，並不屬於作用域的型別，只是關於作用域的一個補充說明吧。

2. 什麼是作用域鏈（scope chain）

在JS引擎中，通過識別符號查詢識別符號的值，會從當前作用域向上查詢，直到作用域找到第一個匹配的識別符號位置。就是JS的作用域鏈。

var a = 1;
function fn1 () {
    var a = 2;
    function fn2 () {
        var a = 3;
        console.log(a);
    }
    fn2 ();
}
fn1(); // 3

console.log(a) 語句中，JS在查詢 a變數識別符號的值的時候，會從 fn2 內部向外部函式查詢變數宣告，它發現fn2內部就已經有了a變數，那麼它就不會繼續查詢了。那麼最終結果也就會列印3了。

3. 作用域鏈與執行上下文

在此前的部落格：js基礎梳理-究竟什麼是執行上下文棧（執行棧），執行上下文(可執行程式碼）？中講到執行上下文的生命週期:

3.執行上下文的生命週期

3.1 建立階段

  • 生成變數物件（Variable object, VO）
  • 建立作用域鏈（Scope chain）
  • 確定this指向

3.2 執行階段

  • 變數賦值
  • 函式引用
  • 執行其他程式碼

上面做了那麼多鋪墊，其實重點是想梳理這一小節。
下面，以一個函式的建立和啟用兩個時期來講解作用域鏈是如何建立及變化的。

3.1函式建立階段

上文中講到，函式的作用域在函式定義的時候就決定了。

這是因為函式有一個內部屬性[[scope]]，當函式建立的時候，就會儲存所有父變數物件到其中，但是注意：此時[[scope]]並不代表完整的作用域鏈，因為在建立階段，它還沒有包括自己的作用域。

舉個例子：

function foo () {
    function bar () {
        ...
    }
}

函式建立時，各自的[[scope]]為：

foo.[[scope]] = [
    globalContext.VO
];

bar.[[scope]] = [
    fooContext.AO,
    globalContext.AO
];

3.2 函式啟用階段

當函式啟用時，進入函式上下文，建立VO/AO後，就會將活動物件新增到作用域鏈的前端。

這時候執行上下文的作用域鏈，命名為 Scope:

Scope = [AO].concat([[scope]]);

至此，作用域鏈建立完畢。

3.3 舉個例子

以下面的例子為例，結合之前的變數物件，活動物件和執行上下文棧，總結一下函式執行上下文中作用域鏈和變數物件的建立過程：

var x = 10;
 
function foo() {
  var y = 20;
 
  function bar() {
    var z = 30;
    console.log(x +  y + z);
  }
 
  bar();
}
 
foo(); // 60

大家肯定都知道列印結果會是60。但是從第一行程式碼開始到最後一行程式碼結束，整個程式碼的執行上下文棧以及作用域鏈是怎樣變化的呢？

// 第一步：進入全域性上下文，此時的執行上下文棧是這樣：
ECStack = [
    globalContext: {
        VO: {
            foo: <reference to function foo() {}>,
            x: 10
        }
    }
];

// 第二步：foo函式被建立，此時的執行上下文棧沒有變化，但是建立了foo函式的作用域，儲存作用域鏈到內部屬性[[scope]]。
ECStack = [
    globalContext: {
        VO: {
            foo: <reference to function foo() {}>,
            x: 10
        }
    }
];
foo.[[scope]] = [
    globalContext.VO
];

// 第三步：foo函式執行，進入foo函式執行上下文的建立階段
// 這個階段它做了三件事：
// 1.複製之前的foo.[[scope]]屬性到foo函式上下文下，建立foo函式的作用域鏈；
// 2. 建立foo函式上下文的變數物件,並初始化變數物件，依次加入形參，函式宣告，變數宣告
// 3. 把foo函式上下文的變數物件加入到第一步建立的foo函式作用域鏈的最前面。
// 最終，經過這三個步驟之後，整個執行上下文棧是這樣

ECStack = [
    globalContext: {
        VO: {
            foo: <reference to function foo() {}>,
            x: 10
        }
    },
    <foo>functionContext: {
        VO: {
            arguments: {
                length: 0
            },
            bar: <reference to function bar() {}>,
            y: undefined
        },
        Scope: [foo.VO, globalContext.VO]
    }
];

foo.[[scope]] = [
    foo.VO,
    globalContext.VO
];

// 第四步：foo函式執行，進入foo函式執行上下文的執行階段。
// 這個階段又做了以下2件事：
// 1. 把foo執行上下文的變數物件VO改成了活動物件AO，並且修改AO中變數的值
// 2. 發現建立了一個 bar函式，就儲存了bar函式的所有父變數物件到bar函式的[[scope]]屬性上。


ECStack = [
    globalContext: {
        VO: {
            foo: <reference to function foo() {}>,
            x: 10
        }
    },
    <foo>functionContext: {
        AO: {
            arguments: {
                length: 0
            },
            bar: <reference to function bar() {}>,
            y: 20
        },
        Scope: [foo.AO, globalContext.VO]
    }
];

foo.[[scope]] = [
    foo.AO,
    globalContext.VO
];

bar.[[scope]] = [
    foo.AO,
    globalContext.VO
];

// 第五步，bar函式執行，進入bar函式執行上下文的建立階段
// 與第三步類似，也做了三件事，只不過主體變成了bar
// 1.複製之前的bar.[[scope]]屬性到bar函式上下文下，建立foo函式的作用域鏈；
// 2. 建立bar函式上下文的變數物件,並初始化變數物件，依次加入形參，函式宣告，變數宣告
// 3. 把bar函式上下文的變數物件加入到第一步建立的bar函式作用域鏈的最前面。
// 最終，經過這三個步驟之後，整個執行上下文棧是這樣

ECStack = [
    globalContext: {
        VO: {
            foo: <reference to function foo() {}>,
            x: 10
        }
    },
    <foo>functionContext: {
        AO: {
            arguments: {
                length: 0
            },
            bar: <reference to function bar() {}>,
            y: 20
        },
        Scope: [foo.AO, globalContext.VO]
    },
    <bar>functionContext: {
        VO: {
            arguments: {
                length: 0
            },
            z: undefined
        },
        Scope: [bar.VO, foo.AO, globalContext.VO]
    }
];

foo.[[scope]] = [
    foo.AO,
    globalContext.VO
];

bar.[[scope]] = [
    bar.VO,
    foo.AO,
    globalContext.VO
];

// 第六步：bar函式執行，進入bar函式執行上下文的執行階段
// 與第四步類似。不過此時bar函式裡面不會再建立新的函式上下文了
// 1. 把bar執行上下文的變數物件VO改成了活動物件AO，並且修改AO中變數的值
ECStack = [
    globalContext: {
        VO: {
            foo: <reference to function foo() {}>,
            x: 10
        }
    },
    <foo>functionContext: {
        AO: {
            arguments: {
                length: 0
            },
            bar: <reference to function bar() {}>,
            y: 20
        },
        Scope: [foo.AO, globalContext.VO]
    },
    <bar>functionContext: {
        AO: {
            arguments: {
                length: 0
            },
            z: 30
        },
        Scope: [bar.AO, foo.AO, globalContext.VO]
    }
];

foo.[[scope]] = [
    foo.AO,
    globalContext.VO
];

bar.[[scope]] = [
    bar.AO,
    foo.AO,
    globalContext.VO
];

// 第七步：執行bar函式中的console.log(x + y +z)，查詢x, y, z三個識別符號

- "x"
-- <bar>functionContext.AO   // 沒找到,繼續到foo.AO中找
-- <foo>functionContext.AO   // 還沒找到，再往globalContext.VO中找
-- globalContext.VO     // 找到了，值為 10

- "y"
-- <bar>functionContext.AO   // 沒找到,繼續到foo.AO中找
-- <foo>functionContext.AO   // 找到了，值為20

-- "z"
-- <bar>functionContext.AO   // 找到了，值為 30

列印結果： 60。

// 第八步：bar函式執行完畢，將其從執行上下文棧中彈出，foo函式執行完畢，將其從執行上下文棧中彈出。最終，執行上下文棧，只剩下globalContext

ECStack = [
    globalContext: {
        VO: {
            foo: <reference to function foo() {}>,
            x: 10
        }
    }
]

感覺其實可以簡化理解一下，把第三四步，第五六步分別分成一個步驟。

打算每週定一個小主題，可能是基礎知識鞏固，也可能是自己學習新知識的記錄。在下一篇博文中，將對this指向問題進行梳理。如果你也感興趣，也可以去搜集下相關資料，到時候大家共同學習探討一下。

相關文章