==================================== Partie 1=======================================

Présentation de Node.js

Qu'est-ce que Node.js ?

• Node.js est un environnement de serveur open source
• Node.js est gratuit
• Node.js fonctionne sur différentes plates-formes (Windows, Linux, Unix, Mac OS X,
etc.)
• Node.js utilise JavaScript sur le serveur

Pourquoi Node.js ?
Node.js utilise la programmation asynchrone !

Une tâche courante pour un serveur Web peut être d'ouvrir un fichier sur le serveur et de
renvoyer le contenu au client.

Voici comment PHP ou ASP gère une demande de fichier :

1. Envoie la tâche au système de fichiers de l'ordinateur.

2. Attend pendant que le système de fichiers s'ouvre et lit le fichier.
3. Renvoie le contenu au client.
4. Prêt à traiter la prochaine demande.

Voici comment Node.js gère une demande de fichier :

1. Envoie la tâche au système de fichiers de l'ordinateur.

2. Prêt à traiter la prochaine demande.
3. Lorsque le système de fichiers a ouvert et lu le fichier, le serveur renvoie le
contenu au client.

Node.js élimine l'attente et continue simplement avec la requête suivante.

Node.js exécute une programmation asynchrone à un seul thread, non bloquante, qui
est très économe en mémoire.

1
Que peut faire Node.js ?
• Node.js peut générer du contenu de page dynamique
• Node.js peut créer, ouvrir, lire, écrire, supprimer et fermer des fichiers sur le
serveur
• Node.js peut collecter des données de formulaire
• Node.js peut ajouter, supprimer, modifier des données dans votre base de données

Qu'est-ce qu'un fichier Node.js ?

• Les fichiers Node.js contiennent des tâches qui seront exécutées sur certains
événements
• Un événement typique est quelqu'un essayant d'accéder à un port sur le serveur
• Les fichiers Node.js doivent être lancés sur le serveur avant d'avoir un effet
• Les fichiers Node.js ont l'extension ".js"

===========================================================================

Node.js Démarrer
Télécharger Node.js
Le site Web officiel de Node.js contient des instructions d'installation pour
Node.js : https://nodejs.org

Commencer
Une fois que vous avez téléchargé et installé Node.js sur votre ordinateur, essayons
d'afficher "Hello World" dans un navigateur Web.

Créez un fichier Node.js nommé "myfirst.js" et ajoutez le code suivant :

myfirst1.js

var http = require('http');

http.createServer(function (req, res) {

res.writeHead(200, {'Content-Type': 'text/html'});
res.end('Hello World!');
}).listen(8084);

Enregistrez le fichier sur votre ordinateur : C:\Users\ Votre nom \myfirst1.js

2
Le code indique à l'ordinateur d'écrire "Hello World!" si quelqu'un (par exemple un
navigateur Web) essaie d'accéder à votre ordinateur sur le port 8084.

Pour l'instant, vous n'avez pas besoin de comprendre le code. Il sera expliqué plus tard.

Interface de ligne de commande

Les fichiers Node.js doivent être lancés dans le programme "Command Line Interface" de
votre ordinateur.

La façon d'ouvrir l'interface de ligne de commande sur votre ordinateur dépend du système
d'exploitation. Pour les utilisateurs de Windows, appuyez sur le bouton de démarrage et
recherchez "Invite de commandes", ou écrivez simplement "cmd" dans le champ de
recherche.

Naviguez jusqu'au dossier qui contient le fichier "myfirst1.js", la fenêtre de l'interface de

ligne de commande devrait ressembler à ceci :

C:\Users\Your Name>_

Lancer le fichier Node.js

Le fichier que vous venez de créer doit être initié par Node.js avant qu'une action puisse
avoir lieu.

Démarrez votre interface de ligne de commande, écrivez node myfirst1.js et appuyez

sur Entrée :

Lancez "myfirst1.js":

C:\Users\Your Name>node myfirst1.js

Maintenant, votre ordinateur fonctionne comme un serveur !

Si quelqu'un essaie d'accéder à votre ordinateur sur le port 8080, il recevra un "Hello
World!" message en retour !

Démarrez votre navigateur Internet et saisissez l'adresse : http://localhost:8084

===========================================================================

3
Modules Node.js

Qu'est-ce qu'un module dans Node.js ?

Considérez que les modules sont identiques aux bibliothèques JavaScript.

Un ensemble de fonctions que vous souhaitez inclure dans votre application.

Modules intégrés
Node.js possède un ensemble de modules intégrés que vous pouvez utiliser sans aucune
autre installation.

Consultez notre Référence des modules intégrés pour une liste complète des modules.

Inclure les modules

Pour inclure un module, utilisez la require() fonction avec le nom du module :

var http = require('http');

// Votre application a maintenant accès au module HTTP et est capable de créer un

//serveur :

http.createServer(function (req, res) {

res.writeHead(200, {'Content-Type': 'text/html'});
res.end('Hello World!2 ');
}).listen(8084);

Créez vos propres modules

Vous pouvez créer vos propres modules, et les inclure facilement dans vos applications.

L'exemple suivant crée un module qui renvoie un objet date et heure :

4
Exemple
Créez un module qui renvoie la date et l'heure actuelles :

exports.myDateTime = function () {
return Date();
};

Utilisez le mot- exports clé pour rendre les propriétés et les méthodes disponibles en
dehors du fichier de module.

Enregistrez le code ci-dessus dans un fichier appelé "myfirstmodule.js"

Incluez votre propre module

Vous pouvez désormais inclure et utiliser le module dans n'importe lequel de vos fichiers
Node.js.

Exemple
Utilisez le module "myfirstmodule" dans un fichier Node.js :

var http = require('http');

var dt = require('./myfirstmodule');

http.createServer(function (req, res) {

res.writeHead(200, {'Content-Type': 'text/html'});
res.write("The date and time are currently: " + dt.myDateTime());
res.end();
console.log('http://localhost:8084');
}).listen(8084);

Notez que nous utilisons ./pour localiser le module, cela signifie que le module est situé
dans le même dossier que le fichier Node.js.

Enregistrez le code ci-dessus dans un fichier appelé " myfirst2.js ", et lancez le fichier :

"myfirst2.js":

C:\Users\Your Name>node myfirst2.js

Si vous avez suivi les mêmes étapes sur votre ordinateur, vous verrez le même résultat
que l'exemple : http://localhost:8084

5
 ===========================================================================

Module HTTP Node.js

Le module HTTP intégré

Node.js possède un module intégré appelé HTTP, qui permet à Node.js de transférer des
données via le protocole HTTP (Hyper Text Transfer Protocol).

Pour inclure le module HTTP, utilisez la require()méthode :

var http = require('http');

Node.js en tant que serveur Web

Le module HTTP peut créer un serveur HTTP qui écoute les ports du serveur et renvoie
une réponse au client.

Utilisez la createServer()méthode pour créer un serveur HTTP :

Exemple
var http = require('http');

//create a server object:

http.createServer(function (req, res) {
res.write('Hello World!'); //write a response to the client
res.end(); //end the response
}).listen(8084); //the server object listens on port 8084

La fonction passée dans la http.createServer() méthode sera exécutée lorsque

quelqu'un tentera d'accéder à l'ordinateur sur le port 8084.

Enregistrez le code ci-dessus dans un fichier appelé " myfirst3.js", et lancez le fichier :

Lancez myfirst3.js :

C:\Users\Your Name>node myfirst3.js

Si vous avez suivi les mêmes étapes sur votre ordinateur, vous verrez le même résultat
que l'exemple : http://localhost:8084

6
Ajouter un en-tête HTTP
Si la réponse du serveur HTTP est censée être affichée au format HTML, vous devez
inclure un en-tête HTTP avec le type de contenu correct :

Exemple
myfirst4.js
var http = require('http');
http.createServer(function (req, res) {
res.writeHead(200, {'Content-Type': 'text/html'});
res.write('Hello World!');
res.end();
}).listen(8084);

Le premier argument de la res.writeHead()méthode est le code d'état, 200 signifie que

tout est OK, le deuxième argument est un objet contenant les en-têtes de réponse.

Lire la chaîne de requête

La fonction passée à http.createServer() a une req argument qui représente la demande
du client, sous la forme d'un objet (objet http.IncomingMessage).

Cet objet a une propriété appelée "url" qui contient la partie de l'url qui vient après le
nom de domaine :

myfirst5.js

var http = require('http');

http.createServer(function (req, res) {
res.writeHead(200, {'Content-Type': 'text/html'});
res.write(req.url);
res.end();
}).listen(8084);
console.log('http://localhost:8084/hiver');
console.log('http://localhost:8084/ete');

