Alai

L’auteur a sélectionné l’Open Internet/Free Speech Fund pour recevoir un don dans le cadre du programme Write for DOnations.

Introduction

En Node.js, un module est une collection de fonctions et d’objets JavaScript qui peuvent être utilisés par des applications externes. Décrire un morceau de code comme un module fait moins référence à ce qu’est le code qu’à ce qu’il fait – tout fichier ou collection de fichiers Node.js peut être considéré comme un module si ses fonctions et ses données sont rendues utilisables par des programmes externes.

Parce que les modules fournissent des unités de fonctionnalité qui peuvent être réutilisées dans de nombreux programmes plus importants, ils vous permettent de créer des applications faiblement couplées qui évoluent avec la complexité, et vous ouvrent la porte pour partager votre code avec d’autres développeurs. La capacité d’écrire des modules qui exportent des fonctions et des données utiles vous permettra de contribuer à la communauté Node.js au sens large – en fait, tous les paquets que vous utilisez sur npm ont été regroupés et partagés en tant que modules. Cela fait de la création de modules une compétence essentielle pour un développeur Node.

Dans ce tutoriel, vous allez créer un module Node.js qui suggère quelle couleur les développeurs web devraient utiliser dans leurs conceptions. Vous développerez le module en stockant les couleurs sous forme de tableau, et en fournissant une fonction pour en récupérer une au hasard. Ensuite, vous parcourrez les différentes façons d’importer un module dans une application Node.js.

Prérequis

• Vous aurez besoin de Node.js et de npm installés sur votre environnement de développement. Ce tutoriel utilise la version 10.17.0. Pour l’installer sur macOS ou Ubuntu 18.04, suivez les étapes de la section Comment installer Node.js et créer un environnement de développement local sur macOS ou la section Installation à l’aide d’un PPA de la section Comment installer Node.js sur Ubuntu 18.04. En ayant Node.js installé, vous aurez également npm installé ; ce tutoriel utilise la version 6.11.3.
• Vous devriez également être familier avec le fichier package.json, et une expérience avec les commandes npm serait également utile. Pour acquérir cette expérience, suivez Comment utiliser les modules Node.js avec npm et package.json, en particulier l’étape 1 – Créer un fichier package.json.
• Il sera également utile d’être à l’aise avec le REPL (Read-Evaluate-Print-Loop) de Node.js. Vous l’utiliserez pour tester votre module. Si vous avez besoin de plus d’informations à ce sujet, lisez notre guide sur la façon d’utiliser le Node.js REPL.

Étape 1 – Création d’un module

Cette étape vous guidera dans la création de votre premier module Node.js. Votre module contiendra une collection de couleurs dans un tableau et fournira une fonction pour en obtenir une au hasard. Vous utiliserez la propriété exports intégrée à Node.js pour rendre la fonction et le tableau disponibles pour les programmes externes.

D’abord, vous commencerez par décider quelles données sur les couleurs vous stockerez dans votre module. Chaque couleur sera un objet qui contient une propriété name que les humains peuvent facilement identifier, et une propriété code qui est une chaîne contenant un code couleur HTML. Les codes de couleur HTML sont des nombres hexadécimaux à six chiffres qui vous permettent de modifier la couleur des éléments d’une page Web. Vous pouvez en savoir plus sur les codes de couleur HTML en lisant cet article Codes et noms de couleur HTML.

Vous déciderez ensuite des couleurs que vous souhaitez prendre en charge dans votre module. Votre module contiendra un tableau appelé allColors qui contiendra six couleurs. Votre module comprendra également une fonction appelée getRandomColor() qui sélectionnera aléatoirement une couleur dans votre tableau et la retournera.

Dans votre terminal, créez un nouveau dossier appelé colors et déplacez-vous dedans :

 
mkdir colors
 
cd colors
 

Initialisez npm afin que d’autres programmes puissent importer ce module plus tard dans le tutoriel :

npm init -y 

Vous avez utilisé le drapeau -y pour sauter les invites habituelles pour personnaliser votre package.json. S’il s’agissait d’un module que vous souhaitiez publier sur npm, vous répondriez à toutes ces invites avec des données pertinentes, comme expliqué dans Comment utiliser les modules Node.js avec npm et package.json.

Dans ce cas, votre sortie sera :

Output
{ "name": "colors", "version": "1.0.0", "description": "", "main": "index.js", "scripts": { "test": "echo \"Error: no test specified\" && exit 1" }, "keywords": , "author": "", "license": "ISC"}

