le nœud nécessite qu'est-ce que cela signifie

require in node est une fonction qui accepte un paramètre, le paramètre formel est nommé id et le type est String ; la fonction require peut importer des modules, des fichiers JSON et des fichiers locaux, le module est accessible via un chemin relatif à partir de ; "node_modules", Exporté depuis "module local" ou "fichier JSON", le chemin sera celui de la variable "__dirname" ou du répertoire de travail actuel.

L'environnement d'exploitation de ce tutoriel : système Windows 7, nodejs version 18.4.0, ordinateur Dell G3.

Que signifie le nœud requis ?

Utilisation spécifique de la fonction require dans Nodejs

Instructions

Cet article fait référence à la version du document du site officiel de Node est la v11.12.0.

Cet article analyse principalement les résultats obtenus lors de l'importation de fichiers JSON et js dans Nodejs. Il aborde également brièvement l'utilisation du module d'exportation module.exports et les exportations dans Nodejs.

Introduction

En train de lire le code source du webpack, j'ai vu la ligne de code suivante :

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

Cela mène à l'étude de require dans Nodejs.

require introduction

Dans la documentation Node.js, la documentation relative à require se trouve dans le répertoire Modules et fait partie du système modulaire Nodejs.

require est une fonction. Cette conclusion peut être vérifiée via typeof ou Object.prototype.toString.call() :

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

En imprimant directement require, vous pouvez constater qu'il existe plusieurs propriétés statiques montées sous la fonction require. Ces propriétés statiques peuvent également être trouvées dans le fichier require. documentation officielle de Nodejs Retrouvez les instructions pertinentes directement dans :

{ [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] } } }

exiger les attributs statiques de la fonction

J'ajouterai des détails plus tard ici.

require use

Vous pouvez voir les instructions suivantes sur require dans la documentation officielle du site Web :

require(id)# Ajouté dans : v0.1.13 nom ou chemin du module id Retours : contenu du module exporté Utilisé pour importer des modules, du JSON et des fichiers locaux. Les modules peuvent être importés à partir de node_modules et les fichiers JSON peuvent être importés à l'aide d'un chemin relatif (par exemple ./, ./foo, ./bar/baz, ../foo). sera résolu par rapport au répertoire nommé par __dirname (si défini) ou au répertoire de travail actuel

En même temps, trois méthodes d'utilisation de require sont données :

// 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');

À partir des documents ci-dessus, les informations suivantes peuvent être tirées. :

• require accepte un paramètre, le paramètre formel est nommé id et le type est String.

• La fonction require renvoie le contenu partout dans le module, et le type est arbitraire. La fonction

• require peut importer des modules, des fichiers JSON et des fichiers locaux. Les modules peuvent être exportés à partir de node_modules, de modules locaux, de fichiers JSON via un chemin relatif par rapport à la variable __dirname (si définie) ou au répertoire de travail actuel.

require practice

Ici, nous discuterons des conclusions pratiques de require en catégories.

require import JSON

JSON est une syntaxe pour sérialiser des objets, des tableaux, des nombres, des chaînes, des booléens et null .

Au début de l'article, il a été mentionné que l'attribut version dans le fichier package.json est lu via le fichier require("./package.json"). Ici, nous allons essayer d'importer le fichier info.json et d'afficher les informations associées.

Le répertoire de structure du fichier est le suivant :

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

Modifiez le contenu du fichier info.json en :

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

Dans info.json, il contient des chaînes, des valeurs booléennes, des valeurs nulles, des nombres, des objets et des tableaux.

Modifiez le contenu de index.js comme suit et exécutez la commande node index.js dans le terminal actuel, et obtenez les résultats suivants :

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 } ]

Vous pouvez voir que lorsque require importe un fichier JSON, un objet est renvoyé, et Nodejs peut accéder directement à toutes les propriétés de l'objet, y compris String, Boolean, Number, Null, Object et Array. Mon hypothèse personnelle est qu'une méthode similaire à JSON.parse() peut être utilisée ici.

Grâce à cette conclusion, nous avons également eu une idée, qui est de transmettre le fichier JSON via la méthode require pour lire certaines valeurs. Par exemple, au début de l'article, webpack a obtenu la valeur de la version en lisant le package. Fichier .json.

nécessite d'importer des fichiers js locaux

Le répertoire de la structure du fichier est le suivant :

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

Dans le fichier index.js, module_a et module_b sont importés dans l'ordre et les valeurs attribuées, puis ces deux variables sont imprimées, le le contenu est le suivant :

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结束执行 ***")

Dans le fichier module_a, module.exports ou exports n'est pas spécifié, mais une instruction d'exécution asynchrone setTimeout est ajoutée, le contenu est le suivant :

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

Dans le fichier module_b, module.exports est spécifié (il peut également être remplacé par exports.name, mais il ne peut pas être utilisé directement, exports est égal à un certain objet, car exports et module.exports pointent en fait vers une adresse et font référence au même objet. Si exports est utilisé pour égaler d'autres types de référence, il ne pointera plus vers module.exports et le contenu de module.exports ne peut pas être modifié. ), le contenu est le suivant :

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

Exécutez le nœud index.js dans le terminal du répertoire actuel et obtenez le résultat suivant :

*** 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视频教程》

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!