Enregistrez le code ci-dessus dans un fichier appelé "demo_http_url.js" et lancez le

fichier :

Lancez myfirst5.js

C:\Users\Your Name>node myfirst5.js

7
Si vous avez suivi les mêmes étapes sur votre ordinateur, vous devriez voir deux
résultats différents lors de l'ouverture de ces deux adresses :

http://localhost:8084/été

Produira ce résultat:

/ été

http://localhost:8084/hiver

Produira ce résultat:

/ hiver

Fractionner la chaîne de requête

Il existe des modules intégrés pour diviser facilement la chaîne de requête en parties
lisibles, comme le module URL.

Exemple
Divisez la chaîne de requête en parties lisibles :

=====

en francais
url.parse est une méthode du module url de la bibliothèque standard de Node.js, qui est
utilisé pour analyser une chaîne URL en ses parties composantes.

Voici un exemple d'utilisation de url.parse :

Cela produira un objet qui représente les composants de l'URL, tels que le protocole, le nom d'hôte, le port, le
nom de chemin, la chaîne de requête et le fragment.

8
Vous pouvez ensuite accéder aux composants individuels de l'URL en utilisant les propriétés de l'objet retourné,
comme parsedUrl.protocol ou parsedUrl.query.

=====

var http = require('http');

var url = require('url');

http.createServer(function (req, res) {

res.writeHead(200, {'Content-Type': 'text/html'});
var q = url.parse(req.url, true).query;
var txt = q.year + " " + q.month;
res.end(txt);
}).listen(8084);

Enregistrez le code ci-dessus dans un fichier appelé "demo_querystring.js" et lancez le

fichier :

Lancez myfirst6.js:

C:\Users\Your Name>node myfirst6.js

L'adresse: http://localhost:8084/?year=2023&month=juillet

Produira ce résultat:

2023 July

En savoir plus sur le module URL dans le chapitre Module URL Node.js.

9
Exemple
URL Comme routage :

const http = require("http");

const server = http.createServer((req,resp)=>{

//console.log(req);
if(req.url=="/"){
resp.write("<h1>Bienvenue dans notre premier http response by nodeJS
API</h1>");
}
else if(req.url==="/home"){
console.log("--------");
resp.write("<h1> thi is the home page</h1>");
}
else{
console.log(req.url);
resp.write(`<h1>Il existe une erreur d'url : </h1>
<ul>
<li>Ressources Not Found</li>
<li>Erreur 404</li>
<li><a href="/home">Go Home</li>
</ul>
`);
}
resp.end();
});

server.listen(8084);
//j'execute node modelHTTP.js puis j'execute dans le browser localhost:5000/home par
exemple

==================================== Partie 2=======================================

10
 Module de système de
fichiers Node.js

Node.js en tant que serveur de fichiers

Le module de système de fichiers Node.js vous permet de travailler avec le système de
fichiers de votre ordinateur.

Pour inclure le module File System, utilisez la require() méthode :

var fs = require('fs');

Utilisation courante du module File System :

• Lire des fichiers

• Créer des fichiers
• Mettre à jour les fichiers
• Supprimer les fichiers
• Renommer les fichiers

1) Lire les fichiers

La fs.readFile() méthode est utilisée pour lire des fichiers sur votre ordinateur.

Supposons que nous ayons le fichier HTML suivant (situé dans le même dossier que
Node.js) :

demofile1.html

11
Créez un fichier Node.js qui lit le fichier HTML et renvoyez le contenu :

Exemple
Obtenez votre propre serveur Node.js

Enregistrez le code ci-dessus dans un fichier appelé " t1.js ", et lancez le fichier :

Lancez t1.js:

C:\Users\Your Name>node t1.js

Si vous avez suivi les mêmes étapes sur votre ordinateur, vous verrez le même résultat
que l'exemple : http://localhost:8084

12
2) Créer des fichiers
Le module File System propose des méthodes pour créer de nouveaux fichiers :

• fs.appendFile()
• fs.open()
• fs.writeFile()

1. fs.appendFile()

Cette méthode ajoute le contenu spécifié à un fichier. Si le fichier n'existe pas, le fichier
sera créé :

Exemple
Créez un nouveau fichier en utilisant la méthode appendFile() :

2. fs.open()

Cette méthode prend un mode d’ouverture comme deuxième argument, si le mode est "w"
pour "écriture", le fichier spécifié est ouvert en écriture. Si le fichier n'existe pas, un fichier
vide est créé :

Exemple
Créez un nouveau fichier vide en utilisant la méthode open() :

13
 3. fs.writeFile()

Cette méthode remplace le fichier spécifié et son contenu s'il existe. Si le fichier n'existe
pas, un nouveau fichier, contenant le contenu spécifié, sera créé :

Exemple
Créez un nouveau fichier en utilisant la méthode writeFile() :

3) Mettre à jour les fichiers

Le module File System dispose de méthodes pour mettre à jour les fichiers :

• fs.appendFile()
• fs.writeFile()

1. fs.appendFile()

Cette méthode ajoute le contenu spécifié à la fin du fichier spécifié :

Exemple
Ajouter un retour a la ligne et " On ajoute du texte" à la fin du fichier 'mynewfile1.txt ":

14
 2. fs.writeFile()

Cette méthode remplace le fichier et le contenu spécifiés :

Exemple
Remplacez le contenu du fichier "mynewfile3.txt":

4) Supprimer les fichiers

Pour supprimer un fichier avec le module File System, utilisez la fs.unlink() méthode.

La fs.unlink()méthode supprime le fichier spécifié :

Exemple
Supprimez "mynewfile2.txt":

15
5) Renommer les fichiers
Pour renommer un fichier avec le module File System, utilisez la fs.rename() méthode.

La fs.rename() méthode renomme le fichier spécifié :

Exemple
Renommez "''mynewfile1.txt " en "'myrenamedfile.txt ":

16
 ==================================== Partie 3=======================================

Module URL Node.js

1) Le module d'URL intégré

Le module URL divise une adresse Web en parties lisibles.

Pour inclure le module URL, utilisez la require() méthode :

var url = require('url');

Analysez une adresse avec la url.parse() méthode et elle renverra un objet URL avec
chaque partie de l'adresse en tant que propriétés.

Le code url.parse(adr, true) est utilisé pour analyser une URL et en extraire les
différentes parties qui la composent, telles que le protocole, l'hôte, le chemin, les
paramètres de requête, etc.

Voici une explication détaillée de chaque paramètre de la méthode url.parse() :

• adr : Il s'agit de l'URL que nous souhaitons analyser.

• true : Ce deuxième paramètre est un booléen qui indique si les paramètres de la
requête doivent être analysés en tant qu'objet ( true) ou en tant que chaîne de
requête (false).

La méthode url.parse() renvoie un objet qui contient les différentes parties de

l'URL analysée. Voici les principales propriétés de l'objet renvoyé :

• protocol : Le protocole utilisé (http, https, ftp, etc.)

• host : L'hôte (nom de domaine ou adresse IP) de l'URL.
• pathname : Le chemin de l'URL.
• query : Les paramètres de la requête, soit sous forme d'une chaîne de requête (si
true est false), soit sous forme d'un objet (si true est true).
• hash : le fragment d'URL, également appelé ancre ou hash, fait référence à la
partie optionnelle d'une URL qui suit le symbole "#" et qui peut être utilisée pour
identifier une section spécifique d'une ressource Web.

17
 En résumé, le code url.parse(adr, true) analyse l'URL adr en tant qu'objet et
renvoie un objet contenant les différentes parties de l'URL.

Exemple Divisez une adresse Web en parties lisibles :

2) Serveur de fichiers Node.js

Nous savons maintenant comment analyser la chaîne de requête et, dans le chapitre
précédent, nous avons appris à faire en sorte que Node.js se comporte comme un
serveur de fichiers. Combinons les deux, et servons le dossier demandé par le client.

Créez deux fichiers html et enregistrez-les dans le même dossier que vos fichiers node.js.

été.html

<!DOCTYPE html>
<html>
<body>
<h1>Summer</h1>
<p>I love the sun!</p>
</body>
</html>

hiver.html

<!DOCTYPE html>
<html>
<body>
<h1>Winter</h1>
<p>I love the snow!</p>
</body>
</html>

18
Créez un fichier t3.js Node.js qui ouvre le fichier demandé et renvoie le contenu au
client. Si quelque chose ne va pas, lancez une erreur 404 :

t3.js :

Pensez à initier le fichier :

