Abonnez-vous à DeepL Pro pour traduire des fichiers plus volumineux.

Visitez www.DeepL.com/pro pour en savoir plus.

haps://www.facebook.com/tutorialspointîndia y https://twitter.com/tutorialspoint
 Node.js

À propos du didacticiel
Node.js est une plateforme/un cadre très puissant basé sur JavaScript et construit sur le
moteur JavaScript V8 de Google Chrome. Il est utilisé pour développer des applications web
à forte intensité d'E/S, comme les sites de streaming vidéo, les applications à page unique et
d'autres applications web. Node.js est open source, entièrement gratuit et utilisé par des
milliers de développeurs dans le monde.

Audience
Ce tutoriel est conçu pour les programmeurs de logiciels qui veulent apprendre les bases de
Node.js et ses concepts architecturaux. Ce tutoriel vous donnera une compréhension
suffisante de tous les composants nécessaires de Node.js avec des exemples appropriés.

Conditions préalables
Avant de commencer ce tutoriel, vous devez avoir des connaissances de base en JavaScript.
Comme nous allons développer des applications web à l'aide de Node.js, il serait bon que
vous ayez une certaine connaissance des autres technologies web telles que HTML, CSS,
AJAX, etc.

Exécuter Node.js en ligne

Pour la plupart des exemples donnés dans ce tutoriel, vous trouverez une option Try it, alors
utilisez cette option pour exécuter vos programmes Node.js sur place et profitez de votre
apprentissage.

Essayez l'exemple suivant en utilisant l'option "Essayez" disponible dans le coin supérieur
droit de la boîte de code d'exemple ci-dessous (sur notre site web) :

/* Programme Hello World ! en Node.js */

console.log("Hello World !") ;

Droits d'auteur et clause de non-responsabilité

Copyright 2016 par Tutorials Point (I) Pvt. Ltd.

Tous les contenus et graphiques publiés dans ce livre électronique sont la propriété de
Tutorials Point (I) Pvt. Ltd. Il est interdit à l'utilisateur de ce livre électronique de
réutiliser, conserver, copier, distribuer ou republier tout ou partie du contenu de ce livre
électronique de quelque manière que ce soit sans l'accord écrit de l'éditeur.

Nous nous efforçons de mettre à jour le contenu de notre site Web et de nos didacticiels
aussi rapidement et précisément que possible, mais le contenu peut contenir des
inexactitudes ou des erreurs. Tutorials Point (I) Pvt. Ltd. ne donne aucune garantie quant
à l'exactitude, l'actualité ou l'exhaustivité de notre site web ou de son contenu, y
compris ce tutoriel. Si vous découvrez des erreurs sur notre site Web ou dans ce tutoriel,
veuillez nous en informer à l'adresse contact@tutorialspoint.com.

i
 Node.js

Table des matières

À propos du didacticiel ......................................................................................................................................i
Audience............................................................................................................................................................i
Conditions préalables ........................................................................................................................................i
Exécuter Node.js en ligne..................................................................................................................................i
Droits d'auteur et clause de non-responsabilité................................................................................................i
Table des matières ...........................................................................................................................................ii

1. Introduction.............................................................................................................................................1
Qu'est-ce que Node.js ? ...................................................................................................................................1
Caractéristiques de Node.js .............................................................................................................................1
Qui utilise Node.js ?..........................................................................................................................................2
Concepts...........................................................................................................................................................2
Où utiliser Node.js ? .........................................................................................................................................2
Où ne pas utiliser Node.js ?..............................................................................................................................2

2. Configuration de l'environnement .............................................................................................................3

Essayer l'option en ligne...................................................................................................................................3
Configuration de l'environnement local............................................................................................................3
Éditeur de texte................................................................................................................................................3
Le moteur d'exécution Node.js.........................................................................................................................3
Télécharger Node.js Archive ............................................................................................................................4
Installation sur UNIX/Linux/Mac OS X et SunOS ..............................................................................................4
Installation sous Windows ...............................................................................................................................4
Vérifier l'installation : Exécution d'un fichier....................................................................................................5

3. Première application................................................................................................................................6
Création d'une application Node.js ..................................................................................................................6

4. Terminal REPL ..........................................................................................................................................9

Terminal REPL en ligne .....................................................................................................................................9
Commandes REPL...........................................................................................................................................11
Arrêt de REPL..................................................................................................................................................11

5. NPM.......................................................................................................................................................12
Installer des modules avec NPM ....................................................................................................................12
Installation globale ou locale..........................................................................................................................12
Utilisation de package.json.............................................................................................................................14
Attributs de Package.json...............................................................................................................................19
Désinstallation d'un module ..........................................................................................................................19
Mise à jour d'un module ................................................................................................................................19
Rechercher un module...................................................................................................................................19
Créer un module ............................................................................................................................................19

6. Concept de rappel ..................................................................................................................................21

Qu'est-ce que le rappel ? ...............................................................................................................................21
Exemple de code de blocage..........................................................................................................................21
Exemple de code non bloquant......................................................................................................................22

ii
 Node.js
7. Boucle événementielle ...........................................................................................................................23
Programmation événementielle .....................................................................................................................23
Exemple..........................................................................................................................................................24
Comment fonctionnent les applications Node ?.............................................................................................25

8. Émetteur d'événements .........................................................................................................................26

Classe EventEmitter ........................................................................................................................................26
Méthodes .......................................................................................................................................................26
Méthodes de classe........................................................................................................................................27
Evénements....................................................................................................................................................28
Exemple..........................................................................................................................................................28

9. Tampons ................................................................................................................................................30
Création de tampons ......................................................................................................................................30
Écriture dans les tampons..............................................................................................................................30
Lecture des tampons......................................................................................................................................31
Convertir un tampon en JSON........................................................................................................................32
Concaténer des tampons................................................................................................................................33
Comparer les tampons ...................................................................................................................................33
Tampon de copie............................................................................................................................................34
Tampon à tranches.........................................................................................................................................35
Longueur de la mémoire tampon...................................................................................................................36
Méthodes Référence......................................................................................................................................36
Méthodes de classe........................................................................................................................................41

10. Cours d'eau ............................................................................................................................................43

Qu'est-ce qu'un flux ? ....................................................................................................................................43
Lire à partir d'un cours d'eau..........................................................................................................................43
Écrire au fil de l'eau ........................................................................................................................................44
La canalisation des cours d'eau ......................................................................................................................45
Enchaîner les flux ...........................................................................................................................................46

11. Système de fichiers ................................................................................................................................48

Synchrone ou asynchrone ..............................................................................................................................48
Ouvrir un fichier .............................................................................................................................................49
Obtenir des informations sur les fichiers........................................................................................................51
Écriture d'un fichier ........................................................................................................................................53
Lecture d'un fichier.........................................................................................................................................54
Fermeture d'un fichier....................................................................................................................................56
Tronquer un fichier.........................................................................................................................................57
Supprimer un fichier.......................................................................................................................................59
Créer un répertoire ........................................................................................................................................60
Lire un annuaire .............................................................................................................................................61
Supprimer un répertoire ................................................................................................................................62
Méthodes Référence......................................................................................................................................63

12. Objets globaux .......................................................................................................................................69

nom de fichier...............................................................................................................................................69
nom de domaine ............................................................................................................................................69
setTimeout(cb, ms) .........................................................................................................................................70
clearTimeout (t) ..............................................................................................................................................70
setInterval(cb, ms) ..........................................................................................................................................71
Objets globaux ...............................................................................................................................................71

iii
 Node.js
Objet de la console .........................................................................................................................................72
Objet du processus.........................................................................................................................................74

13. Modules utilitaires .................................................................................................................................81

Module OS......................................................................................................................................................81
Module de chemin d'accès.............................................................................................................................83
Module net.....................................................................................................................................................85
Module DNS ...................................................................................................................................................92
Module de domaine .......................................................................................................................................95

14. Module Web ..........................................................................................................................................99

Qu'est-ce qu'un serveur web ?.......................................................................................................................99
Architecture des applications web .................................................................................................................99
Créer un serveur web avec Node .................................................................................................................100
Faire une requête au serveur Node.js..........................................................................................................102
Créer un client Web avec Node....................................................................................................................102

15. Cadre express.......................................................................................................................................104

Aperçu de l'Express.......................................................................................................................................104
Installer Express ...........................................................................................................................................104
Exemple de Hello world................................................................................................................................104
Demande et réponse....................................................................................................................................106
Demande d'objet..........................................................................................................................................106
Objet de la réponse ......................................................................................................................................109
Routage de base ...........................................................................................................................................115
Servir des fichiers statiques..........................................................................................................................118
Méthode GET ...............................................................................................................................................119
Méthode POST .............................................................................................................................................121
Téléchargement de fichiers ..........................................................................................................................123
Gestion des cookies......................................................................................................................................125

16. API RESTful...........................................................................................................................................126

Qu'est-ce que l'architecture REST ?..............................................................................................................126
Méthodes HTTP............................................................................................................................................126
Services Web RESTful ...................................................................................................................................126
Créer RESTful pour une bibliothèque ...........................................................................................................126
Liste des utilisateurs .....................................................................................................................................128
Ajouter des utilisateurs ................................................................................................................................129
Afficher les détails........................................................................................................................................130
Supprimer un utilisateur...............................................................................................................................131

