Node.js 啓動方式：一道關於全局變量的題目引起的思考

原文連接：https://xcoder.in/2015/11/26/a-js-problem-about-global/

原題

題目是這樣的。

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

foo();

上題由咱們親愛的小龍童鞋發現並在咱們的 901 羣裏提問的。

通過

而後有下面的小對話。

小龍：大家猜這個輸出什麼？

弍紓：2

力叔：2 啊

死月·絲卡蕾特：2

力叔：有什麼問題麼？

小龍：輸出 undefind。

死月·絲卡蕾特：你肯定？

小龍：是否是我電腦壞了

力叔：你肯定？

弍紓：你肯定？

小龍：爲何我 node 文件名跑出來的是 undefined？

鄭昱：-.- 同樣阿。undefined

以上就是剛見到這個題目的時候羣裏的一個小討論。

分析

後來我就以爲奇怪，既然小龍驗證過了，說明他也不是隨地大小便，無的放矢什麼的。

因而我也驗證了一下，不過因爲偷懶，沒有跟他們同樣寫在文件裏面，而是直接 node 開了個 REPL 來輸入上述代碼。

結果是 2！

結果是 2！

結果是 2！

因而這就出現了一個很奇怪的問題。

尼瑪爲毛我是 2 他們倆是 undefined 啊！

不過立刻我就反應過來了——咱們幾個的環境不一樣，他們是 $ node foo.js 而我是直接 node 開了個 REPL，因此有必定的區別。

而力叔自己就是前端大神，我估計是以 Chrome 的調試工具下爲基礎出的答案。

REPL vs 文件執行

其實上述的問題，須要解釋的問題大概就是 a 到底掛在哪了。

由於細細一想，在 function 當中，this 指向的目標是 global 或者 window。

還沒法理解上面這句話的童鞋須要先補一下基礎。

那麼最終須要解釋的就是 a 到底有沒有掛在全局變量上面。

這麼一想就有點細思恐極的味道了——若是在 node 線上運行環境裏面的源代碼文件裏面隨便 var 一個變量就掛到了全局變量裏面那是有多恐怖！

因而就有些釋然了。

但到底是什麼緣由致使 REPL 和文件執行方式不同的呢？

全局對象的屬性

首先是弍紓找出了阮老師 ES6 系列文章中的全局對象屬性一節。

全局對象是最頂層的對象，在瀏覽器環境指的是 window 象，在 Node.js 指的是 global 對象。ES5 之中，全局對象的屬性與全局變量是等價的。

window.a = 1;
a // 1

a = 2;
window.a // 2

上面代碼中，全局對象的屬性賦值與全局變量的賦值，是同一件事。（對於Node來講，這一條只對REPL環境適用，模塊環境之中，全局變量必須顯式聲明成global對象的屬性。）

有了阮老師的文章驗證了這個猜測，我能夠放心大膽繼續看下去了。

repl.js

知道了上文的內容以後，感受首要查看的就是 Node.js 源碼中的 repl.js 了。

先是結合了一下本身之前用自定義 REPL 的狀況，通常的步驟先是獲取 REPL 的上下文，而後在上下文裏面貼上各類本身須要的東西。

var r = relp.start(" ➜ ");
var c = r.context;

// 在 c 裏面貼上各類上下文
c.foo = bar;
// ...

關於自定義 REPL 的一些使用方式能夠參考下老雷寫的《Node.js 定製 REPL 的妙用》。

有了以前寫 REPL 的經驗，大體明白了 REPL 裏面有個上下文的東西，那麼在 repl.js 裏面咱們也找到了相似的代碼。

REPLServer.prototype.createContext = function() {
  var context;
  if (this.useGlobal) {
    context = global;
  } else {
    context = vm.createContext();
    for (var i in global) context[i] = global[i];
    context.console = new Console(this.outputStream);
    context.global = context;
    context.global.global = context;
  }

  context.module = module;
  context.require = require;

  this.lines = [];
  this.lines.level = [];

  // make built-in modules available directly
  // (loaded lazily)
  exports._builtinLibs.forEach(function(name) {
    Object.defineProperty(context, name, {
      get: function() {
        var lib = require(name);
        context._ = context[name] = lib;
        return lib;
      },
      // allow the creation of other globals with this name
      set: function(val) {
        delete context[name];
        context[name] = val;
      },
      configurable: true
    });
  });

  return context;
};

看到了關鍵字 vm。咱們暫時先無論 vm，光從上面的代碼能夠看出，context 要麼等於 global，要麼就是把 global 上面的全部東西都粘過來。

而後順帶着把必須的兩個不在 global 裏的兩個東西 require 和 module 給弄過來。

下面的東西就不須要那麼關心了。

VM

接下去咱們來說講 vm。

VM 是 node 中的一個內置模塊，能夠在文檔中看到說明和使用方法。

大體就是將代碼運行在一個沙箱以內，而且事先賦予其一些 global 變量。

而真正起到上述 var 和 global 區別的就是這個 vm 了。

vm 之中在根做用域（也就是最外層做用域）中使用 var 應該是跟在瀏覽器中同樣，會把變量粘到 global（瀏覽器中是 window）中去。

咱們能夠試試這樣的代碼：

var vm = require('vm');
var localVar = 'initial value';

vm.runInThisContext('var localVar = "vm";');
console.log('localVar: ', localVar);
console.log('global.localVar: ', global.localVar);

其輸出結果是：

localVar: initial value
global.localVar: vm

如文檔中所說，vm 的一系列函數中跑腳本都沒法對當前的局部變量進行訪問。各函數能訪問本身的 global，而 runInThisContext 的 global 與當前上下文的 global 是同樣的，因此能訪問當前的全局變量。

因此出現上述結果也是理所固然的了。