Lancez t2.js :

C:\Users\Your Name>node t2.js

Si vous avez suivi les mêmes étapes sur votre ordinateur, vous devriez voir deux
résultats différents lors de l'ouverture de ces deux adresses :

http://localhost:8084/summer.html

19
Produira ce résultat:

Summer
I love the sun!

http://localhost:8084/winter.html

Produira ce résultat:

Winter
I love the snow!

20
 SERIE EXERCICES

I) SUR le système de fichiers Node.js :

1) Créez un fichier texte "message.txt" et écrivez-y "Bonjour Node.js !" en utilisant la méthode
fs.writeFile().
2) Lisez le contenu du fichier "message.txt" à l'aide de la méthode fs.readFile() et affichez-le dans
la console.
3) Créez un dossier "documents" avec la méthode fs.mkdir().
4) Copiez le fichier "message.txt" dans le dossier "documents" avec la méthode fs.copyFile().
5) Supprimez le fichier "message.txt" avec la méthode fs.unlink().
6) Renommez le fichier "documents/message.txt" en "documents/nouveau-message.txt" avec la
méthode fs.rename().
7) Affichez la liste des fichiers et dossiers présents dans le dossier "documents" avec la méthode
fs.readdir().
8) Créez un fichier "data.json" contenant un objet avec des propriétés et des valeurs de votre
choix avec la méthode fs.writeFile().
9) Lisez le contenu du fichier "data.json" à l'aide de la méthode fs.readFile() et affichez-le dans la
console.
10) Modifiez une propriété de l'objet contenu dans le fichier "data.json" avec la méthode
fs.readFile(), puis écrivez les modifications dans le fichier avec la méthode fs.writeFile().

II) SUR ‘URL Node.js :

1) Utiliser le module 'url' pour extraire les paramètres de requête d'une URL donnée .
2) Utiliser le module 'url' pour extraire le chemin d'une URL donnée.
3) Utiliser le module 'url' pour résoudre une URL relative en une URL absolue.
4) Utiliser le module 'url' pour parser une URL donnée en ses différentes parties (protocole,
hôte, chemin, etc.).
5) Utiliser le module 'url' pour générer une URL à partir de ses différentes parties (protocole,
hôte, chemin, etc.).
6) Utiliser le module 'querystring' pour créer une chaîne de requête à partir d'un objet
JavaScript.
7) Utiliser le module 'querystring' pour parser une chaîne de requête en un objet JavaScript.
8) Utiliser le module 'url' pour ajouter des paramètres de requête à une URL existante.
9) Utiliser le module 'url' pour extraire le nom de domaine d'une URL donnée.
10) Utiliser le module 'url' pour vérifier si une URL est absolue ou relative.

21
 CORRECTION SERIE EXERCICES

I) système de fichiers
1. Créez un fichier texte "message.txt" et écrivez-y "Bonjour Node.js !" en utilisant la méthode
fs.writeFile().

2. Lisez le contenu du fichier "message.txt" à l'aide de la méthode fs.readFile() et affichez-le dans la

console.

3. Créez un dossier "documents" avec la méthode fs.mkdir().

});
4. Copiez le fichier "message.txt" dans le dossier "documents" avec la méthode fs.copyFile().

22
5. Supprimez le fichier "message.txt" avec la méthode fs.unlink().

6. Renommez le fichier "documents/message.txt" en "documents/nouveau-message.txt" avec la

méthode fs.rename().

7. Affichez la liste des fichiers et dossiers présents dans le dossier "documents" avec la méthode
fs.readdir().

8. Créez un fichier "data.json" contenant un objet avec des propriétés et des valeurs de votre choix
avec la méthode fs.writeFile().
R1)

23
R2)

Dans cet exemple, j'ai créé un objet data qui contient des propriétés et des valeurs de mon choix, puis j'ai
converti cet objet en format JSON à l'aide de la méthode JSON.stringify(). J'ai ensuite utilisé la méthode
fs.writeFile() pour écrire le fichier "data.json" avec les données JSON. La fonction de rappel ((err) =>
{ ... }) est utilisée pour gérer les erreurs éventuelles lors de l'écriture du fichier.

24
 ======== JSON.stringify =========

Ce code utilise la méthode JSON.stringify() pour convertir un objet JavaScript en une chaîne de
caractères JSON.

La méthode JSON.stringify() prend en entrée un objet JavaScript et, éventuellement, deux

arguments optionnels pour personnaliser la sortie JSON.

Dans ce cas, le premier argument obj est l'objet à convertir en JSON. Le deuxième argument null
indique qu'aucune fonction de remplacement ne doit être utilisée lors de la conversion. Le
troisième argument 2 spécifie l'indentation de deux espaces à utiliser pour formater la chaîne
JSON résultante. Cela signifie que chaque niveau de profondeur de la structure JSON sera indenté
de deux espaces.

Le résultat de l'appel de JSON.stringify(obj, null, 2) est stocké dans une variable nommée
newData. Cette variable contiendra donc la chaîne JSON correspondante à l'objet initial obj avec
une indentation de deux espaces pour chaque niveau de profondeur.
=================

9. Lisez le contenu du fichier "data.json" à l'aide de la méthode fs.readFile() et affichez-le dans la

console.

25
 Dans cet exemple, j'ai utilisé la méthode fs.readFile() pour lire le contenu du fichier "data.json". La
fonction de rappel ((err, data) => { ... }) est utilisée pour gérer les erreurs éventuelles lors de la
lecture du fichier et récupérer le contenu du fichier. Le deuxième argument 'utf-8' est utilisé pour spécifier
l'encodage du fichier (ici, UTF-8). Ensuite, si une erreur se produit, elle est affichée dans la console. Si la lecture
est réussie, le contenu du fichier est affiché dans la console.

10. Modifiez une propriété de l'objet contenu dans le fichier "data.json" avec la méthode fs.readFile(),
puis écrivez les modifications dans le fichier avec la méthode fs.writeFile().

Dans cet exemple, j'ai utilisé la méthode fs.readFile() pour lire le contenu du fichier "data.json". La
fonction de rappel ((err, data) => { ... }) est utilisée pour gérer les erreurs éventuelles lors de la
lecture du fichier et récupérer le contenu du fichier. Ensuite, j'ai converti les données JSON en un objet
JavaScript à l'aide de la méthode JSON.parse(). J'ai modifié une propriété de cet objet (obj.age = 36;),
puis j'ai converti l'objet modifié en format JSON à l'aide de la méthode JSON.stringify() .

Enfin, j'ai utilisé la méthode fs.writeFile() pour écrire les modifications dans le fichier "data.json". La
fonction de rappel ((err) => { ... }) est utilisée pour gérer les erreurs éventuelles lors de l'écriture du
fichier.

26
 II) URL

1) Utiliser le module 'url' pour extraire les paramètres de requête d'une URL donnée .

'http://example.com/page?name=John&age=30'

const url = require('url');

const urlString = 'http://example.com/page?name=John&age=30';
const urlObj = url.parse(urlString, true);
const query = urlObj.query;
console.log(query.name); // John
console.log(query.age); // 30

2) Utiliser le module 'url' pour extraire le chemin d'une URL donnée.

'http://example.com/page?name=John&age=30'

const url = require('url');

const urlString = 'http://example.com/page?name=John&age=30';
const urlObj = url.parse(urlString, true);
const path = urlObj.pathname;
console.log(path); // /page

3) Utiliser le module 'url' pour résoudre une URL relative en une URL absolue.

const url = require('url');

const baseUrl = 'http://example.com';
const relativeUrl = '/page';
const resolvedUrl = url.resolve(baseUrl, relativeUrl);
console.log(resolvedUrl); // http://example.com/page

Le code ci-dessus utilise le module url de Node.js pour résoudre une URL relative en une URL
absolue.

const url = require('url');

• La première ligne définit une constante url qui utilise le module url de Node.js. Cela permet
d'utiliser les fonctions de ce module pour travailler avec des URL.

const baseUrl = 'http://example.com';

• La deuxième ligne définit une constante baseUrl contenant l'URL de base du site Web.

const relativeUrl = '/page';

• La troisième ligne définit une constante relativeUrl contenant une URL relative qui sera résolue
par rapport à baseUrl.
const resolvedUrl = url.resolve(baseUrl, relativeUrl);

27
• La quatrième ligne utilise la fonction url.resolve() pour résoudre relativeUrl en une URL
absolue par rapport à baseUrl.
console.log(resolvedUrl);
• La cinquième ligne affiche le résultat obtenu dans la console.