17. Mise à l'échelle d'une application.........................................................................................................133

La méthode exec()........................................................................................................................................133
La méthode spawn().....................................................................................................................................135
La méthode fork().........................................................................................................................................137

18. Emballage ............................................................................................................................................139

Installation de JXcore....................................................................................................................................139
Emballage du code .......................................................................................................................................140
Lancement d'un fichier JX.............................................................................................................................140

iv
 1. Introduction Node.js

Qu'est-ce que Node.js ?

Node.js est une plateforme côté serveur construite sur le moteur JavaScript de Google
Chrome (moteur V8). Node.js a été développé par Ryan Dahl en 2009 et sa dernière version
est la v0.10.36. La définition de Node.js telle que fournie par sa documentation officielle
est la suivante :

Node.js est une plateforme basée sur le moteur d'exécution JavaScript de Chrome,
qui permet de créer facilement des applications réseau rapides et évolutives.
Node.js utilise un modèle d'E/S événementiel et non bloquant qui le rend léger et
efficace, parfait pour les applications en temps réel à forte intensité de données qui
s'exécutent sur des appareils distribués.

Node.js est un environnement d'exécution open source et multiplateforme pour le

développement d'applications côté serveur et de réseaux. Les applications Node.js sont
écrites en JavaScript et peuvent être exécutées dans l'environnement d'exécution Node.js
sur OS X, Microsoft Windows et Linux.

Node.js fournit également une riche bibliothèque de divers modules JavaScript, ce qui
simplifie considérablement le développement d'applications web à l'aide de Node.js.

Node.js = environnement d'exécution + bibliothèque JavaScript

Caractéristiques de Node.js
Voici quelques-unes des caractéristiques importantes qui font de Node.js le premier choix
des architectes de logiciels.

• Asynchronisme et gestion des événements - Toutes les API de la bibliothèque

Node.js sont asynchrones, c'est-à-dire non bloquantes. Cela signifie
essentiellement qu'un serveur basé sur Node.js n'attend jamais qu'une API
renvoie des données. Le serveur passe à l'API suivante après l'avoir appelée et un
mécanisme de notification des événements de Node.js aide le serveur à obtenir une
réponse de l'appel API précédent.

• Très rapide - Construite sur le moteur JavaScript V8 de Google Chrome, la

bibliothèque Node.js est très rapide dans l'exécution du code.

• Simple thread mais hautement évolutif - Node.js utilise un modèle simple thread
avec une boucle d'événements. Le mécanisme des événements permet au
serveur de répondre de manière non bloquante et le rend hautement évolutif,
contrairement aux serveurs traditionnels qui créent un nombre limité de threads
pour traiter les demandes. Node.js utilise un programme à thread unique et ce
même programme peut répondre à un nombre beaucoup plus important de
demandes que les serveurs traditionnels tels que le serveur HTTP Apache.

• Pas de mise en mémoire tampon - Les applications Node.js ne mettent jamais de

1
 données en mémoire tampon. Elles émettent simplement les données par
morceaux.

• Licence - Node.js est publié sous la licence MIT.

2
 Node.js

Qui utilise Node.js ?

Voici le lien vers le wiki github contenant une liste exhaustive de projets, d'applications et
d'entreprises qui utilisent Node.js. Cette liste comprend eBay, General Electric, GoDaddy,
Microsoft, PayPal, Uber, Wikipins, Yahoo ! et Yammer, pour n'en citer que quelques-uns.

• Projets, applications et entreprises utilisant Node

Concepts
Le diagramme suivant décrit certaines parties importantes de Node.js que nous aborderons
en détail dans les chapitres suivants.

Où utiliser Node.js ?
Voici les domaines dans lesquels Node.js s'avère être un partenaire technologique idéal.

● Applications liées aux E/S

● Applications de flux de données
● Applications en temps réel à forte intensité de données (DIRT)
● Applications basées sur des API JSON
● Applications à page unique

Où ne pas utiliser Node.js ?

Il n'est pas conseillé d'utiliser Node.js pour des applications à forte intensité de CPU.

3
 2. Configuration de l'environnement Node.js

Essayez l'option en ligne

Vous n'avez pas besoin de créer votre propre environnement pour commencer à apprendre
Node.js. La raison est très simple, nous avons déjà mis en place un environnement Node.js
en ligne, afin que vous puissiez exécuter tous les exemples disponibles en ligne et apprendre
par la pratique. N'hésitez pas à modifier n'importe quel exemple et à vérifier les résultats
avec différentes options.

Essayez l'exemple suivant en utilisant l'option "Essayez" disponible dans le coin supérieur
droit de la boîte de code d'exemple ci-dessous (sur notre site web) :

/* Programme Hello World ! en Node.js */

console.log("Hello World !") ;

Pour la plupart des exemples donnés dans ce tutoriel, vous trouverez une option Essayer,
alors utilisez-la et profitez de votre apprentissage.

Configuration de l'environnement local

Si vous souhaitez configurer votre environnement pour Node.js, vous devez avoir les
deux logiciels suivants sur votre ordinateur, (a) un éditeur de texte et (b) les binaires
installables de Node.js.

Éditeur de texte
Vous devez disposer d'un éditeur de texte pour taper votre programme. Voici quelques
exemples d'éditeurs de texte : Windows Notepad, OS Edit command, Brief, Epsilon,
EMACS, vim ou vi.

Le nom et la version des éditeurs de texte peuvent varier d'un système d'exploitation à
l'autre. Par exemple, Notepad sera utilisé sous Windows, et vim ou vi peuvent être utilisés
sous Windows ainsi que sous Linux ou UNIX.

Les fichiers que vous créez avec votre éditeur sont appelés fichiers source et contiennent le
code source du programme. Les fichiers source des programmes Node.js sont généralement
nommés avec l'extension ".js".

Avant de commencer à programmer, assurez-vous que vous disposez d'un éditeur de texte
et que vous avez suffisamment d'expérience dans la manière d'écrire un programme
informatique, de l'enregistrer dans un fichier et enfin de l'exécuter.

Le moteur d'exécution Node.js

Le code source que vous écrivez dans un fichier source est simplement du javascript.
L'interpréteur Node.js interprète et exécute votre code javascript.

La distribution Node.js se présente sous la forme d'un binaire installable pour les
4
systèmes d'exploitation SunOS, Linux, Mac OS X et Windows dotés d'architectures de
processeurs x86 32 bits (386) et 64 bits (amd64).

5
 Node.js

La section suivante explique comment installer la distribution binaire de Node.js sur différents systèmes
d'exploitation.

Télécharger Node.js Archive

Téléchargez la dernière version du fichier d'archive installable de Node.js à partir de
Node.js Downloads. Au moment de la rédaction de ce tutoriel, voici les versions
disponibles sur les différents systèmes d'exploitation.

OS Nom de
l'archive

Fenêtres node-v6.3.1-x64.msi

Linux node-v6.3.1-linux-x86.tar.gz

Mac node-v6.3.1-darwin-x86.tar.gz

SunOS node-v6.3.1-sunos-x86.tar.gz

Installation sur UNIX/Linux/Mac OS X et SunOS

En fonction de l'architecture de votre système d'exploitation, téléchargez et extrayez
l'archive node-v0.12.0- osname.tar.gz dans /tmp, puis déplacez les fichiers extraits dans le
répertoire /usr/local/nodejs. Par exemple :

$ cd /tmp
$ wget http://nodejs.org/dist/v6.3.1/node-v6.3.1-linux-x64.tar.gz
tar xvfz node-v6.3.1-linux-x64.tar.gz
$ mkdir -p /usr/local/nodejs
$ mv node-v6.3.1-linux-x64/* /usr/local/nodejs
Ajoutez /usr/local/nodejs/bin à la variable d'environnement PATH.

OS Sortie

Linux export PATH=$PATH:/usr/local/nodejs/bin

Mac export PATH=$PATH:/usr/local/nodejs/bin

FreeBSD export PATH=$PATH:/usr/local/nodejs/bin

Installation sous Windows

Utilisez le fichier MSI et suivez les instructions pour installer Node.js. Par défaut, le
programme d'installation utilise la distribution Node.js dans C:\Program Files\nodejs. Le
programme d'installation doit définir le répertoire C:\Program Files\nodejs\bin dans la
variable d'environnement PATH de Window. Redémarrez toutes les invites de commande
6
 Node.js
ouvertes pour que la modification prenne effet.

7
 Node.js

Vérifier l'installation : Exécution d'un fichier

Créez un fichier js nommé main.js sur votre machine (Windows ou Linux) contenant le code
suivant.

/* Programme Hello, World ! en node.js */

console.log("Hello, World !")

Exécutez maintenant main.js à l'aide de l'interpréteur Node.js pour voir le résultat :

$ node main.js
Si tout se passe bien, votre installation devrait donner le résultat suivant :

Bonjour à tous !

8
 3. Première application Node.js

Avant de créer une application "Hello, World !" à l'aide de Node.js, voyons les composants
d'une application Node.js. Une application Node.js se compose des trois éléments
importants suivants :

1. Importer les modules requis : Nous utilisons la directive require pour charger les
modules Node.js.

2. Créer un serveur : Un serveur qui écoutera les requêtes des clients, comme le
serveur HTTP Apache.

3. Lire la requête et renvoyer la réponse : Le serveur créé à l'étape précédente lira

