Nodejs モジュール システムのソースコード分析

関数モジュール(id = "", 親) {
  // モジュール ID。通常はモジュールの絶対パスです。this.id = id;
  this.path = path.dirname(id);
  this.exports = {};
  //現在のモジュール呼び出し元 this.parent = parent;
  親を更新します。
  this.filename = null;
  // モジュールはロードされていますか? this.loaded = false;
  //現在のモジュールによって参照されるモジュール this.children = [];
}

// 1. エクスポートを使用する: 通常はツール ライブラリ関数または定数をエクスポートするために使用します。exports.name = 'xiaoxiang';
exports.add = (a, b) => a + b;
// 2. module.exports を使用します。オブジェクト全体または単一の関数をエクスポートします...
モジュール.エクスポート = {
  追加、
  マイナス
}

// モジュールを参照 const { add, minus } = require('./module');
const a = require('/usr/app/module');
定数 http = require('http');

exports.name = 'テスト';
console.log(module.exports.name); // テスト
module.export.name = 'テスト';
console.log(exports.name); // テスト

エクスポート = { 名前: 'テスト' };
console.log(module.exports.name, exports.name); // 未定義、テスト

module.exports = exports = { 名前: 'test' };
console.log(module.exports.name, exports.name) // テスト、テスト

// エントリ関数を要求する Module.prototype.require = function(id) {
  //...
  深さ++が必要です。
  試す {
    return Module._load(id, this, /* isMain */ false); // モジュールをロード } finally {
    必要な深さ--;
  }
};

Module._load = function(リクエスト、親、isMain) {
  // ステップ 1: モジュールの完全なパスを解決します。const filename = Module._resolveFilename(request, parent, isMain);

  // ステップ 2: モジュールをロードします。これは 3 つのケースに分かれています。// ケース 1: キャッシュされたモジュールがある場合は、モジュールの exports プロパティを直接返します。const cachedModule = Module._cache[filename];
  (cachedModule !== 未定義)の場合 
    cachedModule.exports を返します。
  // ケース 2: 組み込みモジュールの読み込み const mod = loadNativeModule(filename, request);
  mod が 'canBeRequiredByUsers' の場合、 mod.exports を返します。
  // ケース 3: モジュールをビルドする load const module = new Module(filename, parent);
  // ロード後、モジュールインスタンスをキャッシュします。Module._cache[filename] = module;

  // ステップ 3: モジュール ファイルをロードします module.load(filename);

  // ステップ 4: エクスポート オブジェクトを返します。 return module.exports;
};

Module._resolveFilename = function(request, parent, isMain, options) {
 NativeModule.canBeRequiredByUsers(リクエスト)の場合 
     // 組み込みモジュールの読み込みを優先する return request;
 }
 パスを設定します。

 // ノード require.resolve 関数で使用されるオプション。options.paths は検索パスを指定するために使用されます。if (typeof options === "object" && options !== null) {
   ArrayIsArray(options.paths) の場合
     定数isRelative =
       リクエストは("./")で始まります ||
       リクエストは("../")で始まります ||
       (isWindows && request.startsWith(".\\")) ||
       リクエストは("..\\")で始まります。
     相対的である場合
       パス = オプション.パス;
     } それ以外 {
       const fakeParent = 新しいモジュール("", null);
       パス = [];
       (i = 0 とします; i < options.paths.length; i++) {
         定数パス = options.paths[i];
         偽のParent.paths = Module._nodeModulePaths(path);
         const lookupPaths = Module._resolveLookupPaths(リクエスト、fakeParent);
         (j = 0; j < lookupPaths.length; j++) の場合 {
           paths.includes(lookupPaths[j]) が含まれている場合、paths.push(lookupPaths[j]);
         }
       }
     }
   } そうでない場合 (options.paths === undefined) {
     パス = Module._resolveLookupPaths(リクエスト、親);
   } それ以外 {
        //...
   }
 } それ以外 {
   // モジュールの存在パスを検索します paths = Module._resolveLookupPaths(request, parent);
 }
 // 指定されたモジュールとトラバーサル アドレス配列に基づいてモジュール パスを検索し、エントリ モジュールであるかどうかも検索します。const filename = Module._findPath(request, paths, isMain);
 if (!ファイル名) {
   定数requireStack = [];
   (カーソル = 親; カーソル; カーソル = カーソル.parent) {
     requireStack.push(cursor.filename || cursor.id);
   }
   // モジュールが見つからないため、例外をスローします (これはよくあるエラーでしょうか?)
   let message = `モジュール '${request}' が見つかりません`;
   （requireStack.length > 0）の場合{
     message = message + "\nRequire スタック:\n- " + requireStack.join("\n- ");
   }

   const err = new Error(メッセージ);
   err.code = "モジュールが見つかりません";
   err.requireStack = requireStack;
   エラーをスローします。
 }
 //最後にファイル名を含む完全なパスを返します return filename;
};