Dans cet exemple, la constante resolvedUrl contiendra l'URL absolue http://example.com/page.

Cette URL est obtenue en combinant l'URL de base http://example.com et l'URL relative /page.

La fonction url.resolve() utilise les deux arguments passés pour déterminer l'URL absolue finale
en les combinant de manière appropriée. Si l'argument relativeUrl commence par un /, il est
résolu par rapport à l'URL de base. Si l'argument relativeUrl ne commence pas par un /, il est
résolu par rapport au chemin de l'URL de base. Dans ce cas, l'URL de base n'a pas de chemin
spécifié, donc l'URL relative est simplement concaténée à l'URL de base.

4) Utiliser le module 'url' pour parser une URL donnée en ses différentes parties (protocole, hôte, chemin,
etc.).

const url = require('url');

const urlString = 'http://example.com:8084/page?name=John#content';
const urlObj = url.parse(urlString, true);
console.log(urlObj.protocol); // http:
console.log(urlObj.host); // example.com:8084
console.log(urlObj.hostname); // example.com
console.log(urlObj.port); // 8084
console.log(urlObj.pathname); // /page
console.log(urlObj.query); // { name: 'John' }
console.log(urlObj.hash); // #content

28
5) Utiliser le module 'url' pour générer une URL à partir de ses différentes parties (protocole, hôte, chemin,
etc.).

const url = require('url');

const urlObj = {
protocol: 'http:',
hostname: 'example.com',
port: '8080',
pathname: '/page',
query: { name: 'John' },
hash: 'content'
};
const urlString = url.format(urlObj);
console.log(urlString); // http://example.com:8080/page?name=John#content

6) Utiliser le module 'querystring' pour créer une chaîne de requête à partir d'un objet JavaScript.

const querystring = require('querystring');

const obj = { name: 'John', age: 30 };
const queryString = querystring.stringify(obj);
console.log(queryString); // name=John&age=30

7) Utiliser le module 'querystring' pour parser une chaîne de requête en un objet JavaScript.

const querystring = require('querystring');

const queryString = 'name=John&age=30';
const obj = querystring.parse(queryString);

console.log(obj); // { name: 'John', age: '30' }

console.log(obj.name); // John
console.log(obj.age); // 30

29
8) Utiliser le module 'url' pour ajouter des paramètres de requête à une URL existante.

const url = require('url');

const urlString = 'http://example.com/page';
const urlObj = url.parse(urlString, true);
urlObj.query.name = 'John';
urlObj.query.age = 30;

const newUrlString = url.format(urlObj);

console.log(newUrlString);// http://example.com/page?name=John&age=30

9) Utiliser le module 'url' pour extraire le nom de domaine d'une URL donnée.

const url = require('url');

const urlString = 'http://example.com/page?name=John';
const urlObj = url.parse(urlString);
const domain = urlObj.hostname;
console.log(domain); // example.com

10) Utiliser le module 'url' pour vérifier si une URL est absolue ou relative.

const url = require('url');

const absoluteUrl = 'http://example.com/page';
const relativeUrl = '/page';
console.log(url.parse(absoluteUrl).protocol); // 'http:'
console.log(url.parse(relativeUrl).protocol); // null

Ce code utilise le module url de Node.js pour analyser et extraire des informations à partir d'une URL.
const url = require('url');
La première ligne importe le module url en tant que constante url. Cela permet au code d'utiliser les
fonctions et les propriétés du module url dans le reste du programme.

const absoluteUrl = 'http://example.com/page';

Les deux lignes suivantes définissent deux variables absoluteUrl et relativeUrl, qui contiennent
respectivement une URL absolue et une URL relative.
console.log(url.parse(absoluteUrl).protocol);
Ensuite, le code utilise la fonction url.parse pour analyser chacune de ces URL et extraire des
informations telles que le protocole, le nom d'hôte, le chemin, etc.

30
La première instruction console.log(url.parse(absoluteUrl).protocol); affiche le protocole de
l'URL absolue (http:) sur la console.

La seconde instruction console.log(url.parse(relativeUrl).protocol); tente également de

récupérer le protocole, mais cette fois pour une URL relative (/page). Cependant, puisque l'URL relative ne
spécifie pas de protocole, la sortie de cette instruction sera null.

31
 ==================================== Partie 4=======================================

NPM Node.js

1) Qu'est-ce que le NPM ?

NPM est un gestionnaire de packages pour les packages Node.js ou les modules si vous le
souhaitez.

www.npmjs.com héberge des milliers de packages gratuits à télécharger et à utiliser.

Le programme NPM est installé sur votre ordinateur lorsque vous installez Node.js

NPM est déjà prêt à fonctionner sur votre ordinateur !

2) Qu'est-ce qu'un forfait ?

Un package dans Node.js contient tous les fichiers dont vous avez besoin pour un
module.

Les modules sont des bibliothèques JavaScript que vous pouvez inclure dans votre projet.

3) Télécharger un package
Le téléchargement d'un package est très simple.
Ouvrez l'interface de ligne de commande et dites à NPM de télécharger le package
souhaité.

Vous avez maintenant téléchargé et installé votre premier package !

NPM crée un dossier nommé "node_modules", où le package sera placé. Tous les
packages que vous installerez à l'avenir seront placés dans ce dossier.

32
3) Utilisation d'un package
Une fois le package installé, il est prêt à être utilisé.

Voici quelques exemples de packages Node.js couramment utilisés, illustrant la diversité

de leurs fonctionnalités :

1. express:
• Fonctionnalité: Création d'applications web et d'API.
• Exemple d'utilisation:

const express = require('express')

const app = express()

app.get('/', function (req, res) {

res.send('Hello World')
})
app.listen(3000)
console.log("Le serveur est en cours d'execution");
console.log("l'adresse : http://localhost:3000 ");

2. mongoose:
• Fonctionnalité: Interaction avec des bases de données MongoDB.
• Exemple d'utilisation:

const mongoose = require('mongoose');

mongoose.connect('mongodb://localhost:27017/mydatabase', {
useNewUrlParser: true,
useUnifiedTopology: true
});
const catSchema = new mongoose.Schema({
name: String,
race: String
});
const Cat = mongoose.model('Cat', catSchema);

3. lodash:
• Fonctionnalité: Collection de fonctions utilitaires pour manipuler des données et des objets.
• Exemple d'utilisation:

const _ = require('lodash');

const numbers = [1, 2, 3, 4, 5];

const doubledNumbers = _.map(numbers, (number) => number * 2);
console.log(doubledNumbers); // [2, 4, 6, 8, 10]

33
 ==================================== Partie 5=======================================

Événements Node.js
Node.js est parfait pour les applications événementielles.

1) Événements dans Node.js

Chaque action sur un ordinateur est un événement. Comme lorsqu'une connexion est
établie ou qu'un fichier est ouvert.

1) L'objet "readStream" : Cet objet est utilisé pour lire des fichiers dans Node.js.
Lorsqu'un fichier est lu à l'aide de cet objet, plusieurs événements sont déclenchés,
notamment "open", "data", "end" et "error". L'événement "open" est déclenché lorsque
le fichier est ouvert et prêt à être lu. L'événement "data" est déclenché chaque fois qu'une
partie du fichier est lue. L'événement "end" est déclenché lorsque la fin du fichier est
atteinte. Enfin, l'événement "error" est déclenché si une erreur se produit pendant la
lecture du fichier.

Exemple 1
const fs = require('fs');
const readStream = fs.createReadStream('monfichier.txt');

readStream.on('open', function () {
console.log('File is open');
});

readStream.on('data', (chunk) => {

console.log(`Chunk reçu: ${chunk}`);
});

readStream.on('end', () => {
console.log('Lecture du fichier terminée.');
});

readStream.on('error', (err) => {

console.error(`Erreur de lecture du fichier: ${err}`);
});

34
2) L'objet "http" : Cet objet est utilisé pour créer un serveur HTTP dans Node.js. Lorsqu'un
client envoie une demande à ce serveur, plusieurs événements sont déclenchés,
notamment "request", "connection", "close" et "error". L'événement "request" est
déclenché chaque fois qu'une demande est reçue. L'événement "connection" est
déclenché chaque fois qu'un client se connecte au serveur. L'événement "close" est
déclenché lorsque la connexion est fermée. Enfin, l'événement "error" est déclenché si une
erreur se produit pendant le traitement de la demande.

Exemple 2
const http = require('http');

const server = http.createServer(function (req, res) {

console.log('Request received');
res.writeHead(200, { 'Content-Type': 'text/plain' });
res.write('Hello World!');
res.end();
});

