==================================== 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