L'auteur a choisi le Open Internet/Free Speech Fund pour recevoir un don dans le cadre du programme Write for DOnations.

Introduction

Dans 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 renvoie moins à ce qu'est le code qu'à ce qu'il fait : tout fichier ou ensemble 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.

Étant donné 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 s'adaptent à la complexité, et vous offrent la possibilité de partager votre code avec d'autres développeurs. Le fait de pouvoir é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 packages que vous utilisez sur npm ont été regroupés et partagés sous forme de modules. Cela fait de la création de modules une compétence essentielle pour un développeur Node.js.

Dans ce tutoriel, vous allez créer un module Node.js qui suggère les couleurs que 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 permettant d'en récupérer une au hasard. Ensuite, vous passerez en revue les différentes façons d'importer un module dans une application Node.js.

Conditions préalables

É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 de Node.js pour rendre la fonction et le tableau disponibles aux programmes externes.

Tout d'abord, vous allez commencer par décider quelles données sur les couleurs vous allez stocker 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 de couleur HTML. Les codes de couleur HTML sont des nombres hexadécimaux à six chiffres qui vous permettent de changer la couleur des éléments d'une page Web. Vous pouvez en apprendre davantage sur les codes de couleur HTML en lisant l'article Codes et noms de couleurs HTML.

Vous déciderez ensuite des couleurs que vous voulez 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 renverra.

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

  • 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é l'indicateur -y afin d'ignorer 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 les données pertinentes, comme expliqué dans le tutoriel 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 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 :

~/colors/index.js
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. Inscrivez dans votre fichier le tableau surligné suivant :

~/colors/index.js
class Color {
  constructor(name, code) {
    this.name = name;
    this.code = code;
  }
}

const allColors = [
  new Color('brightred', '#E74C3C'),
  new Color('soothingpurple', '#9B59B6'),
  new Color('skyblue', '#5DADE2'),
  new Color('leafygreen', '#48C9B0'),
  new Color('sunkissedyellow', '#F4D03F'),
  new Color('groovygray', '#D7DBDD'),
];

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

~/colors/index.js
class Color {
  constructor(name, code) {
    this.name = name;
    this.code = code;
  }
}

const allColors = [
  new Color('brightred', '#E74C3C'),
  new Color('soothingpurple', '#9B59B6'),
  new Color('skyblue', '#5DADE2'),
  new Color('leafygreen', '#48C9B0'),
  new Color('sunkissedyellow', '#F4D03F'),
  new Color('groovygray', '#D7DBDD'),
];

exports.getRandomColor = () => {
  return allColors[Math.floor(Math.random() * allColors.length)];
}

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 par exemple été créée directement sur l'objet exports. Vous avez ensuite ajouté une propriété allColors à l'objet exports qui fait référence au tableau constant local allColors créé plus tôt dans le script.

Lorsque d'autres modules importeront ce module, allColors et getRandomColor() seront tous deux exposés 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 renvoie une couleur de manière aléatoire. Vous avez également exporté le tableau et la fonction, afin que des programmes externes puissent les utiliser. Dans l'étape suivante, vous utiliserez votre module dans d'autres applications pour démontrer les effets de export.

Étape 2 — Test de 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. Une fois dans le REPL, vous appellerez la fonction getRandomColor() pour voir si elle se comporte comme vous vous y attendez.

Lancez le Node.js REPL dans le même dossier que le fichier index.js :

  • node

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

Commencez par entrer ce qui suit :

  • colors = require('./index');

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

Output
{ getRandomColor: [Function], allColors: [ Color { name: 'brightred', code: '#E74C3C' }, Color { name: 'soothingpurple', code: '#9B59B6' }, Color { name: 'skyblue', code: '#5DADE2' }, Color { name: 'leafygreen', code: '#48C9B0' }, Color { name: 'sunkissedyellow', code: '#F4D03F' }, Color { name: 'groovygray', code: '#D7DBDD' } ] }

Le REPL nous indique la valeur de colors, c'est-à-dire toutes les fonctions et tous les objets importés du fichier index.js. Lorsque vous utilisez le mot-clé require, Node.js renvoie tout le contenu de l'objet exports d'un module.

Rappelez-vous que vous avez ajouté getRandomColor() et allColors aux exports dans le module colors. C'est pourquoi vous les voyez tous les deux dans le REPL lorsqu'ils sont importés.

À l'invite, testez la fonction getRandomColor() :

  • colors.getRandomColor();

Vous obtiendrez une couleur aléatoire :

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

Étant donné que l'index est aléatoire, votre sortie peut varier. Maintenant que vous avez confirmé que le module colors fonctionne, quittez le Node.js REPL :

  • .exit

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

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

Étape 3 — Sauvegarde de votre module local en tant que dépendance

En testant votre module dans le REPL, vous l'avez importé avec un chemin d'accès 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 allez installer le module colors avec la fonction install du module local de npm.