server.on('connection', function () {
console.log('Client connected');
});

server.on('close', function () {
console.log('Server closed');
});

server.on('error', function (err) {

console.log('Error occurred: ' + err.message);
});

server.listen(8084, function () {
console.log('Server started on port 8084');
});
console.log('Adresse: http://localhost:8084/');

setTimeout(function() {
server.close();
}, 10000);

1) Le code commence par importer le module http.

2) Ensuite, un serveur est créé en appelant la méthode createServer() du module
http. Cette méthode prend en paramètre une fonction de rappel qui sera appelée
chaque fois qu'une requête HTTP est reçue. Cette fonction de rappel prend deux
arguments : l'objet req (la demande HTTP) et l'objet res (la réponse HTTP).

3) Dans cette fonction de rappel, on affiche un message "Request received" sur

la console. Ensuite, on configure la réponse HTTP en utilisant la méthode
writeHead() pour définir le code d'état de la réponse à 200 (OK) et le type de
contenu de la réponse à "text/plain". Ensuite, on écrit le message "Hello World!"
35
dans la réponse en utilisant la méthode write(). Enfin, on termine la réponse en
appelant la méthode end().

4) Le serveur écoute également les événements connection, close et error.

L'événement connection est déclenché chaque fois qu'un client se connecte au
serveur, l'événement close est déclenché lorsque le serveur est fermé, et
l'événement error est déclenché lorsque le serveur rencontre une erreur.

5) Enfin, le serveur est démarré en appelant la méthode listen() du serveur en

spécifiant le port sur lequel il doit écouter les demandes entrantes. Une fois
que le serveur est en cours d'exécution, un message "Server started on port 8084"
est affiché sur la console.

Lorsque vous exécutez ce code, un serveur HTTP est créé et écoutera les
requêtes entrantes sur le port 8084. Lorsqu'une demande est reçue, le serveur
renverra une réponse avec le message "Hello World!". Vous pouvez accéder au
serveur en ouvrant un navigateur et en accédant à l'adresse
"http://localhost:8084/". Le message "Adresse: http://localhost:8084/" est
également affiché sur la console.

Pour voir l'exécution de l'événement close, vous pouvez arrêter le serveur en

appelant la méthode close() du serveur. Cela déclenchera l'événement close. Par
exemple, vous pouvez ajouter le code suivant à la fin du script pour fermer le
serveur après 10 secondes

Lorsque le serveur est fermé, le message "Server closed" sera affiché sur la
console.

2) Module Événements
---

Node.js est une plate-forme de développement JavaScript qui utilise le modèle de

programmation asynchrone, ce qui signifie que de nombreux événements peuvent se
produire en même temps. La gestion des événements dans Node.js est basée sur la
bibliothèque EventEmitter, qui permet de déclencher et de gérer des événements.

Voici les étapes de base pour travailler avec des événements dans Node.js :

1) Importez le module events : Pour commencer à travailler avec des événements, vous
devez importer le module events dans votre code.

const EventEmitter = require('events');

2) Créez un objet EventEmitter : Créez un objet EventEmitter à partir de la classe

EventEmitter

const myEmitter = new EventEmitter();

36
3) Définissez des événements : Vous pouvez définir des événements en utilisant la
méthode on de l'objet EventEmitter. Vous pouvez également utiliser la méthode once
pour définir un événement qui ne sera déclenché qu'une seule fois.

myEmitter.on('event', () => {
console.log('Un événement a été déclenché !');
});

myEmitter.once('eventOnce', () => {
console.log('Cet événement ne sera déclenché qu\'une seule fois.');
});

myEmitter.on('eventWithArgs', (arg1,arg2) => {

console.log('Un événement a été déclenché avec ',arg1 ,' et ',arg2,' et
Merci');
});

4) Déclenchez des événements : Vous pouvez déclencher des événements en utilisant la

méthode emit de l'objet EventEmitter. Vous pouvez également passer des arguments à
la méthode emit qui seront transmis aux écouteurs d'événements.

myEmitter.emit('event');
myEmitter.emit('eventOnce');

// Vous pouvez également transmettre des arguments

// aux écouteurs d'événements.
myEmitter.emit('eventWithArgs', 'Omar', 'Brahim');

5) Supprimez des écouteurs d'événements : Vous pouvez supprimer des écouteurs

d'événements en utilisant la méthode removeListener ou la méthode
removeAllListeners de l'objet EventEmitter.

a) myEmitter.removeListener('event', listener);
b) myEmitter.removeAllListeners('event');

a) Méthode myEmitter.removeListener('event', listener):

La méthode removeListener est utilisée pour supprimer un écouteur d'événement

spécifique attaché à un émetteur d'événement.

Voici un exemple où un écouteur d'événement nommé "messageHandler" est attaché

à un émetteur nommé "myEmitter", puis supprimé à l'aide de la méthode
removeListener :

37
const EventEmitter = require('events');

// Créer un nouvel émetteur d'événements

const myEmitter = new EventEmitter();

// Définir un écouteur d'événement nommé "messageHandler"

const messageHandler = () => {
console.log('Un message a été reçu');
};
myEmitter.on('message', messageHandler);

// Supprimer l'écouteur d'événement "messageHandler"

myEmitter.removeListener('message', messageHandler);

Dans cet exemple, la méthode removeListener est utilisée pour supprimer l'écouteur
d'événement "messageHandler" de l'événement "message" attaché à l'émetteur
"myEmitter".

b) Méthode myEmitter.removeAllListeners('event'):

La méthode removeAllListeners est utilisée pour supprimer tous les écouteurs d'un
événement spécifique ou de tous les événements attachés à un émetteur d'événement.

Voici un exemple où plusieurs écouteurs d'événements sont attachés à un émetteur

nommé "myEmitter", puis tous supprimés à l'aide de la méthode removeAllListeners :

const EventEmitter = require('events');

// Créer un nouvel émetteur d'événements

const myEmitter = new EventEmitter();

// Définir deux écouteurs d'événement nommés

//"messageHandler" et "errorHandler"

const messageHandler = () => {

console.log('Un message a été reçu');
};
myEmitter.on('message', messageHandler);

const errorHandler = () => {

console.log('Une erreur s\'est produite');
};
myEmitter.on('error', errorHandler);

// Supprimer tous les écouteurs d'événement

// attachés à l'émetteur "myEmitter"
myEmitter.removeAllListeners();

La gestion des événements est une technique importante en Node.js, car elle permet de
créer des applications performantes et évolutives. Elle est particulièrement utile pour les
38
applications qui doivent gérer de nombreux événements en même temps, comme les
serveurs Web ou les applications en temps réel.

--------------------------

3) EXEMPLES
Exemple 1 :
--------------
var events = require('events');
var eventEmitter = new events.EventEmitter(); // syntaxe CommonJS

//Créez un gestionnaire d'événements :

var myEventHandler = function () {
console.log('I hear a scream!');
}

//Affectez le gestionnaire d'événements à un événement :

eventEmitter.on('scream', myEventHandler);

//Lancer l'événement 'scream' :

eventEmitter.emit('scream');

Dans l'exemple ci-dessous, nous avons créé une fonction qui sera exécutée lorsqu'un
événement "cri" est déclenché.
Pour déclencher un événement, utilisez la emit() méthode.

--------------
Exemple 2 :

var events = require("events");

var eventEmitter = new events.EventEmitter();

//Créez un gestionnaire d'événements :

var myEventHandler = function (nb) {
console.log("I hear a scream!", nb, "fois");
};

//Affectez le gestionnaire d'événements à un événement :

eventEmitter.on("scream", myEventHandler);

//Lancer l'événement 'scream' :

eventEmitter.emit("scream", 5);

--------------

39
Exemple 3 :

const EventEmitter = require('events');

const myEmitter = new EventEmitter(); // syntaxe ES6

// Enregistrement d'un gestionnaire d'événements pour l'événement 'myEvent'

myEmitter.on('myEvent', (data) => {
console.log('L\'événement "myEvent" a été émis avec les données suivantes :',
data);
});

// Émission de l'événement 'myEvent'

myEmitter.emit('myEvent', {message: 'Ceci est un message'});

Lorsque cet exemple est exécuté, la fonction de gestion d'événements enregistrée est
appelée et affiche le message "L'événement "myEvent" a été émis avec les données
suivantes : { message: 'Ceci est un message' }" dans la console.

--------------

Exemple 4 :

// importe le module 'events' et assigne

// la classe EventEmitter à la constante EventEmitter
const EventEmitter = require('events');

//définit une nouvelle classe appelée MonEvenement qui hérite

