Erfahren Sie mehr über den Modulmechanismus von Node und sprechen Sie über den Modulimplementierungsprozess

Dieser Artikel führt Sie zum Verständnis der CommonJs-Spezifikation und des Modulmechanismus von Node und stellt den grundlegenden Prozess der Node-Implementierung der CommonJs-Spezifikation vor. Ich hoffe, dass er für alle hilfreich ist!

Bevor die CommonJs-Spezifikation vorgeschlagen wurde, verfügte Javascript über kein Modulsystem, was bedeutete, dass es für uns schwierig war, umfangreiche Anwendungen zu entwickeln, da die Organisation des Codes schwieriger sein würde.

Was ist die CommonJS-Spezifikation? Zunächst einmal ist CommonJS keine Modulspezifikation, die definiert, wie Module referenziert und exportiert werden. Nodejs

implementiert diese Spezifikation hauptsächlich Es besteht aus drei Teilen: Modulreferenz, Moduldefinition und Modulidentifikation.

---

Modulreferenz

Modulreferenz bedeutet, dass wir andere Module über require einführen können.

const { add } = require('./add');
const result = add(1 ,2);

Moduldefinitionrequire引入其它的模块。

// add.js
exports.add = (a, b) => {
    return a + b;
}

模块定义

一个文件就是一个模块，模块里会提供两个变量，分别为module和exports。module为当前模块本身，exports为要导出的内容，同时exports为module的一个属性，即exports为module.exports。其他模块通过require导入的内容即为module.exports的内容。

// 缓存的模块示意：
const cachedModule = {
    '/Usr/file/src/add.js': 'add.js编译后的内容',
    'http': 'Node自带的http模块编译后的内容',
    'express': '非路径形式自定义文件模块express编译后的内容'
    // ...
}

模块标识

模块标识即为require里面的内容，比如require('./add')，则模块标识为./add

Eine Datei ist ein Modul, und das Modul stellt zwei Variablen bereit, nämlich Modul und Exporte. module ist das aktuelle Modul selbst, exports ist der zu exportierende Inhalt und exports ist ein Attribut des Moduls, d. h. exports ist module.exports. Der von anderen Modulen über require importierte Inhalt ist der Inhalt von module.exports.

/** 
* /Usr/file/index.js;
*/

const { add } = require('add');
const result = add(1, 2);

Modul-ID

---

Die Modul-ID ist der Inhalt in require. Beispiel: require('./add'), dann ist die Modul-ID ./add .

Der über CommonJS erstellte Mechanismus zum Importieren und Exportieren von Modulen ermöglicht es Benutzern, auf einfache Weise umfangreiche Anwendungen zu erstellen, ohne variable Verschmutzungen berücksichtigen zu müssen.

• Modulimplementierung von Node
Node implementiert die CommonJs-Spezifikation und fügt einige Funktionen hinzu, die Sie benötigen. Node führt hauptsächlich die folgenden drei Dinge aus, um die CommonJs-Spezifikation zu implementieren:

Pfadanalyse

Dateipositionierung

Kompilierung und Ausführung

Pfadanalyse

Beim Ausführen von require( ) Zu diesem Zeitpunkt ist der von require empfangene Parameter die Modulkennung, und der Knoten verwendet die Modulkennung, um eine Pfadanalyse durchzuführen. Der Zweck der Pfadanalyse besteht darin, anhand der Modulkennung den Pfad zu ermitteln, in dem sich dieses Modul befindet. Zunächst werden Knotenmodule in zwei Kategorien unterteilt, nämlich Kernmodule und Dateimodule. Das Kernmodul ist das Modul, das mit dem Knoten geliefert wird, und das Dateimodul ist das vom Benutzer geschriebene Modul. Gleichzeitig werden Dateimodule in Dateimodule in Form relativer Pfade, Dateimodule in Form absoluter Pfade und Dateimodule in Form von Nicht-Pfaden (z. B. Express) unterteilt.

Wenn der Knoten ein Dateimodul findet, wird das Modul kompiliert, ausgeführt und zwischengespeichert. Das allgemeine Prinzip besteht darin, den vollständigen Pfad des Moduls als Schlüssel und den kompilierten Inhalt als Wert zu verwenden und dann das Modul einzuführen Zum zweiten Mal ist keine Pfadanalyse, Dateispeicherung, Kompilierung und Ausführung dieser Schritte erforderlich. Der kompilierte Inhalt kann direkt aus dem Cache gelesen werden.

/** 
* /Usr/file/index.js;
*/

console.log(module.paths);