因此在 vm 中跑咱們一開始拋出的問題，答案天然就是 2 了。

var vm = require("vm");
var sandbox = {
    console: console
};

vm.createContext(sandbox);
vm.runInContext("var a = 2;function foo(){console.log(this.a);}foo();", sandbox);

Node REPL 啓動的沙箱

最後咱們再只須要驗證一件事就能真相大白了。

平時咱們自定義一個 repl.js 而後執行 $ node repl.js 的話是會啓動一個 REPL，而這個 REPL 會去調 vm，因此會出現 2 的答案；或者咱們本身在代碼裏面寫一個 vm 而後跑以前的代碼，也是理所固然出現 2。

那麼咱們就輸入 $ node 來進入的 REPL 跟咱們以前講的 REPL 是否是同一個東西呢？

若是是的話，一切就釋然了。

首先咱們進入到 Node 的入口文件——C++ 的 int main()。

它在 Node.js 源碼 src/node_main.cc 之中。

int main(int argc, char *argv[]) {
  setvbuf(stderr, NULL, _IOLBF, 1024);
  return node::Start(argc, argv);
}

就在主函數中執行了 node::Start。而這個 node::Start 又存在 src/node.cc 裏面。

而後在 node::Start 裏面又調用 StartNodeInstance，在這裏面是 LoadEnvironment 函數。

最後在 LoadEnvironment 中看到了幾句關鍵的語句：

Local<String> script_name = FIXED_ONE_BYTE_STRING(env->isolate(), "node.js");
Local<Value> f_value = ExecuteString(env, MainSource(env), script_name);

//...

Local<Function> f = Local<Function>::Cast(f_value);

//...
Local<Object> global = env->context()->Global();

//...
Local<Value> arg = env->process_object();
f->Call(global, 1, &arg);

還有這麼一段關鍵的註釋。

// Now we call 'f' with the 'process' variable that we've built up with
// all our bindings. Inside node.js we'll take care of assigning things to
// their places.

// We start the process this way in order to be more modular. Developers
// who do not like how 'src/node.js' setups the module system but do like
// Node's I/O bindings may want to replace 'f' with their own function.

也就是說，啓動 node 的時候，在作了一些準備以後是開始載入執行 src 文件夾下面的 node.js 文件。

在 92 行附近有針對 $ node foo.js 和 $ node 的判斷啓動不一樣的邏輯。

// ...
} else if (process.argv[1]) {
  // make process.argv[1] into a full path
  var path = NativeModule.require('path');
  process.argv[1] = path.resolve(process.argv[1]);

  var Module = NativeModule.require('module');

  // ...

  startup.preloadModules();
  if (global.v8debug &&
      process.execArgv.some(function(arg) {
        return arg.match(/^--debug-brk(=[0-9]*)?$/);
      })) {
    var debugTimeout = +process.env.NODE_DEBUG_TIMEOUT || 50;
    setTimeout(Module.runMain, debugTimeout);
  } else {
    // Main entry point into most programs:
    Module.runMain();
  }
} else {
  var Module = NativeModule.require('module');

  if (process._forceRepl || NativeModule.require('tty').isatty(0)) {
    // REPL
    var cliRepl = Module.requireRepl();
    cliRepl.createInternalRepl(process.env, function(err, repl) {
      // ...
    });
  } else {
    // ...
  }
}

在上述節選代碼的第一個 else if 中，就是對 $ node foo.js 這種狀況進行處理了，再作完各類初始化以後，使用 Module.runMain(); 來運行入口代碼。

第二個 else if 裏面就是 $ node 這種狀況了。

咱們在終端中打開 $ node 的時候，TTY 一般是關連着的，因此 require('tty').isatty(0) 爲 true，也就是說會進到條件分支而且執行裏面的 cliRepl 相關代碼。

咱們進入到 lib/module.js 看看這個 Module.requireRepl 是什麼東西。

Module.requireRepl = function() {
  return Module._load('internal/repl', '.');
}

因此咱們仍是得轉入 lib/internal/repl.js 來一探究竟。

上面在 node.js 裏面咱們看到它執行了這個 cliRepl 的 createInternalRepl 函數，它的實現大概是這樣的：

function createRepl(env, opts, cb) {
  // ...

  opts = opts || {
    ignoreUndefined: false,
    terminal: process.stdout.isTTY,
    useGlobal: true
  };

  // ...

  opts.replMode = {
    'strict': REPL.REPL_MODE_STRICT,
    'sloppy': REPL.REPL_MODE_SLOPPY,
    'magic': REPL.REPL_MODE_MAGIC
  }[String(env.NODE_REPL_MODE).toLowerCase().trim()];

  // ...

  const repl = REPL.start(opts);

  // ...
}

轉頭一看這個 lib/internal/repl.js 頂端的模塊引入，赫然看到一句話：

const REPL = require('repl');

真相大白。

小結

　　最後再梳理一遍。

　　在於 Node.js 的 vm 裏面，頂級做用域下的 var 會把變量貼到 global 下面。而 REPL 使用了 vm。而後 $ node 進入的一個模式就是一個特定參數下面啓動的一個 REPL。

　　因此咱們一開始提出的問題裏面在 $ node foo.js 模式下執行是 undefined，由於不在全局變量上，可是啓用 $ node 這種 REPL 模式的時候獲得的結果是 2。

番外

小龍：我用 node test.js 跑出來是 a: undefined；那我應該怎麼修改「環境」，來讓他跑出：a: 2 呢？

　　因而有了上面寫的那段代碼。

var vm = require("vm");
var sandbox = {
    console: console
};

vm.createContext(sandbox);
vm.runInContext("var a = 2;function foo(){console.log(this.a);}foo();", sandbox);