// de la classe EventEmitter en utilisant l'héritage
//la classe MonEvenement aura toutes les méthodes et propriétés
// de la classe EventEmitter.
class MonEvenement extends EventEmitter {}

//crée une instance de la classe MonEvenement

// en appelant son constructeur
const monInstance = new MonEvenement();

40
// Abonnement à l'événement 'maNotification'
monInstance.on('maNotification', () => {
console.log('La notification a été reçue.');
});

// Émission de l'événement 'maNotification'

monInstance.emit('maNotification');
--------------

SERIE EXERCICES

1) Créer un programme Node.js qui utilise le module 'events' pour créer et gérer des
événements personnalisés.

2) Créer un programme Node.js qui utilise le module 'events' pour créer et gérer des
événements personnalisés avec des arguments.

3) Créer un programme Node.js qui utilise le module 'events' pour créer et gérer plusieurs
événements personnalisés avec des arguments et un événement personnalisé pour signaler la
fin de l'exécution.

4) Créer un programme Node.js qui lit le contenu d'un fichier texte, en supprime toutes les
voyelles, puis écrit le résultat dans un nouveau fichier texte.

5) Créez un EventEmitter qui écoute une variable de comptage et qui émet un événement
chaque fois que le compteur atteint un multiple de 10. Ajoutez un écouteur d'événements qui
se déclenche chaque fois qu'un multiple de 10 est atteint et qui affiche le nombre de fois que
le compteur a été atteint.

41
 Correction SERIE EXERCICES

1) Créer un programme Node.js qui utilise le module 'events' pour créer et gérer des
événements personnalisés.

Instructions :

1) Créez un fichier JavaScript et nommez-le 'eventEmitter.js'.

2) Importez le module 'events' en utilisant la syntaxe require.
3) Créez un objet EventEmitter en instanciant la classe EventEmitter.
4) Ajoutez un gestionnaire d'événements pour l'événement 'message' qui imprime le
message 'Un message a été reçu'.
5) Déclenchez l'événement 'message' en utilisant la méthode emit().
6) Exécutez le programme en utilisant Node.js.

Solution avec détails:

1) Créez un nouveau fichier JavaScript et nommez-le 'eventEmitter.js'.

2) Importez le module 'events' en utilisant la syntaxe require:
const EventEmitter = require('events');
3) Créez un objet EventEmitter en instanciant la classe EventEmitter:
const myEmitter = new EventEmitter();
4) Ajoutez un gestionnaire d'événements pour l'événement 'message' qui imprime le message
'Un message a été reçu':
myEmitter.on('message', () => {
console.log('Un message a été reçu');
});
5) Déclenchez l'événement 'message' en utilisant la méthode emit():
myEmitter.emit('message');
6) Exécutez le programme en utilisant Node.js en exécutant la commande suivante dans le
terminal:
node eventEmitter.js

code complet:
const EventEmitter = require('events');
const myEmitter = new EventEmitter();

myEmitter.on('message', () => {
console.log('Un message a été reçu');
});

myEmitter.emit('message');

42
2) Créer un programme Node.js qui utilise le module 'events' pour créer et gérer des
événements personnalisés avec des arguments.

Instructions :

1) Créez un fichier JavaScript et nommez-le 'eventEmitterArgs.js'.

2) Importez le module 'events' en utilisant la syntaxe require.
3) Créez un objet EventEmitter en instanciant la classe EventEmitter.
4) Ajoutez un gestionnaire d'événements pour l'événement 'message' qui prend un
argument et l'imprime.
5) Déclenchez l'événement 'message' en utilisant la méthode emit() avec un argument.
6) Exécutez le programme en utilisant Node.js.

Solution avec détails :

1) Créez un nouveau fichier JavaScript et nommez-le 'eventEmitterArgs.js'.

2) Importez le module 'events' en utilisant la syntaxe require:
const EventEmitter = require('events');
3) Créez un objet EventEmitter en instanciant la classe EventEmitter:
const myEmitter = new EventEmitter();
4) Ajoutez un gestionnaire d'événements pour l'événement 'message' qui prend un argument
et l'imprime :
myEmitter.on('message', (arg) => {
console.log('Le message est : ', arg);
});
5) Déclenchez l'événement 'message' en utilisant la méthode emit() avec un argument:
myEmitter.emit('message', 'Bonjour tout le monde !');
6) Exécutez le programme en utilisant Node.js en exécutant la commande suivante dans le
terminal :
node eventEmitterArgs.js

code complet:
const EventEmitter = require('events');
const myEmitter = new EventEmitter();

myEmitter.on('message', (arg) => {

console.log('Le message est : ', arg);
});

myEmitter.emit('message', 'Bonjour tout le monde !');

43
3) Créer un programme Node.js qui utilise le module 'events' pour créer et gérer plusieurs
événements personnalisés avec des arguments et un événement personnalisé pour signaler la
fin de l'exécution.

Instructions :

1) Créez un fichier JavaScript et nommez-le 'eventEmitterMulti.js'.

2) Importez le module 'events' en utilisant la syntaxe require.
3) Créez un objet EventEmitter en instanciant la classe EventEmitter.
4) Ajoutez plusieurs gestionnaires d'événements pour différents événements qui prennent
des arguments et les impriment.
5) Ajoutez un événement personnalisé qui signalera la fin de l'exécution.
6) Déclenchez les différents événements avec des arguments.
7) Déclenchez l'événement de fin d'exécution.
8) Exécutez le programme en utilisant Node.js.

Solution avec détails :

1) Créez un nouveau fichier JavaScript et nommez-le 'eventEmitterMulti.js'.

2) Importez le module 'events' en utilisant la syntaxe require :
const EventEmitter = require('events');
3) Créez un objet EventEmitter en instanciant la classe EventEmitter :
const myEmitter = new EventEmitter();
4) Ajoutez plusieurs gestionnaires d'événements pour différents événements qui prennent des
arguments et les impriment :
myEmitter.on('event1', (arg1, arg2) => {
console.log('Le premier argument est :', arg1, 'Le deuxième argument est :',
arg2);
});

myEmitter.on('event2', (arg1, arg2) => {

console.log('Le premier argument est :', arg1, 'Le deuxième argument est :',
arg2);
});

myEmitter.on('event3', (arg1, arg2) => {

console.log('Le premier argument est :', arg1, 'Le deuxième argument est :',
arg2);
});
5) Ajoutez un événement personnalisé qui signalera la fin de l'exécution :
myEmitter.on('end', () => {
console.log('Fin d\'exécution');
});
6) Déclenchez les différents événements avec des arguments :
myEmitter.emit('event1', 'Hello', 'world');
myEmitter.emit('event2', 'Bonjour', 'tout le monde');
myEmitter.emit('event3', 'Hola', 'mundo');
7) Déclenchez l'événement de fin d'exécution :
myEmitter.emit('end');
8) Exécutez le programme en utilisant Node.js en exécutant la commande suivante dans le
terminal :
node eventEmitterMulti.js

44
code complet:
const EventEmitter = require('events');
const myEmitter = new EventEmitter();

myEmitter.on('event1', (arg1, arg2) => {

console.log('Le premier argument est :', arg1, 'Le deuxième argument est :',
arg2);
});

myEmitter.on('event2', (arg1, arg2) => {

console.log('Le premier argument est :', arg1, 'Le deuxième argument est :',
arg2);
});

myEmitter.on('event3', (arg1, arg2) => {

console.log('Le premier argument est :', arg1, 'Le deuxième argument est :',
arg2);
});

myEmitter.on('end', () => {
console.log('Fin d\'exécution');
});

myEmitter.emit('event1', 'Hello', 'world');

myEmitter.emit('event2', 'Bonjour', 'tout le monde');
myEmitter.emit('event3', 'Hola', 'mundo');

myEmitter.emit('end');

45
4) Créer un programme Node.js qui lit le contenu d'un fichier texte, en supprime toutes les
voyelles, puis écrit le résultat dans un nouveau fichier texte.
Instructions :
1) Créez un fichier JavaScript et nommez-le 'manipulationFichier.js'.
2) Importez le module 'fs' en utilisant la syntaxe require.
3) Utilisez la méthode 'readFile' pour lire le contenu du fichier texte à manipuler.
4) Supprimez toutes les voyelles du contenu du fichier en utilisant une expression
régulière.
5) Utilisez la méthode 'writeFile' pour écrire le nouveau contenu dans un nouveau fichier
texte.
6) Exécutez le programme en utilisant Node.js.

Solution avec détails :

1) Créez un nouveau fichier JavaScript et nommez-le 'manipulationFichier.js'.