Maintenant, ouvrez un éditeur de texte en ligne de commande tel que nano et créez un nouveau fichier qui servira de point d’entrée pour votre module :

nano index.js

Votre module fera plusieurs choses. Tout d’abord, vous allez définir une classe Color. Votre classe Color sera instanciée avec son nom et son code HTML. Ajoutez les lignes suivantes pour créer la classe :

class Color { constructor(name, code) { this.name = name; this.code = code; }}

Maintenant que vous avez votre structure de données pour Color, ajoutez quelques instances dans votre module. Écrivez le tableau surligné suivant dans votre fichier:

class Color { constructor(name, code) { this.name = name; this.code = code; }}const allColors = ;

Enfin, entrez une fonction qui sélectionne aléatoirement un élément dans le tableau allColors que vous venez de créer:

class Color { constructor(name, code) { this.name = name; this.code = code; }}const allColors = ;exports.getRandomColor = () => { return allColors;}exports.allColors = allColors;

Le mot-clé exports fait référence à un objet global disponible dans chaque module Node.js. Toutes les fonctions et tous les objets stockés dans l’objet exports d’un module sont exposés lorsque d’autres modules Node.js l’importent. La fonction getRandomColor() a été créée directement sur l’objet exports, par exemple. Vous avez ensuite ajouté une propriété allColors à l’objet exports qui fait référence au tableau de constantes locales allColors créé plus tôt dans le script.

Lorsque d’autres modules importent ce module, les fonctions allColors et getRandomColor() seront toutes deux exposées et disponibles à l’utilisation.

Enregistrez et quittez le fichier.

Jusqu’à présent, vous avez créé un module qui contient un tableau de couleurs et une fonction qui en renvoie une au hasard. Vous avez également exporté le tableau et la fonction, afin que les programmes externes puissent les utiliser. Dans l’étape suivante, vous allez utiliser votre module dans d’autres applications pour démontrer les effets de export.

Etape 2 – Tester votre module avec le REPL

Avant de construire une application complète, prenez un moment pour confirmer que votre module fonctionne. Dans cette étape, vous utiliserez le REPL pour charger le module colors. Pendant que vous êtes dans le REPL, vous allez appeler la fonction getRandomColor() pour voir si elle se comporte comme vous l’attendez.

Démarrez le REPL de Node.js dans le même dossier que le fichier index.js:

node

Lorsque le REPL aura démarré, vous verrez l’invite >. Cela signifie que vous pouvez entrer du code JavaScript qui sera immédiatement évalué. Si vous souhaitez en savoir plus à ce sujet, suivez notre guide sur l’utilisation du REPL.

Premièrement, entrez ce qui suit :

colors = require('./index');

Dans cette commande, require() charge le module colors à son point d’entrée. Lorsque vous appuyez sur ENTER, vous obtenez:

Output
{ getRandomColor: , allColors: }

Le REPL nous montre la valeur de colors, qui sont toutes les fonctions et les objets importés du fichier index.js. Lorsque vous utilisez le mot clé require, Node.js renvoie tout le contenu à l’intérieur de l’objet exports d’un module.

Rappellez-vous que vous avez ajouté getRandomColor() et allColors à exports dans le module colors. Pour cette raison, vous les voyez tous les deux dans le REPL lorsqu’ils sont importés.

A l’invite, testez la fonction getRandomColor():

colors.getRandomColor();

Vous serez invité avec une couleur aléatoire:

Output
Color { name: 'groovygray', code: '#D7DBDD' }

Comme l’indice est aléatoire, votre sortie peut varier. Maintenant que vous avez confirmé que le module colors fonctionne, quittez le REPL de Node.js:

.exit

Cela vous ramènera à votre ligne de commande du terminal.

Vous venez de confirmer que votre module fonctionne comme prévu en utilisant le REPL. Ensuite, vous allez appliquer ces mêmes concepts et charger votre module dans une application, comme vous le feriez dans un projet réel.

Etape 3 – Enregistrer votre module local comme une dépendance

Lorsque vous avez testé votre module dans le REPL, vous l’avez importé avec un chemin relatif. Cela signifie que vous avez utilisé l’emplacement du fichier index.js par rapport au répertoire de travail pour obtenir son contenu. Bien que cela fonctionne, il est généralement préférable d’importer les modules par leur nom afin que l’importation ne soit pas interrompue lorsque le contexte est modifié. Dans cette étape, vous installerez le module colors avec le module local install de npm.

