Une discussion approfondie sur la modularisation dans Node.js

Qu'est-ce que la modularité ? Cet article vous présentera la modularisation dans Node et présentera le mécanisme de chargement des modules. J'espère qu'il vous sera utile !

1. Le concept de base de la modularisation

1.1 Qu'est-ce que la modularisation

La modularisation fait référence au processus de division du système en plusieurs modules couche par couche de haut en bas lors de la résolution d'un problème complexe. Pour l'ensemble du système, les modules sont des unités qui peuvent être combinées, décomposées et remplacées.

La modularisation dans le domaine de la programmation consiste à suivre des règles fixes et à diviser un gros fichier en plusieurs petits modules indépendants et interdépendants.

Les avantages de la modularisation du code :

• Améliore la réutilisabilité du code

• Améliore la maintenabilité du code

• Peut réaliser un chargement à la demande

2. Modularité dans Node. js

2.1 Classification des modules dans Node.js

Dans Node.js, les modules sont divisés en 3 grandes catégories en fonction de leurs différentes sources, qui sont :

• Modules intégrés (Built- in sont officiellement fournis par Node.js, tels que fs, path, http, etc.)

• Modules personnalisés (chaque fichier .js créé par l'utilisateur est un module personnalisé)

• Modules tiers ( Les modules développés par des tiers ne sont pas des modules intégrés officiellement fournis, ni des modules personnalisés créés par les utilisateurs. Ils doivent être téléchargés avant utilisation)

2.2 Chargement des modules

Utilisez la puissante méthode require(), Vous pouvez charger les modules intégrés requis, les modules définis par l'utilisateur et les modules tiers à utiliser. Par exemple :

Remarque : Lorsque vous utilisez la méthode require() pour charger d'autres modules, le code du module chargé sera exécuté ; Le suffixe de fichier « .js » peut être omis lors du chargement de modules personnalisés.

2.3 Portée du module dans Node.js

• Qu'est-ce que la portée du module

Semblable à la portée de la fonction, les variables, méthodes et autres membres définis dans un module personnalisé ne peuvent être utilisés que dans le module actuel. Accessible dans le module, cette restriction d’accès au niveau du module est appelée portée du module.

• L'avantage de la portée du module

évite le problème de pollution des variables globales (si deux fichiers js sont importés avec des balises de script et que la même variable est définie dans les deux fichiers, la première sera écrasée par la seconde )

2.4 Partage de membres dans la portée du module en externe

1. Objet module

Il y a un objet module dans chaque module personnalisé .js, qui stocke les informations relatives au module actuel Imprimer comme suit :

2. Objet module.exports

Dans un module personnalisé, vous pouvez utiliser l'objet module.exports pour partager des membres au sein du module pour un usage externe.

Lorsque le monde extérieur utilise la méthode require() pour importer un module personnalisé, il obtient l'objet pointé par module.exports.

3. Points à noter lors du partage de membres

Lors de l'utilisation de la méthode require() pour importer un module, le résultat de l'importation sera toujours basé sur l'objet pointé par module.exports.

4. Objet exports

Le mot module.exports étant compliqué à écrire, afin de simplifier le code de partage des membres en externe, Node fournit l'objet exports. Par défaut, exports et module.exports pointent vers le même objet. Le résultat final partagé est toujours basé sur l'objet pointé par module.exports.

5. Malentendus dans l'utilisation de exports et module.exports

N'oubliez pas que lorsque require() un module, vous obtiendrez toujours l'objet pointé par module.exports :

Compréhension personnelle : exports et module .exports pointaient à l’origine vers le même objet. En montant simplement les données, cela pointe toujours vers le même objet. Les données montées via les exportations peuvent également être obtenues par le module require. Si une partie attribue une valeur (pointant vers un autre objet, alors elle ne pointe pas vers le même objet et le module require obtient l'objet pointé par module.exports, donc une fois qu'une partie change le pointeur, le module require n'obtiendra pas la valeur des exports.)

Remarque : Afin d'éviter toute confusion, il est recommandé de ne pas utiliser exports et module.exports en même temps dans le même module

2.5 Spécification de modularité dans Node.jsNode .js suit la spécification de modularité CommonJS, qui stipule les fonctionnalités du module et comment les modules dépendent les uns des autres.

Règles CommonJS :

(1) À l'intérieur de chaque module, la variable module représente le module actuel.

(2) La variable module est un objet et son attribut exports (c'est-à-dire module.exports) est l'interface externe.

(3) Le chargement d'un module charge en fait l'attribut module.exports du module. La méthode require() est utilisée pour charger les modules.

3. npm et packages

3.1 Packages

1. Que sont les packages tiers dans Node.js sont également appelés packages.

Tout comme ordinateurs et ordinateurs font référence à la même chose, les modules et packages tiers font référence au même concept, mais avec des noms différents.

2. Source du package

Différent des modules intégrés et des modules personnalisés dans Node.js, les packages sont développés par des personnes ou des équipes tierces et sont gratuits pour tout le monde.

Remarque : les packages de Node.js sont tous gratuits et open source, et peuvent être téléchargés et utilisés gratuitement sans payer.

3. Pourquoi des packages sont-ils nécessaires ? Étant donné que les modules intégrés de Node.js ne fournissent que quelques API de bas niveau, l'efficacité est très faible lors du développement de projets basés sur des modules intégrés.

Le package est encapsulé sur la base de modules intégrés, fournissant une API plus avancée et plus pratique, ce qui améliore considérablement l'efficacité du développement.

La relation entre les packages et les modules intégrés est similaire à la relation entre jQuery et les API intégrées du navigateur.

4. Où télécharger le package ?

Il existe une société informatique à l'étranger appelée npm, Inc. Cette société possède un site Web très célèbre :

www.npmjs.com/

, qui est la plus grande plateforme de partage de packages au monde. Vous pouvez rechercher n'importe quel package dont vous avez besoin sur ce site Web, à condition d'avoir suffisamment de patience !

Jusqu'à présent, plus de 11 millions de développeurs dans le monde ont développé et partagé plus de 1,2 million de packages pour notre usage via cette plateforme de partage de packages. npm, Inc. fournit un serveur sur registry.npmjs.org/ pour partager tous les packages en externe. Nous pouvons télécharger les packages dont nous avons besoin à partir de ce serveur.

Remarque : Recherchez le package dont vous avez besoin sur le

www.npmjs.com/

site Web

Téléchargez le package dont vous avez besoin depuis le registry.npmjs.org/ serveur

5. npm, Inc. fournit un outil de gestion de packages. Nous pouvons utiliser cet outil de gestion de packages pour télécharger les packages requis depuis le serveur

registry.npmjs.org/

pour une utilisation locale.

Le nom de cet outil de gestion de packages est Node Package Manager (appelé outil de gestion de packages npm). Cet outil de gestion de packages est installé sur l'ordinateur de l'utilisateur avec le package d'installation Node.js. Vous pouvez exécuter la commande npm -v dans le terminal pour vérifier le numéro de version de l'outil de gestion de packages npm installé sur votre ordinateur :

3.2 npm first experience

1 Installation des packages dans la commande du projet. Si vous souhaitez installer un package avec un nom spécifié dans le projet, vous devez exécuter la commande suivante :

npm install 包的完整名称

La commande d'emballage ci-dessus peut être abrégée au format suivant :

npm i 包的完整名称

2. après l'installation initiale du package

Une fois l'empaquetage initial terminé, il y aura un dossier supplémentaire appelé node_modules et un fichier de configuration package-lock.json sous le dossier du projet.

Parmi eux : Le dossier node_modules est utilisé pour stocker tous les packages installés dans le projet. Lorsque require() importe un package tiers, il recherche et charge le package à partir de ce répertoire. Le fichier de configuration package-lock.json est utilisé pour enregistrer les informations de téléchargement de chaque package dans le répertoire node_modules, telles que le nom du package, le numéro de version, l'adresse de téléchargement, etc.

Remarque : les programmeurs ne doivent modifier manuellement aucun code dans les fichiers node_modules ou package-lock.json, l'outil de gestion de packages npm les maintiendra automatiquement.

3. Installez la version spécifiée du package

Par défaut, lorsque vous utilisez la commande npm install pour installer un package, la dernière version du package sera automatiquement installée. Si vous devez installer un package d'une version spécifiée, vous pouvez spécifier la version spécifique via le symbole @ après le nom du package, par exemple :

npm i moment@2.22.2

4 Spécification de la version sémantique du package

Le numéro de version du package est. sous la forme de "décimal pointé" Défini, il y a trois chiffres au total, comme 2.24.0

La signification de chaque chiffre est la suivante :

第1位数字：大版本

第2位数字：功能版本

第3位数字：Bug修复版本

版本号提升的规则：只要前面的版本号增长了，则后面的版本号归零。

3.3 包管理配置文件

npm 规定，在项目根目录中，必须提供一个叫做 package.json 的包管理配置文件。用来记录与项目有关的一些配置信息。例如：

• 项目的名称、版本号、描述等

• 项目中都用到了哪些包

• 哪些包只在开发期间会用到

• 那些包在开发和部署时都需要用到

1、多人协作的问题

遇到的问题：第三方包的体积过大，不方便团队成员之间共享项目源代码。

解决方案：共享时剔除node_modules

2、如何记录项目中安装了哪些包

在项目根目录中，创建一个叫做 package.json 的配置文件，即可用来记录项目中安装了哪些包。从而方便剔除 node_modules 目录之后，在团队成员之间共享项目的源代码。

注意：今后在项目开发中，一定要把 node_modules 文件夹，添加到 .gitignore 忽略文件中。

3、快速创建 package.json

npm 包管理工具提供了一个快捷命令，可以在执行命令时所处的目录中，快速创建 package.json 这个包管理配置文件：

npm init -y

注意：

（1）上述命令只能在英文的目录下成功运行！所以，项目文件夹的名称一定要使用英文命名，不要使用中文，不能出现空格。

（2）@运行 npm install 命令安装包的时候，npm 包管理工具会自动把包的名称和版本号，记录到 package.json 中。

• 特别注意：现在的版本安装包会自动生成package.json。

4、dependencies 节点

package.json 文件中，有一个 dependencies 节点，专门用来记录您使用 npm install 命令安装了哪些包。

5、一次性安装所有的包

当我们拿到一个剔除了 node_modules 的项目之后，需要先把所有的包下载到项目中，才能将项目运行起来。 否则会报类似于下面的错误：

可以运行 npm install 命令（或 npm i）一次性安装所有的依赖包：

6、卸载包

可以运行 npm uninstall 命令，来卸载指定的包：

npm uninstall 具体的包名

注意：npm uninstall 命令执行成功后，会把卸载的包，自动从 package.json 的 dependencies 中移除掉。卸载没有简写。

7、devDependencies 节点

如果某些包只在项目开发阶段会用到，在项目上线之后不会用到，则建议把这些包记录到 devDependencies 节点中。

与之对应的，如果某些包在开发和项目上线之后都需要用到，则建议把这些包记录到 dependencies 节点中。

您可以使用如下的命令，将包记录到 devDependencies 节点中：

3.4 解决下包速度慢的问题

1、为什么下包速度慢

在使用 npm 下包的时候，默认从国外的 registry.npmjs.org/ 服务器进行下载，因此下包速度会很慢。

2、淘宝 NPM 镜像服务器

淘宝在国内搭建了一个服务器，专门把国外官方服务器上的包同步到国内的服务器，然后在国内提供下包的服务。从而极大的提高了下包的速度。

扩展： 镜像（Mirroring）是一种文件存储形式，一个磁盘上的数据在另一个磁盘上存在一个完全相同的副本即为镜像。

3、切换 npm 的下包镜像源

下包的镜像源，指的就是下包的服务器地址。

4、nrm

为了更方便的切换下包的镜像源，我们可以安装 nrm 这个小工具，利用 nrm 提供的终端命令，可以快速查看和切换下包的镜像源。

3.5 包的分类

使用 npm 包管理工具下载的包，共分为两大类，分别是：

• 项目包

• 全局包

1、项目包

那些被安装到项目的 node_modules 目录中的包，都是项目包。

项目包又分为两类，分别是：

• Packages de dépendances de développement (les packages enregistrés dans le nœud devDependencies ne seront utilisés que pendant le développement)

• Packages de dépendances de base (les packages enregistrés dans le nœud de dépendances seront utilisés pendant le développement et après la mise en ligne du projet) à)

2. Forfait global Lors de l'exécution de la commande npm install, si le paramètre -g est fourni, le package sera installé en tant que package global.

Le package global sera installé dans le répertoire utilisateur C:Users AppDataRoamingnpmnode_modules.

Remarque :

(1) Seuls les packages d'outils doivent être installés globalement. Parce qu'ils fournissent des commandes de terminal utiles.

(2) Pour déterminer si un package doit être installé globalement avant de pouvoir être utilisé, vous pouvez vous référer au mode d'emploi officiel.

3. i5ting_toc

i5ting_toc est un petit outil qui peut convertir des documents md en pages html. Les étapes à utiliser sont les suivantes :

3.6 Structure de package standard

Après avoir compris le concept des packages et comment. pour les télécharger, après avoir utilisé le package, examinons de plus près la structure interne du package.

Un package standardisé doit répondre aux trois exigences suivantes :

(1) Le package doit exister dans un répertoire séparé

(2) Le répertoire de niveau supérieur du package doit contenir le fichier de configuration de gestion package.json

(3 ) package.json doit contenir les trois attributs name, version et main, qui représentent respectivement le nom, le numéro de version et l'entrée du package.

Remarque : les trois exigences ci-dessus correspondent au format auquel une structure de package standardisée doit se conformer. Pour plus de contraintes, veuillez vous référer à l'URL suivante : https://yarnpkg.com/zh-Hans/docs/package-json

. 3.7 Développez votre propre package

1. Initialisez la structure de base du package

(1) Créez un nouveau dossier itheima-tools comme répertoire racine du package

(2) Dans le dossier itheima-tools, créez les trois Fichiers suivants :

• package.json (fichier de configuration de gestion des packages)

• index.js (fichier d'entrée du package)

• README.md (document de description du package)

2. Initialiser le package .json

Remarque : nom : est utilisé pour indiquer le nom de l'application ou de la version du logiciel ; indique la version actuelle ; définit le point d'entrée de la description de l'application ; la description de l'application/du progiciel ; mots-clés : cet attribut contient un tableau de mots-clés liés à la fonction du progiciel (aide à parcourir le site Web officiel du nœud pour trouver la licence du progiciel) ;

3. Écrivez la documentation du package

Le fichier README.md dans le répertoire racine du package est la documentation d'utilisation du package. Grâce à lui, nous pouvons rédiger à l'avance les instructions d'utilisation du package au format markdown pour la commodité de l'utilisateur.

Il n'y a aucune exigence obligatoire quant à ce qu'il faut écrire dans le fichier README tant que la fonction, l'utilisation, les précautions, etc. du package peuvent être clairement décrites.

Package de la version 3.8

1. Enregistrez un compte npm

(1) Visitez le site Web www.npmjs.com/, cliquez sur le bouton d'inscription pour accéder à l'interface utilisateur d'enregistrement

(2) Remplissez les informations relatives au compte : Nom complet, adresse e-mail publique, nom d'utilisateur, mot de passe

(3) Cliquez sur le bouton Créer un compte pour créer un compte

(4) Connectez-vous à votre adresse e-mail et cliquez sur le lien de vérification pour vérifier le compte

2. au compte npm

Une fois l'enregistrement du compte npm terminé, vous pouvez exécuter la commande de connexion npm dans le terminal, saisir le nom d'utilisateur et le mot de passe (le mot de passe est masqué et ne peut pas être vu, entrez simplement la bonne clé et appuyez sur Entrée) , e-mail et le code OTP envoyé à l'e-mail, puis vous pourrez vous connecter avec succès.

Remarque : Avant d'exécuter la commande de connexion npm, vous devez d'abord changer l'adresse du serveur du package sur le serveur officiel de npm. (Si vous utilisiez le serveur taobao auparavant, vous devez passer au serveur officiel npm) Sinon, la publication du package échouera !

3. Publiez le package sur npm

Après avoir basculé le terminal vers le répertoire racine du package, exécutez la commande npm submit pour publier le package sur npm (remarque : les noms des packages ne peuvent pas être les mêmes, vous pouvez allez sur le site officiel pour vérifier s'il existe des packages portant le même nom).

4. Supprimez le package publié

Exécutez la commande npm unpublish package name --force pour supprimer le package publié de npm.

Remarque :

(1) La commande npm unpublish ne peut supprimer que les packages publiés dans les 72 heures

(2) Les packages supprimés par npm unpublish ne peuvent pas être republiés dans les 24 heures

(3) Lors de la publication d'un package, vous devez être prudent et essayer de ne pas publier de packages dénués de sens sur npm !

4. Mécanisme de chargement du module

4.1 Prioriser le chargement à partir du cache

Le module sera mis en cache après le premier chargement. Cela signifie également qu'appeler require() plusieurs fois n'entraînera pas l'exécution multiple du code du module.

Remarque : qu'il s'agisse d'un module intégré, d'un module défini par l'utilisateur ou d'un module tiers, ils seront d'abord chargés à partir du cache, améliorant ainsi l'efficacité de chargement du module.

4.2 Mécanisme de chargement des modules intégrés

Les modules intégrés sont des modules officiellement fournis par Node.js, et les modules intégrés ont la priorité de chargement la plus élevée.

Par exemple : require('fs') renvoie toujours le module fs intégré, même s'il existe un package du même nom dans le répertoire node_modules, il est également appelé fs.

4.3 Mécanisme de chargement de module personnalisé

Lorsque vous utilisez require() pour charger un module personnalisé, vous devez spécifier un identifiant de chemin commençant par ./ ​​ou ../. Lors du chargement d'un module personnalisé, si aucun identifiant de chemin tel que ./ ou ../ n'est spécifié, le nœud le chargera en tant que module intégré ou module tiers.

En même temps, lors de l'utilisation de require() pour importer un module personnalisé, si l'extension de fichier est omise, Node.js essaiera de charger les fichiers suivants dans l'ordre :

(1) Charger selon le nom exact du fichier

(2) Complétez l'extension .js pour charger

(3) Complétez l'extension .json pour charger

(4) Complétez l'extension .node pour charger

(5) Le chargement a échoué et le terminal a signalé une erreur

4.4 Mécanisme de chargement de module tiers

Si l'identifiant de module transmis à require() n'est pas un module intégré et ne commence pas par './' ou '../', Node.js commencera par du module actuel. À partir du répertoire parent, essayez de charger des modules tiers à partir du dossier /node_modules.

Si le module tiers correspondant n'est pas trouvé, déplacez-vous vers le répertoire parent un niveau au-dessus et chargez-le jusqu'au répertoire racine du système de fichiers.

Par exemple, en supposant que require('tools') est appelé dans le fichier 'C:Usersitheimaprojectfoo.js', Node.js recherchera dans l'ordre suivant :

(1) C:Usersitheimaprojectnode_modulestools

(2) C : Usersitheimaprojectnode_modulestools

(3) C:Usersnode_modulestools

(4) C:node_modulestools

4.5 Répertoire en tant que module

Lorsque vous passez le répertoire comme identifiant de module à require() pour le chargement, il existe trois méthodes de chargement :

(1) Recherchez un fichier appelé package.json dans le répertoire en cours de chargement et recherchez l'attribut principal comme point d'entrée pour le chargement de require()

(2) S'il n'y a pas de fichier package.json dans le répertoire, ou le L'entrée principale n'existe pas ou ne peut pas être analysée, Node.js tentera de charger le fichier index.js dans le répertoire.

(3) Si les deux étapes ci-dessus échouent, Node.js imprimera un message d'erreur dans le terminal, signalant le module manquant : Erreur : Impossible de trouver le module 'xxx'

Cet article est reproduit à partir de : https:// juejin.cn/post/7083445004240158757

Pour plus de connaissances sur les nœuds, veuillez visiter : tutoriel nodejs !

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!