2) Importez le module 'fs' en utilisant la syntaxe require :
const fs = require('fs');
3) Utilisez la méthode 'readFile' pour lire le contenu du fichier texte à manipuler :
fs.readFile('fichier_a_manipuler.txt', 'utf8', (err, data) => {
if (err) throw err;
console.log('Contenu du fichier avant manipulation :', data);
});

4) Supprimez toutes les voyelles du contenu du fichier en utilisant une expression régulière :
const contenuSansVoyelles = data.replace(/[aeiou]/gi, '');

La ligne de code est une expression régulière qui permet de remplacer toutes les
voyelles dans une chaîne de caractères par une chaîne vide.

La première partie de l'expression régulière, /[aeiou]/gi, est une expression régulière

qui correspond à toutes les voyelles minuscules. La barre oblique inverse ( /) indique
qu'il s'agit d'une expression régulière. Les lettres a, e, i, o, et u correspondent aux
voyelles minuscules. Le modificateur gi indique que l'expression régulière doit être
appliquée à l'ensemble de la chaîne de caractères, y compris les caractères de fin de
ligne.

La deuxième partie de l'expression régulière, '', est la chaîne vide qui remplacera
toutes les voyelles.

5)Utilisez la méthode 'writeFile' pour écrire le nouveau contenu dans un nouveau fichier texte :
fs.writeFile('fichier_manipule.txt', contenuSansVoyelles, (err) => {
if (err) throw err;
console.log('Le fichier a été manipulé et enregistré avec succès !');
});

6) Exécutez le programme en utilisant Node.js en exécutant la commande suivante dans le

terminal :
node manipulationFichier.js
Le programme devrait lire le contenu du fichier texte à manipuler, supprimer toutes les
voyelles, puis écrire le nouveau contenu dans un nouveau fichier texte.
code complet:
46
 const fs = require('fs');
fs.readFile('fichier_a_manipuler.txt', 'utf8', (err, data) => {
if (err) throw err;
console.log('Contenu du fichier avant manipulation :', data);

const contenuSansVoyelles = data.replace(/[aeiou]/gi, '');

fs.writeFile('fichier_manipule.txt', contenuSansVoyelles, (err) => {

if (err) throw err;
console.log('Le fichier a été manipulé et enregistré avec succès !');
});
});

5) Créez un EventEmitter qui écoute une variable de comptage et qui émet un événement
chaque fois que le compteur atteint un multiple de 10. Ajoutez un écouteur d'événements qui
se déclenche chaque fois qu'un multiple de 10 est atteint et qui affiche le nombre de fois que
le compteur a été atteint.

const EventEmitter = require('events');

class Counter extends EventEmitter {
constructor() {
super();
this.count = 0;
}
increment() {
this.count++;
if (this.count % 10 === 0) {
this.emit('multiple_of_10', this.count);
}
}
}
const counter = new Counter();

counter.on('multiple_of_10', (count) => {

console.log(`Le compteur a atteint un multiple de 10 (${count} fois)`);
});

for (let i = 0; i < 100; i++) {

counter.increment();
}

1. Importation du module events:

• const EventEmitter = require('events');

o Cette ligne importe la classe EventEmitter du module events intégré à Node.js.
o La classe EventEmitter permet à un objet d'émettre des événements qui peuvent
être écoutés par d'autres parties du code.

47
2. Création d'une classe Counter qui hérite de EventEmitter:

• class Counter extends EventEmitter {…}

o Cette classe définit un compteur qui peut émettre des événements lorsqu'il atteint
des multiples de 10.

3. Constructeur de la classe Counter:

constructor() {
super();
this.count = 0;}

o Le constructeur initialise le compteur à 0.

o Il appelle la méthode super() pour s'assurer que le constructeur de la classe
parente (EventEmitter) est également appelé.

4. Méthode increment():

increment() {
this.count++;
if (this.count % 10 === 0) {
this.emit('multiple_of_10', this.count);
}

o Cette méthode incrémente le compteur de 1.

o Si le compteur est maintenant un multiple de 10, il émet un événement
nommé 'multiple_of_10' avec la valeur du compteur en tant que donnée.

5. Création d'une instance de Counter:

const counter = new Counter();

o Cette ligne crée une nouvelle instance de la classe Counter.

6. Écoute de l'événement 'multiple_of_10':

counter.on('multiple_of_10', (count) => {

console.log(`Le compteur a atteint un multiple de 10 (${count} fois)`);}) ;

o Cette ligne écoute l'événement 'multiple_of_10' émis par l'instance counter.

o Lorsqu'un événement est émis, la fonction anonyme fournie est exécutée.
o Cette fonction affiche un message dans la console indiquant que le compteur a
atteint un multiple de 10, ainsi que le nombre de fois qu'il a été incrémenté.

48
7. Boucle d'incrémentation du compteur:

for (let i = 0; i < 100; i++) {

counter.increment();
}

o Cette boucle incrémente le compteur 100 fois.

o À chaque itération, la méthode increment() est appelée, ce qui peut déclencher
l'émission d'un événement 'multiple_of_10'.

Donc :

• Le programme crée un compteur qui peut émettre des événements lorsqu'il atteint des
multiples de 10.
• Le compteur est incrémenté 100 fois.
• À chaque multiple de 10, un message est affiché indiquant que le compteur a atteint un
multiple de 10 et le nombre de fois qu'il a été incrémenté.

49
 ==================================== Partie 6=======================================

Télécharger des fichiers Node.js

1) Module Formidable

Il existe un très bon module pour travailler avec les téléchargements de fichiers, appelé
"Formidable".

Le module Formidable peut être téléchargé et installé à l'aide de NPM :

C:\Users\Your Name>npm install formidable

Après avoir téléchargé le module Formidable, vous pouvez inclure le module dans
n'importe quelle application :

var formidable = require('formidable');

2) Télécharger des fichiers

Vous êtes maintenant prêt à créer une page Web dans Node.js qui permet à l'utilisateur
de télécharger des fichiers sur votre ordinateur :

Étape 1 : Créer un formulaire de téléchargement

Créez un fichier Node.js qui écrit un formulaire HTML, avec un champ de

téléchargement :

Exemple
Ce code produira un formulaire HTML :

var http = require('http');