Wenn Sie das von require importierte Modul finden möchten, besteht die Reihenfolge beim Auffinden des Moduls darin, zunächst zu prüfen, ob sich das Modul bereits im Cache befindet. Wenn es sich nicht im Cache befindet, überprüfen Sie dann das Kernmodul und suchen Sie dann nach für das Dateimodul. Unter diesen sind Dateimodule in Form von Pfaden leichter zu finden. Der vollständige Dateipfad kann anhand des relativen oder absoluten Pfads ermittelt werden. Es ist relativ mühsam, benutzerdefinierte Dateimodule in Nicht-Pfad-Form zu finden. Node sucht im Ordner „node_modules“ nach der Datei.

Wo ist das Verzeichnis node_modules? Die Datei, die wir gerade ausführen, ist /Usr/file/index.js;

[
'/Usr/file/node_modules',
'/Usr/node_modules',
'/node_modules',
]

In diesem Modul haben wir ein Add-Modul eingeführt. Dieses Add ist weder ein Kernmodul noch ein Pfad . Dateimodul im Formular, wie man dieses Modul zu diesem Zeitpunkt findet.

Module haben ein Pfadattribut, um das Add-Modul zu finden. Wir können dieses Attribut eingeben, um Folgendes anzuzeigen:

const { add } = require('./add');

Wir können den Wert von Pfaden ausdrucken, indem wir node index.js im Dateiverzeichnis ausführen . Der Wert in Pfaden ist ein Array wie folgt:

// index.js
const { add } = require('./add');

Das heißt, Node sucht nacheinander im obigen Verzeichnis, um zu sehen, ob es das Add-Modul enthält. Das Prinzip ähnelt der Prototypenkette. Beginnen Sie mit der Suche im Ordner „node_modules“ auf derselben Verzeichnisebene wie die aktuell ausgeführte Datei. Wenn das Verzeichnis „node_modules“ nicht gefunden wird oder nicht vorhanden ist, fahren Sie mit der Suche auf der höheren Ebene fort.

🎜🎜Dateipositionierung🎜🎜🎜🎜Pfadanalyse und Dateipositionierung können zusammen verwendet werden, oder es kann sich um ein Verzeichnis oder ein Paket handeln, das durch die Pfadanalyse gefunden wird Bestimmte Dateien erfordern eine zusätzliche Verarbeitung. 🎜🎜🎜Dateierweiterungsanalyse🎜🎜

const { add } = require('./add');

比如上面这段代码，文件标识符是不带扩展名的，这个时候node会依次查找是否存在.js、.json、.node文件。

目录和包分析

同样是上面这段代码，通过./add查找到的可能不是一个文件，可能是一个目录或者包（通过判断add文件夹下是否有package.json文件来判断是目录还是包）。这个时候文件定位的步骤是这样的：

• 查看是否有package.json文件
  • 有
    • 读取package.json里的main字段的值作为文件
  • 没有
    • 寻找目录下的index作为文件（依次查找index.js、index.json、index.node）

如果package.json里没有main字段，那么也会将index作为文件，然后进行扩展名分析找到对应后缀的文件。

模块编译

我们开发中主要遇到的模块为json模块和js模块。

json模块编译

当我们require一个json模块的时候，实际上Node会帮我们使用fs.readFilcSync去读取对应的json文件，得到json字符串，然后调用JSON.parse解析得到json对象，再赋值给module.exports，然后给到require。

js模块编译

当我们require一个js模块的时候，比如

// index.js
const { add } = require('./add');

// add.js
exports.add = (a, b) => {
    return a + b;
}

这个时候发生了什么呢，为什么我们可以直接在模块里使用module、exports、require这些变量。这是因为Node在编译js模块的时候对模块的内容进行了首尾的包装。

比如add.js这个模块，实际编译的时候是会被包装成类似这样的结构：

(function(require, exports, module) {
  exports.add = (a, b) => {
    return a + b;
  }
  return module.exports;
})(require, module.exports, module)

即我们编写的js文件是会被包装成一个函数，我们编写的只是这个函数里的内容，Node后续的包装的过程对我们隐藏了。这个函数支持传入一些参数，其中就包括require、exports和module。

当编译完js文件后，就会执行这个文件，node会将对应的参数传给这个函数然后执行，并且返回module.exports值给到require函数。

以上就是Node实现CommonJs规范的基本流程。

更多node相关知识，请访问：nodejs 教程！

Das obige ist der detaillierte Inhalt vonErfahren Sie mehr über den Modulmechanismus von Node und sprechen Sie über den Modulimplementierungsprozess. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!