// モジュールファイルのアドレス指定アドレス配列メソッド Module._resolveLookupPaths = function(request, parent) {
    NativeModule.canBeRequiredByUsers(リクエスト)の場合
      debug("[] 内の %j を探しています", request);
      null を返します。
    }

    // 相対パスでない場合は（
      リクエスト.charAt(0) !== "." ||
      (リクエストの長さ > 1 &&
        リクエスト.charAt(1) !== "." &&
        リクエスト.charAt(1) !== "/" &&
        (!isWindows || request.charAt(1) !== "\\"))
    ）{
      /** 
       * node_modules フォルダを確認します * modulePaths はユーザー ディレクトリ、node_path 環境変数はディレクトリ、グローバル ノードのインストール ディレクトリを指定します */
      パスを modulePaths とします。

      親が null ではない場合、parent.paths と parent.paths.length が適用されます。
        // 親モジュールの modulePath も子モジュールの modulePath に追加し、遡って paths = parent.paths.concat(paths); を見つける必要があります。
      }

      paths.length > 0 ? paths : null を返します。
    }

    // replインタラクションを使用する場合は、./ ./node_modulesとmodulePathsを順番に検索します
    if (!親 || !親ID || !親ファイル名) {
      const mainPaths = ["."].concat(Module._nodeModulePaths("."), modulePaths);

      mainPaths を返します。
    }

    // 相対パス導入の場合は、検索パスに親フォルダのパスを追加します。const parentDir = [path.dirname(parent.filename)];
    親ディレクトリを返します。
   };

// 指定されたモジュールとトラバーサルアドレス配列に基づいてモジュールの実際のパスを検索し、それがトップレベルモジュールであるかどうかも調べます。Module._findPath = function(request, paths, isMain) {
 定数 absoluteRequest = path.isAbsolute(リクエスト);
 if (絶対リクエスト) {
  // 絶対パス、特定のモジュールを直接検索します paths = [""];
 } そうでない場合 (!paths || paths.length === 0) {
   false を返します。
 }
 定数キャッシュキー =
   リクエスト + "\x00" + (paths.length === 1 ? paths[0] : paths.join("\x00"));
 // キャッシュパス const entry = Module._pathCache[cacheKey];
 if (entry) は entry を返します。
 拡張子を出力します。
 末尾にスラッシュを入れる =
   リクエストの長さ > 0 &&
   request.charCodeAt(request.length - 1) === CHAR_FORWARD_SLASH; // '/'
 if (!末尾のスラッシュ) {
   末尾のスラッシュ = /(?:^|\/)\.?\.$/.test(request);
 }
 // 各パスについて
 (i = 0 とします; i < paths.length; i++) {
   定数curPath = パス[i];
   curPath && stat(curPath) < 1 の場合、続行します。
   const basePath = resolveExports(curPath, request, absoluteRequest);
   ファイル名を入力します。
   定数rc = stat(basePath);
   if (!末尾のスラッシュ) {
     if (rc === 0) { // stat ステータスが 0 を返す場合、それはファイルです // File.
       もし (!isMain) {
         if (preserveSymlinks) {
           // モジュールを解決してキャッシュするときにシンボリック リンクを維持するようにモジュール ローダーに指示します。
           ファイル名 = path.resolve(basePath);
         } それ以外 {
           // シンボリックリンクを保持しない filename = toRealPath(basePath);
         }
       } そうでない場合 (preserveSymlinksMain) {
         ファイル名 = path.resolve(basePath);
       } それ以外 {
         ファイル名 = toRealPath(basePath);
       }
     }
     if (!ファイル名) {
       exts === undefined の場合、 exts = ObjectKeys(Module._extensions);
       // サフィックスを解析します。filename = tryExtensions(basePath, exts, isMain);
     }
   }
   if (!ファイル名 && rc === 1) { 
     /** 
       * stat が 1 を返し、ファイル名が存在しない場合は、フォルダーとみなされます * ファイルサフィックスが存在しない場合は、ディレクトリの下の package.json のメインエントリで指定されたファイルの読み込みを試みます * 存在しない場合は、index[.js、.node、.json] ファイルを試します */
     exts === undefined の場合、 exts = ObjectKeys(Module._extensions);
     ファイル名 = tryPackage(basePath, exts, isMain, request);
   }
   if (filename) { // ファイルが存在する場合は、ファイル名をキャッシュに追加します。 Module._pathCache[cacheKey] = filename;
     ファイル名を返します。
   }
 }
 const selfFilename = trySelf(paths, exts, isMain, trailingSlash, request);
 if (自己ファイル名) {
   // パスキャッシュを設定します。Module._pathCache[cacheKey] = selfFilename;
   selfFilename を返します。
 }
 false を返します。
};

// 標準モジュールのロードを試みる function tryPackage(requestPath, exts, isMain, originalPath) {
  const pkg = readPackageMain(リクエストパス);
  もし(!pkg){
    // package.json が存在しない場合は、index がデフォルトのエントリ ファイルとして使用されます。 return tryExtensions(path.resolve(requestPath, "index"), exts, isMain);
  }
  定数ファイル名 = path.resolve(requestPath, pkg);
  実際 =
    tryFile(ファイル名、isMain) ||
    tryExtensions(ファイル名、拡張子、isMain) ||
    tryExtensions(path.resolve(ファイル名、"index")、exts、isMain);
  //...
  実際の値を返します。
}
// package.jsonのメインフィールドを読み取る function readPackageMain(requestPath) {
  const pkg = readPackage(リクエストパス);
  pkg を返します ? pkg.main : undefined;
}

