Knoten erfordern, was das bedeutet

require in node ist eine Funktion, die einen Parameter akzeptiert, der formale Parameter heißt id und der Typ ist String; die require-Funktion kann Module, JSON-Dateien importieren und auf das Modul kann über einen relativen Pfad zugegriffen werden „node_modules“, exportiert aus „lokalem Modul“ oder „JSON-Datei“, der Pfad gilt für die Variable „__dirname“ oder das aktuelle Arbeitsverzeichnis.

Die Betriebsumgebung dieses Tutorials: Windows 7-System, NodeJS-Version 18.4.0, Dell G3-Computer.

Was bedeutet Knoten erforderlich?

Spezifische Verwendung der Require-Funktion in Nodejs

Anleitung

Dieser Artikel bezieht sich auf die Version des offiziellen Node-Website-Dokuments, Version 11.12.0.

Dieser Artikel analysiert hauptsächlich die Ergebnisse, die beim Importieren von JSON- und JS-Dateien in Nodejs erzielt werden. Er geht auch kurz auf die Verwendung des Modulexports module.exports und -exporte in Nodejs ein.

Einführung

Beim Lesen des Webpack-Quellcodes sah ich die folgende Codezeile:

const version = require("../package.json").version

Dies führt zur Untersuchung der Anforderungen in Nodejs.

require-Einführung

In der Node.js-Dokumentation befindet sich die relevante Dokumentation für require im Modules-Verzeichnis und ist Teil des Nodejs-Modulsystems.

require ist eine Funktion. Diese Schlussfolgerung kann durch typeof oder Object.prototype.toString.call() überprüft werden:

console.log(require) // 输出：Function
console.log(Object.prototype.toString.call(require) // 输出：[object Function]

Durch direktes Drucken von require können Sie feststellen, dass unter der require-Funktion mehrere statische Eigenschaften gemountet sind. Diese statischen Eigenschaften können auch in gefunden werden Offizielle Dokumentation von Nodejs. Die relevanten Anweisungen finden Sie direkt in:

{ [Function: require]
 resolve: { [Function: resolve] paths: [Function: paths] },
 main:
  Module {
   id: '.',
   exports: {},
   parent: null,
   filename: '/Users/bjhl/Documents/webpackSource/index.js',
   loaded: false,
   children: [],
   paths:
   [ '/Users/bjhl/Documents/webpackSource/node_modules',
    '/Users/bjhl/Documents/node_modules',
    '/Users/bjhl/node_modules',
    '/Users/node_modules',
    '/node_modules' ] },
 extensions:
  [Object: null prototype] { '.js': [Function], '.json': [Function], '.node': [Function] },
 cache:
  [Object: null prototype] {
   '/Users/bjhl/Documents/webpackSource/index.js':
   Module {
    id: '.',
    exports: {},
    parent: null,
    filename: '/Users/bjhl/Documents/webpackSource/index.js',
    loaded: false,
    children: [],
    paths: [Array] } } }

statische Funktionsattribute erforderlich

Ich werde später hier Details hinzufügen.

require-Verwendung

Die folgenden Anweisungen zu require finden Sie in der offiziellen Website-Dokumentation:

require(id)# Hinzugefügt in: v0.1.13 id Modulname oder -pfad Rückgabe: exportierter Modulinhalt Verwendet Zum Importieren von Modulen, JSON und lokalen Dateien können lokale Module und JSON-Dateien über einen relativen Pfad (z. B. ./, ./foo, ./bar/baz, ../foo) importiert werden wird anhand des Verzeichnisses namens __dirname (falls definiert) oder des aktuellen Arbeitsverzeichnisses aufgelöst.

Gleichzeitig sind drei Methoden zur Verwendung von require angegeben:

// Importing a local module:
const myLocalModule = require('./path/myLocalModule');

// Importing a JSON file:
const jsonData = require('./path/filename.json');

// Importing a module from node_modules or Node.js built-in module:
const crypto = require('crypto');

Aus den oben genannten Dokumenten können die folgenden Informationen entnommen werden :

• require akzeptiert einen Parameter, der formale Parameter heißt id und der Typ ist String.

• Die Funktion require gibt den Inhalt überall im Modul zurück und der Typ ist beliebig. Die Funktion „require“ kann Module, JSON-Dateien und lokale Dateien importieren. Module können aus node_modules, lokalen Modulen und JSON-Dateien über einen relativen Pfad gegenüber der Variablen __dirname (falls definiert) oder dem aktuellen Arbeitsverzeichnis exportiert werden.

Praxis erforderlich

Hier besprechen wir die praktischen Schlussfolgerungen von „Require in Category“.

Import JSON erforderlich

JSON ist eine Syntax zum Serialisieren von Objekten, Arrays, Zahlen, Zeichenfolgen, Booleschen Werten und Null.
Am Anfang des Artikels wurde erwähnt, dass das Versionsattribut in der Datei package.json über die Datei require("./package.json") gelesen wird. Hier werden wir versuchen, die Datei info.json zu importieren und zugehörige Informationen anzuzeigen.

Das Dateistrukturverzeichnis lautet wie folgt:

.
├── index.js
└── info.json

Ändern Sie den Inhalt der Datei info.json wie folgt:

{
  "name": "myInfo",
  "hasFriend": true,
  "salary": null,
  "version": "v1.0.0",
  "author": {
    "nickname": "Hello Kitty",
    "age": 20,
    "friends": [
      {
        "nickname": "snowy",
        "age": 999
      }
    ]
  }
}

In info.json enthält es Zeichenfolgen, boolesche Werte, Nullen, Zahlen, Objekte und Arrays.

Ändern Sie den Inhalt von index.js wie folgt und führen Sie den Befehl node index.js im aktuellen Terminal aus und erhalten Sie die folgenden Ergebnisse:

const info = require("./info.json")
console.log(Object.prototype.toString.call(info)) // [object Object]
console.log(info.version) // v1.0.0
console.log(info.hasFriend) // true
console.log(info.salary) // null
console.log(info.author.nickname) // Hello Kitty
console.log(info.author.friends) // [ { nickname: 'snowy', age: 999 } ]

Sie können sehen, dass beim Importieren einer JSON-Datei durch require ein Objekt zurückgegeben wird und Nodejs können direkt auf alle Eigenschaften im Objekt zugreifen, einschließlich String, Boolean, Number, Null, Object und Array. Meine persönliche Vermutung ist, dass hier eine ähnliche Methode wie JSON.parse() verwendet werden könnte.

Durch diese Schlussfolgerung sind wir auch auf die Idee gekommen, die JSON-Datei über die Anforderungsmethode zu übergeben, um bestimmte Werte zu lesen. Am Anfang des Artikels hat Webpack beispielsweise den Versionswert durch Lesen des Pakets erhalten .json-Datei.

lokale js-Dateien importieren müssen

Das Dateistrukturverzeichnis ist wie folgt:

.
├── index.js
├── module_a.js
└── module_b.js

In der Datei index.js werden module_a und module_b der Reihe nach importiert und ihnen Werte zugewiesen, und dann werden diese beiden Variablen gedruckt Der Inhalt lautet wie folgt:

console.log("*** index.js开始执行 ***")
const module_a = require("./module_a")
const module_b = require("./module_b")
console.log(module_a, "*** 打印module_a ***")
console.log(module_b, "*** 打印module_b ***")
console.log("*** index.js结束执行 ***")

In der Datei module_a ist module.exports oder exports nicht angegeben, aber eine asynchrone Ausführungsanweisung setTimeout wurde hinzugefügt. Der Inhalt lautet wie folgt:

console.log("** module_a开始执行 **")
let name = "I'm module_a"
setTimeout(() => {
  console.log(name, "** setTimeout打印a的名字 **")
}, 0)
console.log("** module_a结束执行 **")

In der Datei module_b ist module.exports angegeben (Er kann auch durch „exports.name“ ersetzt werden, kann jedoch nicht direkt verwendet werden. „exports“ entspricht einem bestimmten Objekt, da „exports“ und „module.exports“ tatsächlich auf eine Adresse verweisen und auf dasselbe Objekt verweisen. Wenn „exports“ verwendet wird, um anderen zu entsprechen Referenztypen, es wird nicht mehr auf module.exports verweisen und der Inhalt in module.exports kann nicht geändert werden), der Inhalt ist wie folgt:

console.log("** module_b开始执行 **")
let name = "I'm module_b"
console.log(name, "** 打印b的名字 **")
module.exports = {
  name
}
console.log("** module_b结束执行 **")

Führen Sie node index.js im aktuellen Verzeichnisterminal aus und erhalten Sie die folgende Ausgabe:

*** index.js开始执行 ***
** module_a开始执行 **
** module_a结束执行 **
** module_b开始执行 **
I am module_b ** 打印b的名字 **
** module_b结束执行 **
{} '*** 打印module_a ***'
{ name: 'I am module_b' } '*** 打印module_b ***'
*** index.js结束执行 ***
I am module_a ** setTimeout打印a的名字 **

通过以上执行结果可以得出结论：

• require某个js文件时，如果未通过exports或者module.exports指定导出内容，则require返回的结果是一个空对象；反之可以通过module.export或者给exports属性赋值来导出指定内容。

• require某个js文件时，该文件会立即sync执行。

require导入模块

我们先选择一个npm包——cors。 进入文件夹，运行一下命令：

npm init -y // 初始化
echo -e "let cors = require(\"cors\")\nconsole.log(cors)" > index.js // 生成index.js文件
npm install cors --save // 安装cors包

文件结构如下(...处省略了其他的模块):

.
├── index.js
├── node_modules
│  ├── cors
│  │  ├── CONTRIBUTING.md
│  │  ├── HISTORY.md
│  │  ├── LICENSE
│  │  ├── README.md
│  │  ├── lib
│  │  │  └── index.js
│  │  └── package.json
│  │  ...
├── package-lock.json
└── package.json

index.js中的内容如下：

let cors = require("cors")
console.log(cors)

运行 node index.js ，得出以下结果：

[Function: middlewareWrapper]

找到node_modules下的cors模块文件夹，观察cros模块中的package.json文件，找到main字段： "main": "./lib/index.js" ，找到main字段指向的文件，发现这是一个IIFE，在IIFE中的代码中添加，console.log("hello cors")，模拟代码结构如下：

(function () {
  'use strict';
  console.log("hello cors"); // 这是手动添加的代码
  ...
  function middlewareWrapper(o) {
    ...
  }
  module.exports = middlewareWrapper;
})()

再次运行 node index.js ，得出以下结果：

hello cors
[Function: middlewareWrapper]

为什么会打印出 hello cors 呢？因为require模块的时候，引入的是该模块package.json文件中main字段指向的文件。而这个js文件会自动执行，跟require引用本地js文件是相同的。

packjson文档

在npm的官方网站中可以找到关于package.json中的main字段定义。

main   The main field is a module ID that is the primary entry point to your program. That is, if your package is named foo, and a user installs it, and then does require("foo"), then your main module's exports object will be returned.   This should be a module ID relative to the root of your package folder   For most modules, it makes the most sense to have a main script and often not much else.

在以上说明中可以得出以下结论：

• main字段是一个模块ID，是程序的主入口。

• 当使用require("xxx")的时候，导入的是main字段对应的js文件里的module.exports。

所以require导入模块的时候，是运行的对应模块package.json中main字段指定的文件。

推荐学习：《node视频教程》

Das obige ist der detaillierte Inhalt vonKnoten erfordern, was das bedeutet. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!