Does require in node uses eval to run a code in another file

user_1993034 0
Viewed 1246

I was just trying to understand modules in node. I understood few things like node creates a module wrapper function around code placed in each file.

Let's say there are 2 files, a.js and b.js

In a.js, when i require b.js for first time, how will the module wrapper function which is present in b.js get's executed.

Does node do something like, get the whole content of b.js file as a string and then execute that from a.js using eval and then keep the result of this function call in cache.

node.js javascript
2 Answers

More or less.

Node.js loads script file contents and wraps with module wrapper:

Module.wrap = function(script) {
  return Module.wrapper[0] + script + Module.wrapper[1];
};

Module.wrapper = [
  '(function (exports, require, module, __filename, __dirname) { ',
  '\n});'
];

Then module function is evaluated with vm.runInThisContext:

  var wrapper = Module.wrap(content);

  var compiledWrapper = vm.runInThisContext(wrapper, {
    filename: filename,
    lineOffset: 0,
    displayErrors: true
  });

vm module provides V8 execution context, and vm.runInThisContext evaluates the code similarly to indirect eval:

vm.runInThisContext() compiles code, runs it within the context of the current global and returns the result. Running code does not have access to local scope, but does have access to the current global object.

<...>

Because vm.runInThisContext() does not have access to the local scope, localVar is unchanged. In contrast, eval() does have access to the local scope, so the value localVar is changed. In this way vm.runInThisContext() is much like an indirect eval() call, e.g. (0,eval)('code').

user_37315010

When you do require then node.js have loader.js file which is responsible for loading the module. Following steps perform by loader.js file

  1. First, it checks in that module is present in the cached module or not. Checking is done by Module._cache
  2. if Not present in cached then, Creates a new Module instance.
  3. Saves into Cache
  4. Call module.load() with your the given filename. This will call module.compile() after reading the file contents.
  5. If Error in parsing the file (Because when compilation happen with any compiler there is the step of lexical analysis and parsing) then deletes the module from the cache
  6. Then returns module.export object.

As we know node is open source I am directly giving github path of loader.js of node.js

Path of loader.js

Here is the code of Module._load function which is written by Node.js Team

// Check the cache for the requested file.
// 1. If a module already exists in the cache: return its exports object.
// 2. If the module is native: call `NativeModule.require()` with the
//    filename and return the result.
// 3. Otherwise, create a new module for the file and save it to the cache.
//    Then have it load  the file contents before returning its exports
//    object.
Module._load = function(request, parent, isMain) {
  if (parent) {
    debug('Module._load REQUEST %s parent: %s', request, parent.id);
  }

  var filename = Module._resolveFilename(request, parent, isMain);

  var cachedModule = Module._cache[filename];
  if (cachedModule) {
    updateChildren(parent, cachedModule, true);
    return cachedModule.exports;
  }

  if (NativeModule.nonInternalExists(filename)) {
    debug('load native module %s', request);
    return NativeModule.require(filename);
  }

  // Don't call updateChildren(), Module constructor already does.
  var module = new Module(filename, parent);

  if (isMain) {
    process.mainModule = module;
    module.id = '.';
  }

  Module._cache[filename] = module;

  tryModuleLoad(module, filename);

  return module.exports;
};

Also check this article to understand how process works

How require() Actually Works

user_79961960
Related