Mettez en place un nouveau module Node.js en dehors du dossier colors. Tout d’abord, allez dans le répertoire précédent et créez un nouveau dossier :

 
cd ..
 
mkdir really-large-application
 

Passez maintenant dans votre nouveau projet :

cd really-large-application

Comme pour le module colors, initialisez votre dossier avec npm :

npm init -y 

Les package.json suivants seront générés :

Output
{ "name": "really-large-application", "version": "1.0.0", "description": "", "main": "index.js", "scripts": { "test": "echo \"Error: no test specified\" && exit 1" }, "keywords": , "author": "", "license": "ISC"}

Maintenant, installez votre module colors et utilisez le drapeau --save pour qu’il soit enregistré dans votre fichier package.json:

npm install --save ../colors

Vous venez d’installer votre module colors dans le nouveau projet. Ouvrez le fichier package.json pour voir la nouvelle dépendance locale:

nano package.json

Vous constaterez que les lignes surlignées suivantes ont été ajoutées:

{ "name": "really-large-application", "version": "1.0.0", "description": "", "main": "index.js", "scripts": { "test": "echo \"Error: no test specified\" && exit 1" }, "keywords": , "author": "", "license": "ISC", "dependencies": { "colors": "file:../colors" }}

Exituez le fichier.

Le module colors a été copié dans votre répertoire node_modules. Vérifiez qu’il y est avec la commande suivante :

ls node_modules

Cela donnera la sortie suivante :

Output
colors

Utilisez votre module local installé dans ce nouveau programme. Ré-ouvrez votre éditeur de texte et créez un autre fichier JavaScript:

nano index.js

Votre programme importera d’abord le module colors. Il choisira ensuite une couleur au hasard en utilisant la fonction getRandomColor() fournie par le module. Enfin, il imprimera un message sur la console qui indique à l’utilisateur la couleur à utiliser.

Entrez le code suivant dans index.js:

const colors = require('colors');const chosenColor = colors.getRandomColor();console.log(`You should use ${chosenColor.name} on your website. It's HTML code is ${chosenColor.code}`);

Enregistrez et quittez ce fichier.

Votre application indiquera maintenant à l’utilisateur une option de couleur aléatoire pour un composant de site web.

Exécutez ce script avec :

node index.js

Votre sortie sera similaire à :

Output
You should use leafygreen on your website. It's HTML code is #48C9B0

Vous avez maintenant installé avec succès le module colors et vous pouvez le gérer comme n’importe quel autre paquet npm utilisé dans votre projet. Cependant, si vous avez ajouté plus de couleurs et de fonctions à votre module colors local, vous devrez exécuter npm update dans vos applications pour pouvoir utiliser les nouvelles options. Dans l’étape suivante, vous utiliserez le module local colors d’une autre manière et obtiendrez des mises à jour automatiques lorsque le code du module change.

Étape 4 – Lier un module local

Si votre module local est en développement lourd, la mise à jour continue des paquets peut être fastidieuse. Une alternative serait de lier les modules. Lier un module garantit que toute mise à jour du module est immédiatement reflétée dans les applications qui l’utilisent.

Dans cette étape, vous allez lier le module colors à votre application. Vous allez également modifier le module colors et confirmer que ses changements les plus récents fonctionnent dans l’application sans avoir à réinstaller ou à mettre à niveau.

D’abord, désinstallez votre module local :

npm un colors

npm lie les modules en utilisant des liens symboliques (ou symlinks), qui sont des références qui pointent vers des fichiers ou des répertoires dans votre ordinateur. La liaison d’un module se fait en deux étapes :

1. Créer un lien global vers le module. npm crée un lien symbolique entre votre répertoire global node_modules et le répertoire de votre module. Le répertoire global node_modules est l’emplacement dans lequel tous vos paquets npm à l’échelle du système sont installés (tout paquet que vous installez avec le drapeau -g).
2. Créer un lien local. npm crée un lien symbolique entre votre projet local qui utilise le module et le lien global du module.

D’abord, créez le lien global en retournant dans le dossier colors et en utilisant la commande link:

 
cd ../colors
 
sudo npm link
 

Une fois terminé, votre shell affichera :

Output
/usr/local/lib/node_modules/colors -> /home/sammy/colors

Vous venez de créer un lien symbolique dans votre dossier node_modules vers votre répertoire colors.