la requête HTTP faite par le client, qui peut être un navigateur ou une console, et
renverra la réponse.

Création d'une application Node.js

Étape 1 - Importer le module requis

Nous utilisons la directive require pour charger le module http et stocker l'instance HTTP
renvoyée dans une variable http comme suit :

var http = require("http") ;

Étape 2 - Créer un serveur

Nous utilisons l'instance http créée et appelons la méthode http.createServer() pour créer
une instance de serveur, puis nous la lions au port 8081 en utilisant la méthode listen
associée à l'instance de serveur. Passez-lui une fonction avec les paramètres request et
response. Écrivez l'exemple d'implémentation pour qu'il renvoie toujours "Hello World".

http.createServer(function (request, response) {

// Envoi de l'en-tête HTTP

// Statut HTTP : 200 : OK
// Type de contenu : text/plain
response.writeHead(200, { 'Content-Type' : 'text/plain'}) ;

// Envoyer le corps de la réponse comme "Hello

World" response.end('Hello World\n') ;
}).listen(8081) ;

9
 Node.js

// La console imprimera le message

console.log('Server running at http://127.0.0.1:8081/') ;
Le code ci-dessus suffit à créer un serveur HTTP qui écoute, c'est-à-dire qui attend une
requête sur le port 8081 de la machine locale.

Étape 3 - Test de la demande et de la réponse

Rassemblons les étapes 1 et 2 dans un fichier appelé main.js et démarrons notre serveur
HTTP comme indiqué ci-dessous :

var http = require("http") ;

http.createServer(function (request,
response) {

// Envoi de l'en-tête HTTP

// Statut HTTP : 200 : OK
// Type de contenu : text/plain
response.writeHead(200, {'Content-Type' : 'text/plain'}) ;

// Envoyer le corps de la réponse comme "Hello

World" response.end('Hello World\n') ;
}).listen(8081) ;

// La console imprimera le message

