// Each node.js file is a separate module
// Node wraps the contents of the retrieved Javascript file, passing in the following variables
console.log(exports, require.module, __filename, __dirname);
// You can mount exported variables or functions to the properties of exports objects,
exports.name = 'luoxiaobu';
exports.age = '18'Copy the code

// Each node.js file is a separate module
// Node wraps the contents of the retrieved Javascript file, passing in the following variables
console.log(exports, require.module, __filename, __dirname);
let name = 'luoxiaobu';
let age = '18'
// Exports an entire variable object or function using the module.exports object.
module.exports = {name,age};Copy the code

// The core module is introduced into Node's own module
let crypto = require('crypto')

// User-written modules are introduced
let aModule = require('./a.js')
// third party, other people implement published module (actually also other users write)
let proxy = require('http-proxy');Copy the code

2.1 Description of Node Module Loading

// 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.prototype.compileForPublicLoader()` and return the exports.
// 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) {
    let relResolveCacheIdentifier;
    if (parent) {
      debug('Module._load REQUEST %s parent: %s', request, parent.id); . }// Find the file location
    const filename = Module._resolveFilename(request, parent, isMain);
    // There is no need to perform the return cache again
    const cachedModule = Module._cache[filename];
    if(cachedModule ! = =undefined) {
      updateChildren(parent, cachedModule, true);
      if(! cachedModule.loaded)return getExportsForCircularRequire(cachedModule);
      return cachedModule.exports;
    }
    // Load the node native module, loadNativeModule
    // Mod.exports is returned if it exists and can be referenced by the user. (This includes compiling the Node module to create module objects and storing the module running results on module objects)
    const mod = loadNativeModule(filename, request);
    if (mod && mod.canBeRequiredByUsers) return mod.exports;
  
    // Create a module
    // Don't call updateChildren(), Module constructor already does.
    const module = new Module(filename, parent);
  
    if (isMain) {
      process.mainModule = module;
      module.id = '. ';
    }
    // Cache module
    Module._cache[filename] = module;
    if(parent ! = =undefined) {
      relativeResolveCache[relResolveCacheIdentifier] = filename;
    }
    // Load and execute the new module
    module.load(filename);  
      
    return module.exports;
  };Copy the code

2.2 Node source Directory

General source code structure :(only annotated parts of interest)

We can see the node library directory, where:

Deps:Contains libraries that Node relies on, such as V8, libuv, zlib, etc.,

Lib:Contains functions and modules defined in javascript (which may be called via internalBinding to the c++ module, which is implemented in the directory SRC),

SRC:Includes the corresponding C++ implementation of the lib library, many of which are built in here

Can be confused, js and c++ call each other?

Node.js mainly includes these parts, Node Standard Library, Node Bindings, V8, Libuv, and the architecture diagram is as follows:

Node Bindings: is a bridge between JS and C++, which translates the C++ interface exposed by V8 engine into JS API

V8: A JavaScript engine that provides a JavaScript runtime environment

C++ module reference process

C++ and JS interactive reference article :(interested can know)

C++ and JS interaction

Develop customizable applications using the Google V8 engine

2.3 Node Module Classification

• The core module of Node
  • Node core module JS implementation
  • Node core module c++ implementation, js package call c++ module
• Third-party modules, or user-written modules
  • JavaScript module, we developed to write JavaScript module
  • JSON module, a JSON file
  • C/C++ extension module, written in C/C++, compiled with the suffix.node (interested in the dynamic link library)

const filename = Module._resolveFilename(request, parent, isMain);Copy the code

 const cachedModule = Module._cache[filename];
  if(cachedModule ! = =undefined) {
    updateChildren(parent, cachedModule, true);
    return cachedModule.exports;
  }Copy the code

  const module = new Module(filename, parent);
// Cache module objects
  Module._cache[filename] = module;Copy the code

// Native extension for .js
Module._extensions['.js'] = function(module, filename) {
  if (experimentalModules && filename.endsWith('.js')) {
    const pkg = readPackageScope(filename);
    if (pkg && pkg.type === 'module') {
      throw newERR_REQUIRE_ESM(filename); }}const content = fs.readFileSync(filename, 'utf8');
  module._compile(stripBOM(content), filename);
};


// Native extension for .json
Module._extensions['.json'] = function(module, filename) {
  const content = fs.readFileSync(filename, 'utf8');

  if (manifest) {
    const moduleURL = pathToFileURL(filename);
    manifest.assertIntegrity(moduleURL, content);
  }

  try {
    module.exports = JSON.parse(stripBOM(content));
  } catch (err) {
    err.message = filename + ':' + err.message;
    throwerr; }};// Native extension for .node
Module._extensions['.node'] = function(module, filename) {
  if (manifest) {
    const content = fs.readFileSync(filename);
    const moduleURL = pathToFileURL(filename);
    manifest.assertIntegrity(moduleURL, content);
  }
  // Be aware this doesn't use `content`
  return process.dlopen(module, path.toNamespacedPath(filename));
};Copy the code