「循環加載」(circular dependency)指的是 a 腳本的執行依賴 b,而 b 又回頭依賴 a。
// a.js
var b = require('b');
// b.js
var a = require('a');
通常循環依賴代表存在強耦合,處理不好還會導致遞歸載入、讓程式根本跑不起來,因此理論上應該避免。但實務上很難完全杜絕,尤其是依賴關係複雜的大型專案,a 依賴 b、b 依賴 c、c 又依賴 a 這種情況相當常見。這意味著模組載入機制必須把循環依賴納入考量。
目前最常見的兩種模組格式——CommonJS 與 ES6——處理方式完全不同,結果也不一樣。
一、CommonJS 的載入原理
CommonJS 的「一個模組」就是一個腳本檔。require 第一次載入該腳本時會執行整份程式,並在記憶體中產生一個物件:
{
id: '...',
exports: { ... },
loaded: true,
...
}
其中 id 是模組名,exports 是該模組對外輸出的介面,loaded 則是布林值,表示腳本是否執行完畢。之後每次用到這個模組,都是到 exports 上取值;即使再次 require,也不會重新執行模組,而是直接從快取讀取。
二、CommonJS 的循環加載
CommonJS 的重要特性是「載入時執行」:程式碼在 require 的那一刻就全部跑完。因此一旦出現循環加載,它只輸出已經執行的部分,尚未執行的部分不會輸出。
官方文件中的例子,a.js:
exports.done = false;
var b = require('./b.js');
console.log('在 a.js 之中,b.done = %j', b.done);
exports.done = true;
console.log('a.js 執行完畢');
a.js 先輸出一個 done,接著載入 b.js。此時 a.js 就停在這一行,等 b.js 跑完才繼續。
b.js:
exports.done = false;
var a = require('./a.js');
console.log('在 b.js 之中,a.done = %j', a.done);
exports.done = true;
console.log('b.js 執行完畢');
b.js 執行到第二行時去載入 a.js,循環就此形成。系統會到 a.js 對應物件的 exports 上取值,但 a.js 只跑完第一行 exports.done = false,所以 b.js 拿到的 done 是 false。
b.js 接著往下跑完,把執行權交還 a.js,a.js 才繼續到結束。用 main.js 驗證:
var a = require('./a.js');
var b = require('./b.js');
console.log('在 main.js 之中, a.done=%j, b.done=%j', a.done, b.done);
$ node main.js 在 b.js 之中,a.done = false b.js 執行完畢 在 a.js 之中,b.done = true a.js 執行完畢 在 main.js 之中, a.done=true, b.done=true
輸出證實了兩件事:b.js 拿到的 a.js 只執行了第一行;而 main.js 執行到第二行時不會重跑 b.js,而是直接輸出快取中的結果。
三、ES6 的循環加載
ES6 的機制完全不同:遇到 import 時不會執行模組,只產生一個引用;等到真正需要取值時,才回到模組裡去拿。因此 ES6 是動態引用,不存在快取值的概念,模組中的變數始終綁定其所在的模組。
// m1.js
export var foo = 'bar';
setTimeout(() => foo = 'baz', 500);
// m2.js
import { foo } from './m1.js';
console.log(foo);
setTimeout(() => console.log(foo), 500);
$ babel-node m2.js bar baz
foo 在載入時是 bar,500 毫秒後變成 baz,m2.js 兩次都讀到了正確的值。這說明 ES6 不快取執行結果,而是動態去被載入模組取值。
這也導致 ES6 處理循環加載的方式與 CommonJS 有本質差異:它根本不關心是否發生循環,只產生一個指向被載入模組的引用,取值的時機由開發者自己負責保證。以下例子(摘自 Dr. Axel Rauschmayer 的《Exploring ES6》):
// a.js
import { bar } from './b.js';
export function foo() {
bar();
console.log('執行完畢');
}
foo();
// b.js
import { foo } from './a.js';
export function bar() {
if (Math.random() > 0.5) { foo(); }
}
依 CommonJS 規範,這段程式根本跑不起來:a 載入 b,b 又載入 a,此時 a 尚無任何執行結果,foo 會是 null,後面的 foo() 便會報錯。但 ES6 可以正常執行,輸出「執行完畢」,原因就在於它載入的變數都是動態引用,只要引用存在,程式碼就能跑。
再看 SystemJS 提供的一個例子:
// even.js
import { odd } from './odd';
export var counter = 0;
export function even(n) {
counter++;
return n == 0 || odd(n - 1);
}
// odd.js
import { even } from './even';
export function odd(n) {
return n != 0 && even(n - 1);
}
$ babel-node > import * as m from './even.js'; > m.even(10); true > m.counter 6 > m.even(20) true > m.counter 17
n 從 10 遞減到 0 的過程中 even() 共執行 6 次,counter 為 6;第二次 n 從 20 到 0 執行 11 次,加上先前的 6 次,counter 變成 17。
同樣的邏輯改寫成 CommonJS 就會直接爆炸:
// even.js
var odd = require('./odd');
var counter = 0;
exports.counter = counter;
exports.even = function (n) {
counter++;
return n == 0 || odd(n - 1);
};
// odd.js
var even = require('./even').even;
module.exports = function (n) {
return n != 0 && even(n - 1);
};
$ node
> var m = require('./even');
> m.even(10)
TypeError: even is not a function
even.js 載入 odd.js,odd.js 又回頭載入 even.js,此時引擎輸出的是 even.js 已執行的部分(什麼都沒有),所以 odd.js 中的 even 是 undefined,呼叫時自然報錯。