http.createServer(function (req, res) {

res.writeHead(200, {'Content-Type': 'text/html'});
res.write('<form action="fileupload" method="post" enctype="multipart/form-
data">');
res.write('<input type="file" name="filetoupload"><br>');
res.write('<input type="submit">');
res.write('</form>');
return res.end();
}).listen(8084);

50
Étape 2 : Analyser le fichier téléchargé

Incluez le module Formidable pour pouvoir analyser le fichier téléchargé une fois qu'il
atteint le serveur.

Lorsque le fichier est téléchargé et analysé, il est placé dans un dossier temporaire sur
votre ordinateur.

Exemple
Le fichier sera téléchargé et placé dans un dossier temporaire :

var http = require('http');

var formidable = require('formidable');

http.createServer(function (req, res) {

if (req.url == '/fileupload') {
var form = new formidable.IncomingForm();
form.parse(req, function (err, fields, files) {
res.write('File uploaded');
res.end();
});
} else {
res.writeHead(200, {'Content-Type': 'text/html'});
res.write('<form action="fileupload" method="post" enctype="multipart/form-
data">');
res.write('<input type="file" name="filetoupload"><br>');
res.write('<input type="submit">');
res.write('</form>');
return res.end();
}
}).listen(8084);

Étape 3 : Enregistrer le fichier

Lorsqu'un fichier est téléchargé avec succès sur le serveur, il est placé dans un dossier
temporaire.

Le chemin d'accès à ce répertoire se trouve dans l'objet "files", passé en troisième

argument dans la parse() fonction de rappel de la méthode.

51
Pour déplacer le fichier dans le dossier de votre choix, utilisez le module File System, et
renommez le fichier :

Exemple
Incluez le module fs et déplacez le fichier dans le dossier actuel :

var http = require('http');

var formidable = require('formidable');
var fs = require('fs');

http.createServer(function (req, res) {

if (req.url == '/fileupload') {
var form = new formidable.IncomingForm();
form.parse(req, function (err, fields, files) {
var oldpath = files.filetoupload.filepath;
var newpath = 'C:/SS/' + files.filetoupload.originalFilename;
fs.rename(oldpath, newpath, function (err) {
if (err) throw err;
res.write('File uploaded and moved!');
res.end();
});
});
} else {
res.writeHead(200, {'Content-Type': 'text/html'});
res.write('<form action="fileupload" method="post" enctype="multipart/form-
data">');
res.write('<input type="file" name="filetoupload"><br>');
res.write('<input type="submit">');
res.write('</form>');
return res.end();
}
}).listen(8080);
-----------------------------------------------------------------------------------------------------------------------------

Le programme utilise également les modules formidable et fs. formidable est un module
qui permet de traiter les données de formulaire HTML, y compris les fichiers
téléchargés. fs est un module qui permet de manipuler les fichiers et les répertoires.

Lorsque l'utilisateur accède à l'URL racine du serveur, le programme envoie un

formulaire HTML qui permet à l'utilisateur de télécharger un fichier. Lorsque
l'utilisateur soumet le formulaire, le programme vérifie si la requête est pour
l'URL /fileupload. Si c'est le cas, il utilise formidable pour analyser les données
de formulaire et récupérer le fichier téléchargé. Ensuite, il utilise fs pour
renommer le fichier téléchargé et le déplacer vers le répertoire spécifié.
Si la requête n'est pas pour /fileupload, le programme envoie simplement le
formulaire HTML pour télécharger un fichier.

Ce code est un exemple d'utilisation de Node.js pour créer un serveur HTTP qui
permet de télécharger un fichier et de le sauvegarder sur un disque dur. Voici une
explication plus détaillée de chaque partie du code :
52
var http = require('http');
//La première ligne importe le module http de Node.js qui permet de créer un
//serveur HTTP.

var formidable = require('formidable');

//La deuxième ligne importe le module formidable qui permet de traiter facilement
//les formulaires envoyés en POST.

var fs = require('fs');
//La troisième ligne importe le module fs (file system) qui permet de travailler
//avec le système de fichiers.

http.createServer(function (req, res) {

//La quatrième ligne crée un serveur HTTP en appelant la fonction createServer()
//du module http. Cette fonction prend une fonction de rappel qui est appelée à
//chaque fois qu'une requête HTTP est reçue par le serveur.

if (req.url == '/fileupload') {
//Cette ligne vérifie si l'URL de la requête est /fileupload.
// Si c'est le cas, cela signifie que l'utilisateur
//a soumis le formulaire pour télécharger un fichier.

var form = new formidable.IncomingForm();

// Cette ligne crée une nouvelle instance de
// la classe IncomingForm du module formidable.
// Cette classe permet d'analyser les données de formulaire HTML
// et de récupérer les fichiers téléchargés.

form.parse(req, function (err, fields, files) {

// Cette ligne utilise la méthode parse de l'instance form
// pour analyser les données de formulaire.
// Elle prend en paramètre une fonction de rappel
//qui sera exécutée une fois que l'analyse est terminée.
//La fonction de rappel prend trois paramètres :
// - 'err' pour les erreurs éventuelles,
// - 'fields' pour les champs du formulaire
// - 'files' pour les fichiers téléchargés.

var oldpath = files.filetoupload.filepath;

// Cette ligne récupère le chemin d'accès au fichier téléchargé
//en accédant à la propriété 'filepath'
// de l'objet 'files.filetoupload'
// '.filetoupload' est le nom du champ de formulaire
// qui contient le fichier.

var newpath = 'C:/SS/' + files.filetoupload.originalFilename;

53
// Cette ligne définit le nouveau chemin d'accès
// pour le fichier téléchargé. Il s'agit du répertoire
// de destination pour le fichier.
// Le nom du fichier est récupéré à partir
// de la propriété originalFilename de l'objet files.filetoupload.

fs.rename(oldpath, newpath, function (err) {

//Cette ligne utilise la méthode rename du module fs
// pour renommer et déplacer le fichier téléchargé
// vers le nouveau chemin d'accès.
//Elle prend en paramètre une fonction de rappel
// qui sera exécutée une fois que l'opération est terminée.

// Cette ligne vérifie si une erreur s'est produite

// lors du déplacement du fichier.
// Si c'est le cas, une exception est levée.
if (err) throw err;

--------------------------------------------------------------------------------
Avec Gestion d’erreur:

var http = require('http');

var formidable = require('formidable');

var fs = require('fs');

http.createServer(function (req, res) {

if (req.url == '/fileupload') {

var form = new formidable.IncomingForm();

form.parse(req, function (err, fields, files) {

try {

if (err) {

// Renvoyer le formulaire en cas d'erreur

res.writeHead(200, {'Content-Type': 'text/html'});

res.write('<form action="fileupload" method="post" enctype="multipart/form-data">');

res.write('<input type="file" name="filetoupload"><br>');

res.write('<input type="submit">');

res.write('</form>');

return res.end();

var oldpath = files.filetoupload.filepath;

var newpath = 'C:/ss/' + files.filetoupload.originalFilename;

54
 fs.rename(oldpath, newpath, function (err) {

if (err) {

// Renvoyer le formulaire en cas d'erreur

res.writeHead(200, {'Content-Type': 'text/html'});

res.write('<form action="fileupload" method="post" enctype="multipart/form-data">');

res.write('<input type="file" name="filetoupload"><br>');

res.write('<input type="submit">');

res.write('</form>');

return res.end();

// Gérer l'erreur de déplacement

console.error(err);

//res.writeHead(500, {'Content-Type': 'text/plain'});

//res.write('Erreur lors du déplacement du fichier : ' + err.message);

} else {

res.write('File uploaded and moved!');

res.end();

});

} catch (error) {

console.error('Erreur inattendue :', error);

res.writeHead(500, {'Content-Type': 'text/plain'});

res.write('Une erreur inattendue s\'est produite.');

res.end();

});

} else {

// Code pour afficher le formulaire par défaut

res.writeHead(200, {'Content-Type': 'text/html'});

res.write('<form action="fileupload" method="post" enctype="multipart/form-data">');

res.write('<input type="file" name="filetoupload"><br>');

res.write('<input type="submit">');

res.write('</form>');

return res.end();

}).listen(8084);

console.log('Adresse: http://localhost:8084');
--------------------------------------------------------------------------------
55
 ==================================== Partie 7=======================================

Envoyer un e-mail en Node.js

1) Le module Nodemailer

Le module Nodemailer permet d'envoyer facilement des emails depuis votre ordinateur.

Le module Nodemailer peut être téléchargé et installé à l'aide de npm :

C:\Users\Your Name>npm install nodemailer

Après avoir téléchargé le module Nodemailer, vous pouvez inclure le module dans
n'importe quelle application :

var nodemailer = require('nodemailer');

2) Envoyer un e-mail

Vous êtes maintenant prêt à envoyer des e-mails depuis votre serveur.

Utilisez le nom d'utilisateur et le mot de passe de votre fournisseur de messagerie

sélectionné pour envoyer un e-mail. Pour vous montrer comment utiliser votre compte
outlook pour envoyer et créer un email de Test sur le web (https://temp-mail.org/fr/)
pour le recevoir :

const nodemailer = require('nodemailer');

// Créer un transporteur SMTP réutilisable en utilisant les informations de
connexion par défaut
let transporter = nodemailer.createTransport({
service: 'outlook',
auth: {
user: 'squalliTest@outlook.com',
pass: 'motdepasse'
}
});
// Définir les options de l'e-mail
let mailOptions = {
from: 'squalliTest@outlook.com',
to: 'egiamfes@gmail.com',
subject: "Test d'envoi d'e-mail c'est squalli",
text: "Ceci est un test d'envoi d'e-mail en utilisant Node.js et Nodemailer Squalli."
};

56
// Envoyer l'e-mail
transporter.sendMail(mailOptions, (error, info) => {
if (error) {
console.log('Erreur lors de l\'envoi de l\'e-mail : ', error);
} else {
console.log('E-mail envoyé avec succès : ', info.response);
}
});

3) Récepteurs multiples

Pour envoyer un e-mail à plusieurs destinataires, ajoutez-les à la propriété "to" de l'objet

mailOptions, séparés par des virgules :

Exemple
Envoyer un e-mail à plusieurs adresses :

var mailOptions = {
from: 'youremail@gmail.com',
to: 'myfriend@yahoo.com, myotherfriend@yahoo.com',
subject: 'Sending Email using Node.js',
text: 'That was easy!'
}

4) Envoyer HTML

Pour envoyer du texte au format HTML dans votre e-mail, utilisez la propriété "html" au
lieu de la propriété "text":

Exemple
Envoyer un e-mail contenant du HTML :

var mailOptions = {
from: 'youremail@gmail.com',
to: 'myfriend@yahoo.com',
subject: 'Sending Email using Node.js',
html: '<h1>Welcome</h1><p>That was easy!</p>'
}

57