Configurez 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

Entrez maintenant dans votre nouveau projet :

  • cd really-large-application

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

  • npm init -y

Le package.json suivant sera généré :

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 l'indicateur --save afin 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 :

~/really-large-application/package.json
{
  "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"
  }
}

Quittez le fichier.

Le module colors a été copié dans votre répertoire node_modules. Vérifiez qu'il est bien là avec la commande suivante :

  • ls node_modules

Cela donnera la sortie suivante :

Output
colors

Utilisez le module local que vous avez installé dans ce nouveau programme. Rouvrez votre éditeur de texte et créez un autre fichier JavaScript :

  • nano index.js

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

Entrez le code suivant dans index.js :

~/really-large-application/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 élément du site Web.

Exécutez ce script avec :

  • node index.js

Votre sortie sera semblable à :

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

Vous avez maintenant installé le module colors et vous pouvez le gérer comme tout autre package npm utilisé dans votre projet. Toutefois, si vous ajoutiez plus de couleurs et de fonctions à votre module colors local, vous devriez lancer npm update dans vos applications pour pouvoir utiliser les nouvelles options. Dans l'étape suivante, vous utiliserez le module colors local d'une autre manière et obtiendrez des mises à jour automatiques lorsque le code du module changera.

Étape 4 — Liaison d'un module local

Si votre module local est en plein développement, la mise à jour continue des packages peut être fastidieuse. Une autre solution consisterait à lier les modules entre eux. La liaison d'un module garantit que toute mise à jour du module est immédiatement répercutée dans les applications qui l'utilisent.

Dans cette étape, vous relierez le module colors à votre application. Vous modifierez également le module colors et confirmerez que ses dernières modifications fonctionnent dans l'application sans avoir à le réinstaller ou à le mettre à niveau.

Commencez par désinstaller votre module local :

  • npm un colors

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

  1. Création d'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'endroit où sont installés tous vos packages npm à l'échelle du système (tout package que vous installez avec l'indicateur -g).
  2. Création un lien local. npm crée un lien symbolique entre votre projet local qui utilise le module et le lien global du module.

Tout d'abord, créez le lien global en retournant au dossier colors et en utilisant la commande link :

  • cd ../colors
  • sudo npm link

Une fois lien créé, votre shell produira une sortie :

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 dans le dossier really-large-application et liez le package :

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

Vous recevrez une sortie semblable à ce qui suit :

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

Remarque : si vous souhaitez avoir un peu moins de caractères à saisir, 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 local node_modules 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 semblable à :

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

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

  • cd ../colors
  • nano index.js

Ajoutez maintenant une fonction qui sélectionne la 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 :

~/colors/index.js
class Color {
  constructor(name, code) {
    this.name = name;
    this.code = code;
  }
}

const allColors = [
  new Color('brightred', '#E74C3C'),
  new Color('soothingpurple', '#9B59B6'),
  new Color('skyblue', '#5DADE2'),
  new Color('leafygreen', '#48C9B0'),
  new Color('sunkissedyellow', '#F4D03F'),
  new Color('groovygray', '#D7DBDD'),
];

exports.getRandomColor = () => {
        return allColors[Math.floor(Math.random() * allColors.length)];
        }

exports.allColors = allColors;

exports.getBlue = () => {
  return allColors[2];
}

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 instructions à la fin du dossier :

~/really-large-application/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}`);

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 auparavant :

  • node index.js

Vous verrez une sortie semblable à :

Output
You should use brightred on your website. It's HTML code is #E74C3C My 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. Il sera ainsi plus facile d'apporter des modifications à cette application en cours de développement.

Lorsque vous écrivez des applications plus importantes et plus complexes, réfléchissez à la manière dont le code correspondant peut être regroupé en modules, et à la manière dont vous souhaitez que ces modules soient mis en place. Si votre module ne doit être utilisé que par un seul programme, il peut rester dans le même projet et être référencé par un chemin d'accès relatif. Si votre module doit plus tard être partagé séparément, ou s'il existe dans un endroit très différent du projet sur lequel vous travaillez actuellement, l'installation ou la liaison pourraient être des options plus viables. Pour les modules en développement actif, les mises à jour automatiques que la liaison permet sont également un avantage. Si le module n'est pas en cours de 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 joint vos fonctions et objets à l'objet exports global pour les rendre disponibles à des programmes externes. Enfin, vous avez importé ce module dans un programme, démontrant ainsi comment les modules s'assemblent pour former des applications plus importantes.

Maintenant que vous savez comment créer des modules, pensez au type de programme que vous voulez écrire et décomposez-le en divers éléments, 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 en mesure de rédiger des programmes Node.js de qualité au cours de votre parcours d'apprentissage. Pour voir un exemple d'une application Node.js qui utilise des modules, consultez notre tutoriel Comment configurer une application Node.js pour la production sur Ubuntu 18.04.

0 Comments

Creative Commons License