関数 readPackage(requestPath) {
  定数 jsonPath = path.resolve(requestPath, "package.json");
  定数 existing = packageJsonCache.get(jsonPath);
  if (existing !== undefined) は existing を返します。
  // libuv uv_fs_open 実行ロジックを呼び出し、package.json ファイルを読み取り、キャッシュします。const json = internalModuleReadJSON(path.toNamespacedPath(jsonPath));
  json === 未定義の場合{
    // 次にファイルをキャッシュします packageJsonCache.set(jsonPath, false);
    false を返します。
  }
  //...
  試す {
    定数解析 = JSONParse(json);
    定数フィルタリング = {
      名前: 解析された名前、
      メイン: 解析済み.main、
      エクスポート: parsed.exports、
      タイプ: 解析されたタイプ
    };
    packageJsonCache.set(jsonPath, フィルター);
    フィルタリングされた結果を返します。
  } キャッチ (e) {
    //...
  }
}

Module.prototype.load = function(ファイル名) {
  // モジュールがロードされていないことを確認します assert(!this.loaded);
  this.filename = ファイル名;
  // 現在のフォルダの node_modules を見つける
  this.paths = Module._nodeModulePaths(path.dirname(ファイル名));
  const extension = findLongestRegisteredExtension(ファイル名);
  //...
  // js / json / node などの特定のファイル拡張子解析関数を実行します
  Module._extensions[拡張子](this, ファイル名);
  // モジュールが正常にロードされたことを示します this.loaded = true;
  // ... esm モジュールのサポートを省略 };

Module._extensions[".js"] = function(モジュール、ファイル名) {

  // ファイルの内容を読み取る const content = fs.readFileSync(filename, "utf8");
  // コードをコンパイルして実行します module._compile(content, filename);
};

Module._extensions[".json"] = function(モジュール、ファイル名) {
  // ファイルを UTF-8 形式で直接読み込みます。const content = fs.readFileSync(filename, "utf8");
  //...
  試す {
    // ファイルの内容を JSON オブジェクト形式でエクスポートします。 module.exports = JSONParse(stripBOM(content));
  } キャッチ (エラー) {
    //...
  }
};

Module._extensions[".node"] = function(モジュール、ファイル名) {
  //...
  process.dlopen(module, path.toNamespacedPath(filename)) を返します。
};

Module.prototype._compile = function(コンテンツ、ファイル名) {
  モジュールURLを設定します。
  リダイレクトします。
  // モジュールにパブリック変数 __dirname / __filename / module / exports / require を挿入し、関数をコンパイルします。constcompiledWrapper = wrapSafe(filename, content, this);
  const dirname = path.dirname(ファイル名);
  const require = makeRequireFunction(this, リダイレクト);
  結果を出す;
  const エクスポート = this.exports;
  const thisValue = エクスポート;
  const モジュール = this;
  requireDepth === 0 の場合、 statCache = new Map();
      //...
   // モジュール内の関数を実行する result =compiledWrapper.call(
      この値、
      輸出、
      必要とする、
      モジュール、
      ファイル名、
      ディレクトリ名
    );
  すべてのユーザーCJSModuleがロード済み = true;
  requireDepth === 0 の場合、 statCache = null;
  結果を返します。
};
//変数注入のコアロジック function wrapSafe(filename, content, cjsModuleInstance) {
  if (パッチ適用) {
    const ラッパー = Module.wrap(コンテンツ);
    // vm サンドボックスが実行され、実行結果が直接返されます。env->SetProtoMethod(script_tmpl, "runInThisContext", RunInThisContext);
    vm.runInThisContext(ラッパー、{
      ファイル名、
      ラインオフセット: 0,
      表示エラー: true、
      // 動的に読み込む importModuleDynamically: async specifier => {
        定数ローダー = asyncESM.ESMLoader;
        loader.import(specifier, normalizeReferrerURL(filename)) を返します。
      }
    });
  }
  コンパイルします。
  試す {
    コンパイル済み = コンパイル関数(
      コンテンツ、
      ファイル名、
      0,
      0,
      未定義、
      間違い、
      未定義、
      [],
      ["エクスポート"、"必須"、"モジュール"、"__ファイル名"、"__ディレクトリ名"]
    );
  } キャッチ (エラー) {
    //...
  }
  const { callbackMap } = internalBinding("module_wrap");
  callbackMap.set(compiled.cacheKey, {
    importModuleDynamically: 非同期指定子 => {
      定数ローダー = asyncESM.ESMLoader;
      loader.import(specifier, normalizeReferrerURL(filename)) を返します。
    }
  });
  コンパイルされた関数を返します。
}