console.log('Server running at
http://127.0.0.1:8081/') ;
Exécutez maintenant le fichier main.js pour démarrer le serveur comme suit :

$ node main.js
Vérifiez la sortie. Le serveur a démarré.

Le serveur fonctionne à l'adresse http://127.0.0.1:8081/

1
0
 Node.js

Faire une demande au serveur Node.js

Ouvrez http://127.0.0.1:8081/ dans n'importe quel navigateur et observez le résultat suivant.

Félicitations, vous avez votre premier serveur HTTP opérationnel qui répond à toutes les
requêtes HTTP sur le port 8081.

1
1
 4. Terminal REPL Node.js

REPL signifie Read Eval Print Loop et représente un environnement informatique tel qu'une
console Windows ou un shell Unix/Linux où une commande est entrée et le système répond
avec une sortie dans un mode interactif. Node.js ou Node est livré avec un environnement
REPL. Il effectue les tâches suivantes :

● Read - Lit les données saisies par l'utilisateur, les analyse en structure de
données JavaScript et les stocke en mémoire.

● Eval - Prend et évalue la structure de données.

● Imprimer - Imprime le résultat.

● Loop - La commande ci-dessus est exécutée en boucle jusqu'à ce que l'utilisateur appuie deux
fois sur ctrl-c.

La fonction REPL de Node est très utile pour expérimenter les codes Node.js et pour
déboguer les codes JavaScript.

Terminal REPL en ligne

Pour simplifier votre apprentissage, nous avons mis en place un environnement Node.js
REPL facile à utiliser en ligne, où vous pouvez pratiquer la syntaxe Node.js : Lancer le
terminal Node.js REPL

Démarrage du REPL
La REPL peut être lancée en exécutant simplement node dans le shell/console sans aucun
argument, comme suit.

Nœud de dollars
Vous verrez l'invite de commande REPL > où vous pouvez taper n'importe quelle commande Node.js :

Nœud de dollars
>

Expression simple
Essayons une simple mathématique à l'invite de commande de Node.js REPL :

Nœud de dollars
>1+3
4
>1+( 2* 3) - 4
3

1
2
 Node.js

>

Utiliser des variables

Vous pouvez utiliser des variables pour stocker des valeurs et les imprimer plus tard, comme
dans tout script conventionnel. Si le mot-clé var n'est pas utilisé, la valeur est stockée dans
la variable et imprimée. Si le mot-clé var est utilisé, la valeur est stockée mais pas imprimée.
Vous pouvez imprimer les variables à l'aide de console.log().

Nœud de dollars
> x = 10 10
> var y = 10
undefined
> x+y
20
> console.log("Hello World")
Hello Workd
undefined

Expression multiligne
Node REPL prend en charge les expressions multilignes comme en JavaScript. Voyons la
boucle do-while suivante en action :

Nœud de dollars
> var x = 0
undefined
> faire {
... x++ ;
... console.log("x : " + x) ;
... } while ( x < 5 ) ;
x:1
x:2
x:3
x:4
x:5
indéfini
>
... vient automatiquement lorsque vous appuyez sur Entrée après la parenthèse ouvrante.
Node vérifie automatiquement la continuité des expressions.

13
 Node.js

Variable de soulignement
Vous pouvez utiliser le trait de soulignement (_) pour obtenir le dernier résultat :

Nœud de dollars
> var x = 10
undefined
> var y = 20
indéfini
> x+y
30
> var sum = _
undefined
> console.log(sum)
30
indéfini
>

Commandes REPL
• ctrl + c - termine la commande en cours.
• ctrl + c deux fois - terminer le Node REPL.
• ctrl + d - terminer le Node REPL.
• Touches haut/bas - pour consulter l'historique des commandes et modifier les commandes
précédentes.
• tab Keys - liste des commandes en cours.
• .help - liste de toutes les commandes.
• .break - sortie d'une expression multiligne.
• .clear - sort d'une expression multiligne.
• .save filename - enregistre la session Node REPL en cours dans un fichier.
• .load filename - charge le contenu du fichier dans la session Node REPL en cours.

Arrêt de REPL
Comme mentionné ci-dessus, vous devrez utiliser ctrl-c deux fois pour sortir du Node.js REPL.

Nœud de dollars
>

(^C à nouveau pour quitter)

>

14
 5. MNP Node.js

Le gestionnaire de paquets Node (NPM) offre deux fonctionnalités principales :

• Dépôts en ligne pour les paquets/modules node.js qui peuvent être recherchés sur
search.nodejs.org

• Utilitaire en ligne de commande pour installer les paquets Node.js, gérer les versions
et les dépendances des paquets Node.js.

NPM est fourni avec les installables Node.js après la version v0.6.3. Pour le vérifier, ouvrez la
console et tapez la commande suivante pour voir le résultat :

$ npm --version 2.7.1

Si vous utilisez une ancienne version de NPM, il est très facile de la mettre à jour. Il suffit
d'utiliser la commande suivante à partir de la racine :

sudo npm install npm -g

/usr/bin/npm ->
/usr/lib/node_modules/npm/bin/npm-
cli.js npm@2.7.1 /usr/lib/node_modules/npm

Installation de modules à l'aide de NPM

Il existe une syntaxe simple pour installer n'importe quel module Node.js :

$ npm install <Nom du module>

Par exemple, voici la commande d'installation d'un célèbre module de framework web
Node.js appelé express :

$ npm install express

Vous pouvez maintenant utiliser ce module dans votre fichier js comme suit :

var express = require('express') ;

Installation globale ou locale

Par défaut, NPM installe toute dépendance en mode local. Ici, le mode local fait référence à
l'installation des paquets dans le répertoire node_modules qui se trouve dans le dossier où
l'application Node est présente. Les paquets déployés localement sont accessibles via la
méthode require(). Par exemple, lorsque nous avons installé le module express, il a créé le
répertoire node_modules dans le répertoire courant où il a installé le module express.

15
 Node.js

$ ls -l
total 0
drwxr-xr-x 3 root root 20 Mar 17 02:23 node_modules
Vous pouvez également utiliser la commande npm ls pour obtenir la liste de tous les modules installés
localement.

Les paquets/dépendances installés globalement sont stockés dans le répertoire système.

Ces dépendances peuvent être utilisées dans la fonction CLI (Command Line Interface) de
n'importe quel node.js mais ne peuvent pas être importées en utilisant require() dans
l'application Node directement. Essayons maintenant d'installer le module express en
utilisant l'installation globale.

$ npm install express -g

Cela produira un résultat similaire, mais le module sera installé globalement. Ici, la première
ligne indique la version du module et l'endroit où il est installé.

express@4.12.2 /usr/lib/node_modules/express
├── merge-descriptors@1.0.0
├── utils-merge@1.0.0
├── cookie-signature@1.0.6
├── methods@1.1.1
├── fresh@0.2.4
├── cookie@0.1.2
├── escape-html@1.0.1
├── range-parser@1.0.2
├── content-type@1.0.1
├── finalhandler@0.3.3
├── vary@1.0.0
├── parseurl@1.3.0
├── content-disposition@0.5.0
├── path-to-regexp@0.1.3
├── depd@1.0.0
├── qs@2.3.3
├── on-finished@2.2.0 (ee-first@1.1.0)
├── etag@1.5.1 (crc@3.2.1)
├── debug@2.1.3 (ms@0.7.0)
├── proxy-addr@1.0.7 (forwarded@0.1.0, ipaddr.js@0.1.9)
├ ─ ─ s e n d @ 0 . 1 2 . 1 ( d e s t r o y @ 1 . 0 . 3 , m s @ 0 . 7 . 0 , mime@1.3.4)
├── serve-static@1.9.2 (send@0.12.2)
├── accepts@1.2.5 (negotiator@0.5.1, mime-
types@2.0.10)
└── type-is@1.6.1 (media-typer@0.3.0, mime- 16
types@2.0.10)
 Node.js

Vous pouvez utiliser la commande suivante pour vérifier tous les modules installés globalement :

$ npm ls -g

Utilisation de package.json
Le fichier package.json est présent dans le répertoire racine de toute application/module
Node et est utilisé pour définir les propriétés d'un paquet. Ouvrons le package.json du
package express présent dans node_modules/express/

{
"nom" : "express",
"description" : "Fast, unopinionated, minimalist web
framework", "version" : "4.11.2",
"auteur" : {
"name" : "TJ Holowaychuk",
"email" : "tj@vision-
media.ca"
},
"contributeurs" : [
{
"nom" : "Aaron Heckmann",
"email" : "aaron.heckmann+github@gmail.com"
},
{
"name" : "Ciaran Jessup",
"email" :
"ciaranj@gmail.com"
},
{
"name" : "Douglas Christopher
Wilson", "email" :
"doug@somethingdoug.com"
},
{
"name" : "Guillermo Rauch",
"email" :
"rauchg@gmail.com"
},
{
"name" : "Jonathan Ong", 17
"email" :
"me@jongleberry.com"
},
 Node.js

{
"nom" : "Roman Shtylman",
"email" : "shtylman+expressjs@gmail.com"
},
{
"name" : "Young Jae Sim",
"email" :
"hanul@hanul.me"
}
],
"licence" : "MIT", "repository"
: {
"type" : "git",
"url" : "https://github.com/strongloop/express"
},
"homepage" : "http://expressjs.com/",
"keywords" : [
"express",
"framework",
"sinatra", "web",
"rest",
"restful"
, "router",
"app",
"ap
i"
],
"dependencies" :
{"accepts" : "~1.2.3",
"content-disposition" : "0.5.0",
"cookie-signature" : "1.0.5",
"debug" : "~2.1.1",
"depd" : "~1.0.0",
"escape-html" : "1.0.1",
"etag" : "~1.5.1",
"finalhandler" : "0.3.3",
"fresh" : "0.2.4",
18
 Node.js
"media-typer" : "0.3.0",

19
 Node.js

"methods" : "~1.1.1",
"on-finished" : "~2.2.0",
"parseurl" : "~1.3.0",
"path-to-regexp" : "0.1.3",
"proxy-addr" : "~1.0.6",
"qs" : "2.3.3",
"range-parser" : "~1.0.2",
"send" : "0.11.1",
"serve-static" : "~1.8.1",
"type-is" : "~1.5.6",
"vary" : "~1.0.0",
"cookie" : "0.1.2",
"merge-descriptors" : "0.0.2",
"utils-merge" : "1.0.0"
},
"devDependencies" : {
"after" : "0.8.1",
"ejs" : "2.1.4",
"istanbul" : "0.3.5",
"marqué" : "0.3.3",
"mocha" : "~2.1.0",
"devrait" : "~4.6.2",
"supertest" : "~0.15.0",
"hjs" : "~0.0.6",
"body-parser" : "~1.11.0",
"connect-redis" : "~2.2.0",
"cookie-parser" : "~1.3.3",
"express-session" : "~1.10.2",
"jade" : "~1.9.1",
"method-override" : "~2.3.1",
"morgan" : "~1.5.1",
"multiparty" : "~4.1.1",
"vhost" : "~3.0.0"
},
"moteurs" : {
"node" : ">= 0.10.0"
},
16
 Node.js

"fichiers" :
["LICENSE",
"History.md",
"Readme.md",
"index.js",
"lib/"
],
"scripts" : {
"test" : "mocha --require test/support/env --reporter spec --bail -
check-leaks test/ test/acceptance/",

"test-cov" : "istanbul cover node_modules/mocha/bin/_mocha

-- -- require test/support/env --reporter dot --check-leaks
test/ test/acceptance/",

"test-tap" : "mocha --require test/support/env --reporter tap -

check-leaks test/ test/acceptance/",

"test-travis" : "istanbul cover

node_modules/mocha/bin/_mocha - report lcovonly -- --require
test/support/env --reporter spec - check-leaks test/
test/acceptance/"
},
"gitHead" : "63ab25579bda70b4927a179b580a9c580b6c7ada",
"bugs": {
"url" : "https://github.com/strongloop/express/issues"
},
"_id" : "express@4.11.2",
"_shasum" : "8df3d5a9ac848585f00a0777601823faecd3b148",
"_from": "express@*",
"_npmVersion" :
"1.4.28",
"_npmUser" : {
"nom" : "dougwilson",
"email" : "doug@somethingdoug.com"
},
"maintainers" : [
17
 Node.js
{
"nom" : "tjholowaychuk",

18
 Node.js

"email" : "tj@vision-media.ca"
},
{
"nom" : "jongleberry",
"email" : "jonathanrichardong@gmail.com"
},
{
"nom" : "shtylman",
"email" : "shtylman@gmail.com"
},
{
"nom" : "dougwilson",
"email" : "doug@somethingdoug.com"
},
{
"nom" : "aredridel",
"email" : "aredridel@nbtsc.org"
},
{
"nom" : "strongloop",
"email" : "callback@strongloop.com"
},
{
"nom" : "rfeng",
"email" : "enjoyjava@gmail.com"
}
],
"dist" : {
"shasum" : "8df3d5a9ac848585f00a0777601823faecd3b148",
"tarball" : "http://registry.npmjs.org/express/-/express-4.11.2.tgz"
},
"répertoires" : {},
"_resolved" : "https://registry.npmjs.org/express/-/express-4.11.2.tgz",
"readme" : "ERROR : No README data found !"
}

19
 Node.js

Attributs de Package.json
• name - nom du paquet

• version - version du paquet

• description - description du paquet

• homepage - page d'accueil du paquet

• auteur - auteur du paquet

• contributeurs - nom des contributeurs au paquet

• dépendances - liste des dépendances. NPM installe automatiquement

installe toutes les dépendances mentionnées ici dans le dossier
node_module du paquet.

• référentiel - type de référentiel et URL du paquet

• main - point d'entrée du paquet

• mots-clés - mots-clés

Désinstallation d'un module

Utilisez la commande suivante pour désinstaller un module Node.js.

$ npm uninstall express

Une fois que NPM a désinstallé le paquet, vous pouvez le vérifier en regardant le contenu du fichier
/node_modules/ ou tapez la commande suivante :

$ npm ls

Mise à jour d'un module

Mettez à jour le fichier package.json et modifiez la version de la dépendance à mettre à jour,
puis exécutez la commande suivante.

$ npm update express

Rechercher un module
Rechercher un nom de paquet à l'aide de NPM.

$ npm search express

Créer un module
La création d'un module nécessite la génération du fichier package.json. Générons le
package.json en utilisant NPM, qui va générer le squelette de base du package.json.

20
 Node.js

$ npm init
Cet utilitaire vous guidera dans la création d'un fichier package.json.
Il ne couvre que les éléments les plus courants et tente de deviner des
valeurs par défaut raisonnables.

Voir 'npm help json' pour une documentation définitive sur ces
champs et ce qu'ils font exactement.

Utilisez ensuite 'npm install <pkg> --save' pour installer un

paquet et l'enregistrer en tant que dépendance dans le fichier
package.json.

Appuyez sur ^C à tout moment

pour quitter. nom : (webmaster)

Vous devrez fournir toutes les informations nécessaires sur votre module. Vous pouvez vous
aider du fichier package.json mentionné ci-dessus pour comprendre la signification des
différentes informations demandées. Une fois le fichier package.json généré, utilisez la
commande suivante pour vous enregistrer sur le site du dépôt NPM en utilisant une adresse
email valide.

$ npm adduser Nom

d'utilisateur : mcmohd
Mot de passe :
Courriel : (ceci est public) mcmohd@gmail.com
Il est maintenant temps de publier votre module :

$ npm publish
Si tout va bien avec votre module, alors il sera publié dans le dépôt et sera accessible à
l'installation en utilisant NPM comme n'importe quel autre module Node.js.

21
 6. Concept de rappel Node.js

Qu'est-ce que le rappel ?

La fonction de rappel est l'équivalent asynchrone d'une fonction. Une fonction de rappel est
appelée à la fin d'une tâche donnée. Node fait un usage intensif des rappels. Toutes les API
de Node sont écrites de manière à prendre en charge les rappels.

Par exemple, une fonction de lecture d'un fichier peut commencer à lire un fichier et
renvoyer immédiatement le contrôle à l'environnement d'exécution afin que l'instruction
suivante puisse être exécutée. Une fois l'E/S de fichier terminée, elle appellera la fonction
de rappel en lui transmettant le contenu du fichier en tant que paramètre. Il n'y a donc pas
de blocage ou d'attente pour l'E/S de fichier. Cela rend Node.js très évolutif, car il peut
traiter un grand nombre de demandes sans attendre qu'une fonction renvoie des résultats.

Exemple de code de blocage

Créez un fichier texte nommé input.txt avec le contenu suivant :

Tutorials Point propose des contenus

d'auto-apprentissage pour enseigner le monde de
manière simple et facile !!!!!

Créez un fichier js nommé main.js avec le code suivant :

var fs = require("fs") ;

var data = fs.readFileSync('input.txt') ;

console.log(data.toString()) ;
console.log("Programme terminé") ;

Exécutez maintenant le fichier main.js pour voir le résultat :

$ node main.js
Vérifier la sortie.

Tutorials Point propose des contenus d'auto-

apprentissage pour enseigner le monde de manière
simple et facile !!!!! Programme terminé

22
 Node.js

Exemple de code non bloquant

Créez un fichier texte nommé input.txt avec le contenu suivant.

Tutorials Point propose des contenus

d'auto-apprentissage pour enseigner le monde de
manière simple et facile !!!!!

Mettez à jour le fichier main.js pour qu'il contienne le code suivant :

var fs = require("fs") ;

fs.readFile('input.txt', function (err, data) {

if (err) return console.error(err) ;
console.log(data.toString()) ;
}) ;

console.log("Programme terminé") ;
Exécutez maintenant le fichier main.js pour voir le résultat :

$ node main.js
Vérifier la sortie.

Programme terminé
Tutorials Point propose des contenus d'auto-
apprentissage pour enseigner le monde de
manière simple et facile !!!!!

Ces deux exemples expliquent le concept d'appels bloquants et non bloquants.

• Le premier exemple montre que le programme se bloque jusqu'à ce qu'il lise le

fichier et qu'il ne procède qu'à la fin du programme.

• Le deuxième exemple montre que le programme n'attend pas la lecture du fichier et

procède à l'impression de "Programme terminé" et, en même temps, le programme
sans blocage continue à lire le fichier.

Ainsi, un programme bloquant s'exécute de manière très séquentielle. Du point de vue de la

programmation, il est plus facile de mettre en œuvre la logique, mais les programmes non
bloquants ne s'exécutent pas en séquence. Si un programme doit utiliser des données à
traiter, celles-ci doivent être conservées dans le même bloc pour que l'exécution soit
séquentielle.

23
 7. Boucle d'événements Node.js

Node.js est une application monotâche, mais elle peut prendre en charge la concurrence
grâce au concept d'événements et de rappels. Chaque API de Node.js est asynchrone et,
étant donné qu'il s'agit d'une application monotâche, elle utilise des appels de fonction
asynchrones pour maintenir la simultanéité. Node utilise un modèle d'observateur. Le
thread Node maintient une boucle d'événements et chaque fois qu'une tâche est terminée,
il déclenche l'événement correspondant qui signale à la fonction d'écoute d'événements de
s'exécuter.

Programmation événementielle
Node.js utilise fortement les événements et c'est aussi l'une des raisons pour lesquelles
Node.js est assez rapide par rapport à d'autres technologies similaires. Dès que Node
démarre son serveur, il initie simplement ses variables, déclare des fonctions, puis attend
simplement que l'événement se produise.

Dans une application pilotée par les événements, il y a généralement une boucle principale
qui écoute les événements, puis déclenche une fonction de rappel lorsque l'un de ces
événements est détecté.

Bien que les événements ressemblent beaucoup aux rappels, la différence réside dans le fait
que les fonctions de rappel sont appelées lorsqu'une fonction asynchrone renvoie son
résultat, alors que la gestion des événements fonctionne sur le modèle de l'observateur. Les
fonctions qui écoutent les événements agissent en tant qu'observateurs. Chaque fois qu'un
événement est déclenché, la fonction qui l'écoute commence à s'exécuter. Node.js dispose
de plusieurs événements intégrés, disponibles via le module events et la classe
EventEmitter, qui sont utilisés pour lier les événements et les auditeurs d'événements de la
manière suivante :

// Importer le module d'événements

var events = require('events') ;
// Créer un objet eventEmitter
var eventEmitter = new events.EventEmitter() ; 24
 Node.js

La syntaxe suivante permet de lier un gestionnaire d'événements à un événement :

// Lier l'événement et le gestionnaire comme suit

eventEmitter.on('eventName', eventHandler)
;

Nous pouvons déclencher un événement par programme de la manière suivante :

// Déclenche un événement
eventEmitter.emit('eventName') ;

Exemple
Créez un fichier js nommé main.js avec le code suivant :

// Importer le module d'événements

var events = require('events') ;

// Créer un objet eventEmitter

var eventEmitter = new events.EventEmitter() ;

// Créer un gestionnaire d'événements comme suit

var connectHandler = function connected() {
console.log('connection successful.') ;

// Déclenche l'événement data_received

eventEmitter.emit('data_received') ;
}

// Lier l'événement de connexion avec le

gestionnaire eventEmitter.on('connection',
connectHandler) ;

// Lier l'événement data_received avec la fonction anonyme

eventEmitter.on('data_received', function(){
console.log('data received successfully.') ;
}) ;

// Déclenche l'événement de connexion

eventEmitter.emit('connection') ; 25
 Node.js

console.log("Programme terminé.") ;

Essayons maintenant d'exécuter le programme ci-dessus et de vérifier son résultat :

mnode main.js

Le résultat devrait être le suivant :

connexion réussie.
données reçues avec
succès. Programme terminé.

Comment fonctionnent les applications Node ?

Dans l'application Node, toute fonction asynchrone accepte un callback comme dernier
paramètre et une fonction callback accepte une erreur comme premier paramètre.
Reprenons l'exemple précédent. Créez un fichier texte nommé input.txt avec le contenu
suivant.

Tutorials Point propose des contenus

d'auto-apprentissage pour enseigner le monde de
manière simple et facile !!!!!

Créez un fichier js nommé main.js contenant le code suivant :

var fs = require("fs") ;

fs.readFile('input.txt', function (err, data) {

if (err){
console.log(err.stack) ;
return ;
}
console.log(data.toString()) ;
}) ;
console.log("Programme terminé") ;
Ici, fs.readFile() est une fonction asynchrone dont le but est de lire un fichier. Si une erreur
survient pendant l'opération de lecture, l'objet err contiendra l'erreur correspondante,
sinon data contiendra le contenu du fichier. readFile transmet err et data à la fonction de
rappel après la fin de l'opération de lecture, qui imprime finalement le contenu.

Programme terminé
Tutorials Point propose des contenus d'auto-
apprentissage pour enseigner le monde de
manière simple et facile !!!!!
26
 8. Émetteur d'événements Node.js

De nombreux objets d'un nœud émettent des événements, par exemple, un net.Server
émet un événement chaque fois qu'un pair se connecte à lui, un fs.readStream émet un
événement lorsque le fichier est ouvert. Tous les objets qui émettent des événements sont
des instances de events.EventEmitter.

Classe EventEmitter
Comme nous l'avons vu dans la section précédente, la classe EventEmitter se trouve dans le
module events. Elle est accessible via le code suivant :

// Importer le module d'événements

var events = require('events') ;
// Créer un objet eventEmitter
var eventEmitter = new events.EventEmitter() ;
Lorsqu'une instance d'émetteur d'événements est confrontée à une erreur, elle émet un
événement "error". Lorsqu'un nouvel auditeur est ajouté, l'événement "newListener" est
déclenché et lorsqu'un auditeur est supprimé, l'événement "removeListener" est déclenché.

EventEmitter fournit plusieurs propriétés telles que on et emit. La propriété on est utilisée
pour lier une fonction à l'événement et emit est utilisée pour déclencher un événement.

Méthodes

S.No. Méthode et
description
addListener(event, listener)
Ajoute un écouteur à la fin du tableau des écouteurs pour l'événement
1 spécifié. Aucune vérification n'est effectuée pour savoir si l'écouteur a déjà été
ajouté. Plusieurs appels passant la même combinaison d'événement et
d'écouteur se traduiront par l'ajout de l'écouteur plusieurs fois. Retourne
l'émetteur, ce qui permet d'enchaîner les appels.
on(event, listener)
Ajoute un écouteur à la fin du tableau des écouteurs pour l'événement
2 spécifié. Aucune vérification n'est effectuée pour savoir si l'écouteur a déjà été
ajouté. Plusieurs appels passant la même combinaison d'événement et
d'écouteur se traduiront par l'ajout de l'écouteur plusieurs fois. Retourne
l'émetteur, ce qui permet d'enchaîner les appels.

27
 once(event, listener)

Ajoute un écouteur unique à l'événement. Cet écouteur n'est invoqué que la

prochaine fois que l'événement est déclenché, après quoi il est supprimé.
3
Retourne l'émetteur, ce qui permet d'enchaîner les appels.

28
 Node.js

removeListener(event, listener)

Supprime un écouteur du tableau d'écouteurs pour l'événement spécifié.

Attention : Cela modifie les indices du tableau d'auditeurs derrière l'auditeur.
4 removeListener supprime au maximum une instance d'un auditeur du tableau
d'auditeurs. Si un même écouteur a été ajouté plusieurs fois au tableau
d'écouteurs pour l'événement spécifié, alors removeListener doit être appelé
plusieurs fois pour supprimer chaque instance. Retourne l'émetteur, ce qui
permet d'enchaîner les appels.

removeAllListeners([event])
Supprime tous les listeners, ou ceux de l'événement spécifié. Ce n'est pas une
5 bonne idée de supprimer des auditeurs qui ont été ajoutés ailleurs dans le
code, en particulier lorsqu'il s'agit d'un émetteur que vous n'avez pas créé (par
exemple, des sockets ou des flux de fichiers). Retourne l'émetteur, ce qui
permet d'enchaîner les appels.

setMaxListeners(n)
Par défaut, EventEmitters affiche un avertissement si plus de 10 auditeurs sont
6 ajoutés pour un événement particulier. Il s'agit d'une valeur par défaut utile qui
permet de détecter les fuites de mémoire. Il est évident que tous les Emitters ne
doivent pas être limités à 10. Cette fonction permet d'augmenter cette limite.
Elle est fixée à zéro pour un nombre illimité d'émetteurs.

listeners(event)
7
Renvoie un tableau d'auditeurs pour l'événement spécifié.

emit(event, [arg1], [arg2], [...])

8 Exécute chacun des écouteurs dans l'ordre avec les arguments fournis.
Retourne true si l'événement a des auditeurs, false sinon.

Méthodes de classe

S.No. Méthode et
description

1 listenerCount(emitter, event)
Renvoie le nombre d'auditeurs pour un événement donné.

29
 Node.js

Evénements
S. Non. Événements et
description

newListener

• event - Chaîne ; le nom de l'événement

1 • listener - Fonction ; la fonction de traitement de l'événement

Cet événement est émis chaque fois qu'un auditeur est ajouté. Lorsque cet
événement est déclenché, il se peut que l'auditeur n'ait pas encore été
ajouté au tableau des auditeurs de l'événement.

removeListener

• event - Chaîne Le nom de l'événement

• listener - Fonction Fonction de traitement de l'événement

2

Cet événement est déclenché chaque fois que quelqu'un supprime un

auditeur. Lorsque cet événement est déclenché, il se peut que l'auditeur
n'ait pas encore été supprimé du tableau des auditeurs de l'événement.

Exemple
Créez un fichier js nommé main.js avec le code Node.js suivant :

var events = require('events') ;

var eventEmitter = new events.EventEmitter() ;

// auditeur #1
varner1 = function listner1() { console.log('listner1 executed.')
;
}

// auditeur #2
varner2 = function listner2() { console.log('listner2 executed.') ;
}

30
 Node.js

// Lier l'événement de connexion avec la fonction listner1

eventEmitter.addListener('connection', listner1) ;
// Lier l'événement de connexion avec la fonction listner2
eventEmitter.on('connection', listner2) ;

var eventListeners =
require('events').EventEmitter.listenerCount(eventEmitter,'connection') ;
console.log(eventListeners + " Listner(s) listening to connection event") ;

// Déclenche l'événement de connexion

eventEmitter.emit('connection') ;

// Supprimer la liaison de listner1 function

eventEmitter.removeListener('connection', listner1) ;
console.log("Listner1 n'écoutera plus maintenant.") ;

// Déclenche l'événement de connexion

eventEmitter.emit('connection') ;

eventListeners =
require('events').EventEmitter.listenerCount(eventEmitte
r,'connection') ;
console.log(eventListeners + " Listner(s) listening to connection event") ;

console.log("Programme terminé.") ;
Exécutez maintenant le fichier main.js pour voir le résultat :

$ node main.js
Vérifier la sortie.

2 Listner(s) à l'écoute de l'événement

de connexion listner1 exécuté.
listner2 a exécuté.
Listner1 n'écoutera pas
maintenant. Listner2 s'est
exécuté.
1 Listner(s) à l'écoute de l'événement de
connexion Programme terminé.

31
 9. Tampons Node.js

Le JavaScript pur est compatible avec l'Unicode, mais ce n'est pas le cas pour les données
binaires. Lorsque l'on traite des flux TCP ou du système de fichiers, il est nécessaire de gérer
des flux d'octets. Node propose la classe Buffer qui fournit des instances pour stocker des
données brutes similaires à un tableau d'entiers, mais qui correspond à une allocation de
mémoire brute en dehors du tas V8.

La classe tampon est une classe globale à laquelle on peut accéder dans une application sans
importer le module tampon.

Création de tampons
La mémoire tampon des nœuds peut être construite de différentes manières.

Méthode 1
La syntaxe suivante permet de créer un tampon non initié de 10 octets :

var buf = new Buffer(10) ;

Méthode 2
La syntaxe suivante permet de créer un tampon à partir d'un tableau donné :

var buf = new Buffer([10, 20, 30, 40, 50]) ;

Méthode 3
La syntaxe suivante permet de créer un tampon à partir d'une chaîne de caractères donnée et d'un type
d'encodage facultatif :

var buf = new Buffer("Simply Easy Learning", "utf-8") ;

Bien que "utf8" soit l'encodage par défaut, vous pouvez utiliser l'un des encodages suivants :
"ascii", "utf8", "utf16le", "ucs2", "base64" ou "hex".

Écriture dans les tampons

Syntaxe
Voici la syntaxe de la méthode permettant d'écrire dans un tampon de nœud :

buf.write(string[, offset][, length][, encoding])

32
 Node.js

Paramètres
Voici la description des paramètres utilisés :

• string - Il s'agit de la chaîne de données à écrire dans la mémoire tampon.

• offset - C'est l'index du tampon à partir duquel l'écriture doit commencer. La valeur par défaut
est 0.
• length - Nombre d'octets à écrire. La valeur par défaut est buffer.length.
• encoding - Encodage à utiliser. 'utf8' est l'encodage par défaut.

Valeur de retour
Cette méthode renvoie le nombre d'octets écrits. S'il n'y a pas assez d'espace dans le
tampon pour contenir toute la chaîne, une partie de la chaîne sera écrite.

Exemple
buf = nouveau Buffer(256) ;
len = buf.write("Apprentissage simple et facile") ;

console.log("Octets écrits : "+ len) ;

Lorsque le programme ci-dessus est exécuté, il produit le résultat suivant :

Octets écrits : 20

Lecture des tampons

Syntaxe
Voici la syntaxe de la méthode permettant de lire les données d'un tampon de nœud :

buf.toString([encodage][, start][, end])

Paramètres
Voici la description des paramètres utilisés :

• encoding - Encodage à utiliser. 'utf8' est l'encodage par défaut.

• start - Indice de début de lecture, par défaut 0.
• end - Index de fin de lecture, la valeur par défaut est le tampon complet.

Valeur de retour
Cette méthode décode et renvoie une chaîne de caractères à partir des données de la
mémoire tampon encodées à l'aide de l'encodage du jeu de caractères spécifié.

33
 Node.js

Exemple
buf = nouveau Buffer(26) ;
for (var i = 0 ; i < 26 ; i++) {
buf[i] = i + 97 ;
}

console.log( buf.toString('ascii')) ;
// outputs : abcdefghijklmnopqrstuvwxyz
console.log( buf.toString('ascii',0,5)) ;
// sorties : abcde
console.log( buf.toString('utf8',0,5)) ;
// sorties : abcde
console.log( buf.toString(undefined,0,5)) ;
// l'encodage est par défaut "utf8", ce qui donne abcde
Lorsque le programme ci-dessus est exécuté, il produit le résultat suivant :

abcdefghijklmnopqrstuvwxyz
abcde
abcde
abcde

Convertir le tampon en JSON

Syntaxe
Voici la syntaxe de la méthode permettant de convertir un tampon de nœud en objet JSON :

buf.toJSON()

Valeur de retour
Cette méthode renvoie une représentation JSON de l'instance de tampon.

Exemple
var buf = new Buffer('Simply Easy Learning') ; var
json = buf.toJSON(buf) ;

console.log(json) ;
Lorsque le programme ci-dessus est exécuté, il produit le résultat suivant :

34
 Node.js

[ 83, 105, 109, 112, 108, 121, 32, 69, 97, 115, 121, 32, 76, 101, 97, 114, 110,
105, 110, 103 ]

Concaténer les tampons

Syntaxe
Voici la syntaxe de la méthode permettant de concaténer des tampons de nœuds en un seul tampon de
nœud :

Buffer.concat(list[, totalLength])

Paramètres
Voici la description des paramètres utilisés :

• list - Tableau Liste des objets tampons à concaténer.

• totalLength - Il s'agit de la longueur totale des tampons lorsqu'ils sont concaténés.

Valeur de retour
Cette méthode renvoie une instance de tampon.

Exemple
var buffer1 = new Buffer('TutorialsPoint ') ;
var buffer2 = new Buffer('Simply Easy Learning') ;
var buffer3 = Buffer.concat([buffer1,buffer2]) ;
console.log("buffer3 content : " + buffer3.toString()) ;
Lorsque le programme ci-dessus est exécuté, il produit le résultat suivant :

Contenu de buffer3 : TutorialsPoint Apprentissage simple et facile

Comparer les tampons

Syntaxe
Voici la syntaxe de la méthode permettant de comparer deux tampons de nœuds :

buf.compare(otherBuffer) ;

Paramètres
Voici la description des paramètres utilisés :

35
 Node.js

• otherBuffer - Il s'agit de l'autre tampon qui sera comparé à buf.

Valeur de retour
Renvoie un nombre indiquant s'il vient avant ou après ou s'il est identique à l'autre tampon
dans l'ordre de tri.

Exemple
var buffer1 = new Buffer('ABC') ;
var buffer2 = new Buffer('ABCD') ;
var result = buffer1.compare(buffer2) ;

if(result < 0) {
console.log(buffer1 +" comes before " + buffer2) ;
}else if(result == 0){
console.log(buffer1 +" is same as " + buffer2) ;
}else {
console.log(buffer1 +" vient après " + buffer2) ;
}
Lorsque le programme ci-dessus est exécuté, il produit le résultat suivant :

ABC précède ABCD

Tampon de copie

Syntaxe
Voici la syntaxe de la méthode de copie d'un tampon de nœud :

buf.copy(targetBuffer[, targetStart][, sourceStart][, sourceEnd])

Paramètres
Voici la description des paramètres utilisés :

• targetBuffer - Objet tampon dans lequel le tampon sera copié.

• targetStart - Nombre, Facultatif, Valeur par défaut : 0
• sourceStart - Nombre, Facultatif, Valeur par défaut : 0
• sourceEnd - Nombre, Facultatif, Par défaut : buffer.length

36
 Node.js

Valeur de retour
Pas de valeur de retour. Copie les données d'une région de ce tampon vers une région du
tampon cible, même si la région de mémoire cible chevauche la source. S'ils ne sont pas
définis, les paramètres targetStart et sourceStart prennent par défaut la valeur 0, tandis que
sourceEnd prend par défaut la valeur buffer.length.

Exemple
var buffer1 = new Buffer('ABC') ;
//copier un tampon
var buffer2 = new Buffer(3) ;
buffer1.copy(buffer2) ;
console.log("buffer2 content : " + buffer2.toString()) ;
Lorsque le programme ci-dessus est exécuté, il produit le résultat suivant :

Contenu de la mémoire tampon2 : ABC

Tampon de tranche

Syntaxe
Voici la syntaxe de la méthode permettant d'obtenir un sous-buffer d'un tampon de nœud :

buf.slice([start][, end])

Paramètres
Voici la description des paramètres utilisés :

• start - Nombre, Facultatif, Valeur par défaut : 0

• end - Nombre, Facultatif, Par défaut : buffer.length

Valeur de retour
Renvoie un nouveau tampon qui référence la même mémoire que l'ancien, mais décalé et
recadré par les indices de début (0 par défaut) et de fin (longueur du tampon par défaut).
Les indices négatifs commencent à la fin du tampon.

Exemple
var buffer1 = new Buffer('TutorialsPoint') ;
/découpage d'un tampon
var buffer2 = buffer1.slice(0,9) ; console.log("buffer2
content : " + buffer2.toString()) ;

37
 Node.js

Lorsque le programme ci-dessus est exécuté, il produit le résultat suivant :

Contenu de buffer2 : Tutoriels

Longueur du tampon

Syntaxe
Voici la syntaxe de la méthode permettant d'obtenir la taille d'un tampon de nœud en octets :

buf.length ;

Valeur de retour
Renvoie la taille d'un tampon en octets.

Exemple
var buffer = new Buffer('TutorialsPoint') ;
//longueur de la mémoire tampon
console.log("buffer length : " + buffer.length) ;
Lorsque le programme ci-dessus est exécuté, il produit le résultat suivant :

longueur du tampon : 14

Méthodes Référence
Voici une référence du module Buffers disponible dans Node.js. Pour plus de détails, vous
pouvez vous référer à la documentation officielle.

S. Méthode et
Non. description
nouveau tampon (taille)
1 Alloue une nouvelle mémoire tampon de taille octets. Notez que la taille ne doit
pas être supérieure à kMaxLength. Dans le cas contraire, une erreur de type
RangeError sera générée.
nouveau Buffer(buffer)
2
Copie les données du tampon transmis dans une nouvelle instance de tampon.

new Buffer(str[, encoding])

3
Alloue un nouveau tampon contenant la chaîne donnée. L'encodage est par
défaut 'utf8'.
buf.length
Renvoie la taille du tampon en octets. Notez qu'il ne s'agit pas
4 nécessairement de la taille du contenu. length fait référence à la quantité de
mémoire allouée à l'objet tampon. Elle ne change pas lorsque le contenu du
tampon est modifié.

38
 Node.js

buf.write(string[, offset][, length][, encoding])

Écrit une chaîne de caractères dans le tampon à la position offset en utilisant
5
l'encodage donné. offset vaut par défaut 0, encodage vaut par défaut 'utf8'.
length est le nombre d'octets à écrire.
Renvoie le nombre d'octets écrits.
buf.writeUIntLE(value, offset, byteLength[, noAssert])
Écrit une valeur dans le tampon au niveau du décalage et de la longueur d'octet
6
spécifiés. Prend en charge jusqu'à 48 bits de précision. Définissez noAssert à
true pour ignorer la validation de la valeur et du décalage. La valeur par défaut
est false.
buf.writeUIntBE(value, offset, byteLength[, noAssert])
Écrit une valeur dans le tampon au niveau du décalage et de la longueur d'octet
7
spécifiés. Prend en charge jusqu'à 48 bits de précision. Définissez noAssert à
true pour ignorer la validation de la valeur et du décalage. La valeur par défaut
est false.
buf.writeIntLE(value, offset, byteLength[, noAssert])
Écrit une valeur dans le tampon au niveau du décalage et de la longueur
8
d'octet spécifiés. Prend en charge jusqu'à 48 bits de précision. Définissez
noAssert à true pour ignorer la validation de la valeur et du décalage. La valeur
par défaut est false.
buf.writeIntBE(value, offset, byteLength[, noAssert])
Écrit une valeur dans le tampon au niveau du décalage et de la longueur
9
d'octet spécifiés. Prend en charge jusqu'à 48 bits de précision. Définissez
noAssert à true pour ignorer la validation de la valeur et du décalage. La valeur
par défaut est false.
buf.readUIntLE(offset, byteLength[, noAssert])
Version généralisée de toutes les méthodes de lecture numérique. Prend en
10
charge jusqu'à 48 bits de précision. Définissez noAssert à true pour ignorer la
validation de l'offset. Cela signifie que le décalage peut être au-delà de la fin du
tampon. La valeur par défaut est false.
buf.readUIntBE(offset, byteLength[, noAssert])
Version généralisée de toutes les méthodes de lecture numérique. Prend en
11
charge jusqu'à 48 bits de précision. Définissez noAssert à true pour ignorer la
validation de l'offset. Cela signifie que le décalage peut être au-delà de la fin du
tampon. La valeur par défaut est false.
buf.readIntLE(offset, byteLength[, noAssert])
Version généralisée de toutes les méthodes de lecture numérique. Prend en
12
charge jusqu'à 48 bits de précision. Définissez noAssert à true pour ignorer la
validation de l'offset. Cela signifie que le décalage peut être au-delà de la fin du
tampon. La valeur par défaut est false.
buf.readIntBE(offset, byteLength[, noAssert])
Version généralisée de toutes les méthodes de lecture numérique. Prend en
13
charge jusqu'à 48 bits de précision. Définissez noAssert à true pour ignorer la
validation de l'offset. Cela signifie que le décalage peut être au-delà de la fin du
tampon. La valeur par défaut est false.
buf.toString([encodage][, start][, end])
14 Décode et renvoie une chaîne de caractères à partir des données de la mémoire
tampon encodées à l'aide de l'encodage du jeu de caractères spécifié.

39
 Node.js
buf.toJSON()
15 Renvoie une représentation JSON de l'instance de tampon. JSON.stringify
appelle implicitement cette fonction lors de la stringification d'une instance
de Buffer.

40
 Node.js

buf[index]
16 Obtenir et définir l'octet à l'index. Les valeurs se rapportent à des octets
individuels, de sorte que la plage légale est comprise entre 0x00 et 0xFF hex ou
0 et 255.
buf.equals(otherBuffer)
17
Renvoie un booléen si ce tampon et l'autre tampon ont les mêmes octets.

buf.compare(otherBuffer)
18 Renvoie un nombre indiquant si ce tampon vient avant ou après ou est
identique à l'autre tampon dans l'ordre de tri.

buf.copy(targetBuffer[, targetStart][, sourceStart][, sourceEnd]) Copie les

données d'une région de ce tampon vers une région du tampon cible, même si
19 la région de mémoire cible chevauche la source. S'ils ne sont pas définis, les
paramètres targetStart et sourceStart prennent par défaut la valeur 0, tandis
que sourceEnd prend par défaut la valeur buffer.length.

buf.slice([start][, end])
Renvoie un nouveau tampon qui référence la même mémoire que l'ancien,
20
mais décalé et recadré par les index de début (par défaut 0) et de fin (par
défaut longueur du tampon). Les indices négatifs commencent à la fin du
tampon.
buf.readUInt8(offset[, noAssert])
Lit un entier 8 bits non signé dans le tampon au niveau du décalage spécifié.
21
Définissez noAssert à true pour ignorer la validation du décalage. Cela
signifie que le décalage peut être au-delà de la fin du tampon. La valeur par
défaut est false.
buf.readUInt16LE(offset[, noAssert])
Lit un entier 16 bits non signé dans le tampon à l'emplacement spécifié avec le
22
format endian spécifié. Attribuez la valeur true à noAssert pour ignorer la
validation du décalage. Cela signifie que le décalage peut être au-delà de la fin
du tampon. La valeur par défaut est false.
buf.readUInt16BE(offset[, noAssert])
Lit un entier 16 bits non signé dans le tampon à l'emplacement spécifié avec le
23
format endian spécifié. Définissez noAssert à true pour ignorer la validation du
décalage. Cela signifie que le décalage peut être au-delà de la fin du tampon.
La valeur par défaut est false.
buf.readUInt32LE(offset[, noAssert])
Lit un entier 32 bits non signé dans le tampon à l'emplacement spécifié avec le
24
format endian spécifié. Attribuez la valeur true à noAssert pour ignorer la
validation du décalage. Cela signifie que le décalage peut être au-delà de la fin
du tampon. La valeur par défaut est false.
buf.readUInt32BE(offset[, noAssert])
Lit un entier 32 bits non signé dans le tampon à l'emplacement spécifié avec le
25
format endian spécifié. Attribuez la valeur true à noAssert pour ignorer la
validation du décalage. Cela signifie que le décalage peut être au-delà de la fin
du tampon. La valeur par défaut est false.
buf.readInt8(offset[, noAssert])
Lit un entier signé de 8 bits dans le tampon à l'emplacement spécifié.
26
Définissez noAssert à true pour ignorer la validation du décalage. Cela
signifie que le décalage peut être au-delà de la fin du tampon. La valeur
par défaut est false.
41
 Node.js

27 buf.readInt16LE(offset[, noAssert])
Lit un entier signé de 16 bits dans le tampon à l'emplacement spécifié avec la
fonction

42
 Node.js

format endian spécifié. Attribuez la valeur true à noAssert pour ignorer la

validation de l'offset. Cela signifie que le décalage peut être au-delà de la fin du
tampon. La valeur par défaut est false.
buf.readInt16BE(offset[, noAssert])
Lit un entier signé de 16 bits dans le tampon à l'emplacement spécifié avec le
28
format endian spécifié. Définissez noAssert à true pour ignorer la validation du
décalage. Cela signifie que le décalage peut être au-delà de la fin du tampon. La
valeur par défaut est false.
buf.readInt32LE(offset[, noAssert])
Lit un entier 32 bits signé dans le tampon à l'emplacement spécifié avec le
29
format endian spécifié. Définissez noAssert à true pour ignorer la validation du
décalage. Cela signifie que le décalage peut être au-delà de la fin du tampon. La
valeur par défaut est false.
buf.readInt32BE(offset[, noAssert])
Lit un entier 32 bits signé dans le tampon à l'emplacement spécifié avec le
30
format endian spécifié. Définissez noAssert à true pour ignorer la validation du
décalage. Cela signifie que le décalage peut être au-delà de la fin du tampon. La
valeur par défaut est false.
buf.readFloatLE(offset[, noAssert])
Lit un flottant 32 bits dans le tampon à l'emplacement spécifié avec le format
31
endian spécifié. Définissez noAssert à true pour ignorer la validation de
l'offset. Cela signifie que le décalage peut être au-delà de la fin du tampon. La
valeur par défaut est false.
buf.readFloatBE(offset[, noAssert])
Lit un flottant 32 bits dans le tampon à l'emplacement spécifié avec le format
32
endian spécifié. Définissez noAssert à true pour ignorer la validation de
l'offset. Cela signifie que le décalage peut être au-delà de la fin du tampon. La
valeur par défaut est false.
buf.readDoubleLE(offset[, noAssert])
Lit un double 64 bits dans le tampon à l'emplacement spécifié avec le format
33
endian spécifié. Définissez noAssert à true pour ignorer la validation du
décalage. Cela signifie que le décalage peut être au-delà de la fin du tampon.
La valeur par défaut est false.
buf.readDoubleBE(offset[, noAssert])
Lit un double 64 bits dans le tampon à l'emplacement spécifié avec le format
34
endian spécifié. Définissez noAssert à true pour ignorer la validation du
décalage. Cela signifie que le décalage peut être au-delà de la fin du tampon.
La valeur par défaut est false.
buf.writeUInt8(value, offset[, noAssert])
Écrit une valeur dans la mémoire tampon à l'emplacement spécifié. La valeur
doit être un entier 8 bits non signé valide. Définissez noAssert à true pour
35 ignorer la validation de la valeur et du décalage. Cela signifie que la valeur
peut être trop grande pour la fonction spécifique et que le décalage peut être
au-delà de la fin du tampon, ce qui entraîne l'abandon silencieux des valeurs.
Il ne faut pas l'utiliser à moins d'être certain de son exactitude. La valeur par
défaut est false.

43
 Node.js
buf.writeUInt16LE(value, offset[, noAssert])
Écrit une valeur dans la mémoire tampon au décalage spécifié et au format
endian spécifié. La valeur doit être un entier 16 bits non signé valide.
36 Définissez noAssert à true pour ignorer la validation de la valeur et du
décalage. Cela signifie que la valeur peut être trop grande pour la fonction
spécifique et que le décalage peut être au-delà de la fin du tampon, ce qui
entraîne l'abandon silencieux des valeurs. Il ne faut pas l'utiliser à moins
d'être certain de l'exactitude des données. La valeur par défaut est false.

37 buf.writeUInt16BE(value, offset[, noAssert])

Écrit une valeur dans le tampon à l'emplacement spécifié avec l'endian spécifié.

44
 Node.js

format. La valeur doit être un entier non signé valide de 16 bits. Définissez
noAssert à true pour ignorer la validation de la valeur et du décalage. Cela
signifie que la valeur peut être trop grande pour la fonction spécifique et
que le décalage peut être au-delà de la fin du tampon, ce qui entraîne
l'abandon silencieux des valeurs. Il ne faut pas l'utiliser à moins d'être
certain de son exactitude. La valeur par défaut est false.
buf.writeUInt32LE(value, offset[, noAssert])
Écrit une valeur dans le tampon à l'emplacement spécifié avec le format
endian spécifié. La valeur doit être un entier 32 bits non signé valide.
38 Définissez noAssert à true pour ignorer la validation de la valeur et du
décalage. Cela signifie que la valeur peut être trop grande pour la fonction
spécifique et que le décalage peut être au-delà de la fin du tampon, ce qui
entraîne l'abandon silencieux des valeurs. Il ne faut pas l'utiliser à moins
d'être certain de son exactitude. La valeur par défaut est false.
buf.writeUInt32BE(value, offset[, noAssert])
Écrit une valeur dans le tampon à l'emplacement spécifié avec le format
endian spécifié. La valeur doit être un entier 32 bits non signé valide.
39 Définissez noAssert à true pour ignorer la validation de la valeur et du
décalage. Cela signifie que la valeur peut être trop grande pour la fonction
spécifique et que le décalage peut être au-delà de la fin du tampon, ce qui
entraîne l'abandon silencieux des valeurs. Il ne faut pas l'utiliser à moins
d'être certain de son exactitude. La valeur par défaut est false.
buf.writeInt8(value, offset[, noAssert])
Écrit une valeur dans la mémoire tampon au décalage spécifié et au format
endian spécifié. La valeur doit être un entier 8 bits signé valide. Définissez
40 noAssert à true pour ignorer la validation de la valeur et du décalage. Cela
signifie que la valeur peut être trop grande pour la fonction spécifique et que
le décalage peut être au-delà de la fin du tampon, ce qui entraîne l'abandon
silencieux des valeurs. Il ne faut pas l'utiliser à moins d'être certain de son
exactitude. La valeur par défaut est false.
buf.writeInt16LE(value, offset[, noAssert])
Écrit une valeur dans le tampon à l'emplacement spécifié avec le format
endian spécifié. La valeur doit être un entier 16 bits signé valide. Définissez
41 noAssert à true pour ignorer la validation de la valeur et du décalage. Cela
signifie que la valeur peut être trop grande pour la fonction spécifique et
que le décalage peut être au-delà de la fin du tampon, ce qui entraîne
l'abandon silencieux des valeurs. Il ne faut pas l'utiliser à moins d'être
certain de son exactitude. La valeur par défaut est false.
buf.writeInt16BE(value, offset[, noAssert])
Écrit une valeur dans le tampon à l'emplacement spécifié avec le format
endian spécifié. La valeur doit être un entier 16 bits signé valide. Définissez
42 noAssert à true pour ignorer la validation de la valeur et du décalage. Cela
signifie que la valeur peut être trop grande pour la fonction spécifique et
que le décalage peut être au-delà de la fin du tampon, ce qui entraîne
l'abandon silencieux des valeurs. Il ne faut pas l'utiliser à moins d'être
certain de son exactitude. La valeur par défaut est false.
buf.writeInt32LE(value, offset[, noAssert])
Écrit une valeur dans le tampon à l'emplacement spécifié avec le format
endian spécifié. La valeur doit être un entier 32 bits signé valide. Définissez
43 noAssert à true pour ignorer la validation de la valeur et du décalage. Cela
signifie que la valeur peut être trop grande pour la fonction spécifique et
que le décalage peut être au-delà de la fin du tampon, ce qui entraîne
l'abandon silencieux des valeurs. Il ne faut pas l'utiliser à moins d'être
45
 Node.js
certain de son exactitude. La valeur par défaut est false.

44 buf.writeInt32BE(value, offset[, noAssert])

Écrit une valeur dans le tampon à l'emplacement spécifié avec l'endian spécifié.

46