Retournez au dossier really-large-application et liez le paquet :

 
cd ../really-large-application
 
sudo npm link colors
 

Vous recevrez une sortie similaire à la suivante :

Output
/home/sammy/really-large-application/node_modules/colors -> /usr/local/lib/node_modules/colors -> /home/sammy/colors

Note : Si vous souhaitez taper un peu moins, vous pouvez utiliser ln au lieu de link. Par exemple, npm ln colors aurait fonctionné exactement de la même manière.

Comme le montre la sortie, vous venez de créer un lien symbolique du répertoire node_modules local de votre really-large-application vers le lien symbolique colors dans votre node_modules global, qui pointe vers le répertoire réel avec le module colors.

Le processus de liaison est terminé. Exécutez votre fichier pour vous assurer qu’il fonctionne toujours :

node index.js

Votre sortie sera similaire à :

Output
You should use sunkissedyellow on your website. It's HTML code is #F4D03F

Votre fonctionnalité de programme est intacte. Ensuite, testez que les mises à jour sont immédiatement appliquées. Dans votre éditeur de texte, rouvrez le fichier index.js du module colors:

 
cd ../colors
 
nano index.js
 

Ajoutez maintenant une fonction qui sélectionne la toute meilleure nuance de bleu qui existe. Elle ne prend aucun argument, et renvoie toujours le troisième élément du tableau allColors. Ajoutez ces lignes à la fin du fichier:

class Color { constructor(name, code) { this.name = name; this.code = code; }}const allColors = ;exports.getRandomColor = () => { return allColors; }exports.allColors = allColors;exports.getBlue = () => { return allColors;}

Enregistrez et quittez le fichier, puis rouvrez le fichier index.js dans le dossier really-large-application:

 
cd ../really-large-application
 
nano index.js
 

Faites un appel à la fonction getBlue() nouvellement créée, et imprimez une phrase avec les propriétés de la couleur. Ajoutez ces déclarations à la fin du fichier:

const colors = require('colors');const chosenColor = colors.getRandomColor();console.log(`You should use ${chosenColor.name} on your website. It's HTML code is ${chosenColor.code}`);const favoriteColor = colors.getBlue();console.log(`My favorite color is ${favoriteColor.name}/${favoriteColor.code}, btw`);

Enregistrez et quittez le fichier.

Le code utilise maintenant la fonction getBlue() nouvellement créée. Exécutez le fichier comme précédemment :

node index.js

Vous obtiendrez une sortie comme :

Output
You should use brightred on your website. It's HTML code is #E74C3CMy favorite color is skyblue/#5DADE2, btw

Votre script a pu utiliser la dernière fonction de votre module colors, sans avoir à exécuter npm update. Cela facilitera les modifications de cette application en cours de développement.

Au fur et à mesure que vous écrivez des applications plus grandes et plus complexes, pensez à la façon dont le code connexe peut être regroupé en modules, et à la façon dont vous voulez que ces modules soient configurés. Si votre module ne va être utilisé que par un seul programme, il peut rester dans le même projet et être référencé par un chemin relatif. Si votre module est destiné à être partagé séparément par la suite ou s’il se trouve à un endroit très différent du projet sur lequel vous travaillez actuellement, l’installation ou la liaison peut s’avérer plus viable. Les modules en cours de développement bénéficient également des mises à jour automatiques de la liaison. Si le module n’est pas en développement actif, l’utilisation de npm install peut être l’option la plus facile.

Conclusion

Dans ce tutoriel, vous avez appris qu’un module Node.js est un fichier JavaScript contenant des fonctions et des objets qui peuvent être utilisés par d’autres programmes. Vous avez ensuite créé un module et attaché vos fonctions et objets à l’objet global exports pour les rendre disponibles aux programmes externes. Enfin, vous avez importé ce module dans un programme, démontrant ainsi comment les modules s’assemblent en de plus grandes applications.

Maintenant que vous savez comment créer des modules, pensez au type de programme que vous voulez écrire et décomposez-le en divers composants, en gardant chaque ensemble unique d’activités et de données dans leurs propres modules. Plus vous vous exercerez à écrire des modules, plus vous serez à même d’écrire des programmes Node.js de qualité au cours de votre apprentissage. Pour travailler à travers un exemple d’une application Node.js qui utilise des modules, voir notre tutoriel Comment configurer une application Node.js pour la production sur Ubuntu 18.04.