Apprenez NodeJS en 1 Jour-Complete Node JS Guide Avec Des Exemples

Apprendre NodeJS en 1 jour
Par Krishna Rungta
Copyright 2018 - Tous droits réservés - Krishna Rungta
TOUS DROITS RÉSERVÉS. Aucune partie de cette publication ne

peut être reproduite ou transmise sous quelque forme que ce soit,
électronique ou mécanique, y compris la photocopie, l'enregistrement
ou tout autre système de stockage ou de récupération d'informations
sans l'autorisation expresse écrite, datée et signée de l'auteur.
Table des matières
Chapitre 1 Introduction
1. Qu'est-ce que node.js
2. Pourquoi utiliser Node.js
3. Caractéristiques de Node.js
4. Quand utiliser et ne pas utiliser Node.js
Chapitre 2: Télécharger et installer Node.js

1. Comment installer node.js
2. Installation du node via un gestionnaire de paquets
3. Exécution de votre première application Hello world dans
Node.js
Chapitre 3: Modules
1. Quels sont les modules dans Node.js
2. Utiliser des modules dans Node.js
3. Création de modules NPM
4. Modules d'extension
5. Publication de modules NPM
6. Gestion des packages tiers avec npm
7. Qu'est-ce que le fichier package.json
Chapitre 4: Créer un serveur et obtenir des données
Chapitre 5: Node.js avec Express

1. Qu'est-ce que Express.js
2. Installation et utilisation d'Express
3. Quelles sont les routes
4. Exemple de serveur Web utilisant express.js
Chapitre 6: Node.js avec MongoDB

1. Bases de données Node.js et NoSQL
2. Utiliser MongoDB et Node.js
3. Comment créer une application de noeud express avec MongoDB
pour stocker et diffuser du contenu
Chapitre 7: Promesse, Générateur, Événement et

Filestream
1. Que sont les promesses
2. Rappels aux promesses
3. Générer des promesses avec la bibliothèque BlueBird
4. Créer une promesse personnalisée
5. Rappels vs générateurs
6. Filestream dans Node.js
7. Événements émettant
Chapitre 8: Test avec Jasmin

1. Vue d'ensemble de Jasmine pour tester les applications Node.js
2. Comment utiliser Jasmine pour tester les applications Node.js
Chapitre 1 Introduction
L'application web moderne a vraiment parcouru un long chemin au fil

des années avec l'introduction de nombreux frameworks populaires
tels que bootstrap, Angular JS, etc. Tous ces frameworks sont basés
sur le framework JavaScript populaire.
Mais lorsqu'il s'agissait de développer des applications basées sur

serveur, il y avait une sorte de vide, et c'est là que Node.js est entré
dans l'image.
Node.js est également basé sur le framework JavaScript, mais il est

utilisé pour le développement d'applications basées sur serveur. Tout
en parcourant l'ensemble du tutoriel, nous examinerons Node.js en
détail et comment nous pouvons l'utiliser pour développer des
applications basées sur serveur.
Qu'est-ce que node.js ?
Node.js est un environnement d'exécution open-source et
multiplateforme utilisé pour le développement d'applications web côté
serveur. Les applications Node.js sont écrites en JavaScript et peuvent
être exécutées sur une grande variété de systèmes d'exploitation.
Node.js est basé sur une architecture événementielle et une API

d'entrée/sortie non bloquante conçue pour optimiser le débit et
l'évolutivité d'une application pour les applications Web en temps réel.
Sur une longue période de temps, le cadre disponible pour le

développement web était basé sur un modèle sans état. Un modèle
sans état est un modèle dans lequel les données générées dans une
session (telles que les informations sur les paramètres utilisateur et les
événements qui se sont produits) ne sont pas gérées pour être utilisées
dans la session suivante avec cet utilisateur.
Beaucoup de travail a dû être fait pour maintenir l'information de

session entre les demandes d'un utilisateur. Mais avec Node.js, il
existe enfin un moyen pour les applications web d'avoir une connexion
bidirectionnelle en temps réel, où le client et le serveur peuvent initier
la communication, ce qui leur permet d'échanger des données
librement.
Pourquoi utiliser Node.js
Nous examinerons la valeur réelle de Node.js dans les chapitres à
venir, mais qu'est-ce qui rend ce cadre si célèbre. Au fil des ans, la
plupart des demandes étaient fondées sur un cadre de réponse aux
demandes sans état. Dans ce type d'applications, c'est au développeur
de s'assurer que le bon code a été mis en place pour s'assurer que l'état
de la session Web a été maintenu pendant que l'utilisateur travaillait
avec le système.
Mais avec les applications web de Node.js, vous pouvez maintenant

travailler en temps réel et avoir une communication bidirectionnelle.
L'état est maintenu et le client ou le serveur peut démarrer la
communication.
Caractéristiques de Node.js
Examinons quelques-unes des principales caractéristiques de Node.js.
1. L'E/S asynchrone pilotée par événement aide au traitement

simultané des requêtes - C'est probablement le plus gros
argument de vente de Node.js. Cette caractéristique signifie
essentiellement que si une demande est reçue par Node pour une
opération d'entrée/sortie, il exécutera l'opération en arrière-plan
et continuera à traiter d'autres demandes.
C'est très différent des autres langages de programmation. Un exemple

simple de cela est donné dans le code ci-dessous
var fs = require('fs');
fs.readFile("Sample.txt",function(error,data)
{
console.log("Reading Data completed");
});
L'extrait de code ci-dessus se penche sur la lecture d'un fichier

appelé Sample.txt. Dans d'autres langages de programmation, la
ligne de traitement suivante n'aurait lieu qu'une fois que le fichier
entier est lu.
Mais dans le cas de Node.js la fraction importante du code à
remarquer est la déclaration de la fonction ('function(error,data)').
C'est ce qu'on appelle une fonction de rappel.
Ainsi, ce qui se passe ici, c'est que l'opération de lecture du fichier
commencera en arrière-plan. Et d'autres traitements peuvent avoir
lieu simultanément pendant la lecture du fichier. Une fois
l'opération de lecture du fichier terminée, cette fonction anonyme
sera appelée et le texte "Reading Data completed" sera écrit dans le
journal de la console.
2. Node utilise le moteur d'exécution JavaScript V8, celui qui est

utilisé par Google Chrome. Node a un wrapper sur le moteur
JavaScript qui rend le moteur d'exécution beaucoup plus rapide
et donc le traitement des requêtes dans Node devient aussi plus
rapide.
3. Traitement des requêtes simultanées - Une autre fonctionnalité
clé de Node est la possibilité de traiter des connexions
simultanées avec un minimum de frais généraux sur un seul
processus.
4. La bibliothèque Node.js a utilisé JavaScript - C'est un autre aspect
important du développement de Node.js. Une grande partie de la
communauté de développement sont déjà bien versés dans
javascript, et donc, le développement dans Node.js devient plus
facile pour un développeur qui connaît javascript.
5. Il existe une communauté active et dynamique pour le cadre
Node.js. En raison de la communauté active, il y a toujours des
mises à jour de clés mises à disposition du cadre. Cela permet de
garder le cadre toujours à jour avec les dernières tendances dans
le développement web.
Qui utilise Node.js ?

Node.js est utilisé par une variété de grandes entreprises. Vous
trouverez ci-dessous une liste de quelques-uns d'entre eux.
Paypal - Beaucoup de sites au sein de Paypal ont également
commencé la transition sur Node.js.
LinkedIn - LinkedIn utilise Node.js pour alimenter ses serveurs
mobiles, qui alimentent les produits iPhone, Android et Mobile
Web.
Mozilla a implémenté Node.js pour supporter les API de navigateur
qui a un demi-milliard d'installations.
Ebay héberge son service HTTP API dans Node.js.
Quand utiliser et ne pas utiliser
Node.js
Node.js est le meilleur pour une utilisation en streaming ou dans des
applications en temps réel basées sur des événements comme
1. Applications de clavardage
2. Serveurs de jeu - Serveurs rapides et performants qui ont besoin
de traiter des milliers de requêtes à la fois, alors c'est un cadre
idéal.
3. Bon pour l'environnement collaboratif - C'est bon pour les
environnements qui gèrent les documents. Dans l'environnement
de gestion de documents, vous aurez plusieurs personnes qui
affichent leurs documents et font des changements constants en
vérifiant et en vérifiant les documents. Donc Node.js est bon pour
ces environnements parce que la boucle d'événements dans
Node.js peut être déclenchée chaque fois que des documents sont
modifiés dans un environnement de gestion de documents.
4. Serveurs de publicité - Ici encore, vous pourriez avoir des milliers
de demandes pour retirer des publicités du serveur central et
Node.js peut être un cadre idéal pour gérer cela.
5. Serveurs de streaming - Un autre scénario idéal à utiliser Node
est pour les serveurs de streaming multimédia où les clients ont
des requêtes pour extraire différents contenus multimédia de ce
serveur.
Node.js est bon quand vous avez besoin de niveaux élevés de
concomitance mais moins de temps CPU dédié.
Le meilleur de tous, puisque Node.js est construit sur javascript, c'est

le mieux adapté lorsque vous construisez des applications côté client
qui sont basées sur le même framework javascript.
Quand ne pas utiliser Node.js
Node.js peut être utilisé pour un grand nombre d'applications à des

fins diverses, le seul scénario où il ne devrait pas être utilisé est s'il y a
de longs délais de traitement qui est requis par l'application.
Le nœud est structuré pour être à filetage simple. Si une application

est nécessaire pour effectuer de longs calculs en arrière-plan. Donc, si
le serveur fait des calculs, il ne pourra pas traiter d'autres requêtes.
Comme indiqué ci-dessus, Node.js est la meilleure solution lorsque le
traitement nécessite moins de temps CPU dédié.
Chapitre 2 : Télécharger et
installer Node.js
Pour commencer à construire vos applications Node.js, la première

étape est l'installation du framework node.js. Le framework Node.js
est disponible pour une variété de systèmes d'exploitation, de
Windows à Ubuntu et OS X. Une fois que le framework Node.js est
installé, vous pouvez commencer à construire vos premières
applications Node.js.
Node.js a également la possibilité d'intégrer des fonctionnalités

externes ou des fonctionnalités étendues en utilisant des modules
personnalisés. Ces modules doivent être installés séparément. Un
exemple de module est le module MongoDB qui vous permet de
travailler avec les bases de données MongoDB à partir de votre
application Node.js.
Comment installer node.js
La première étape de l'utilisation de Node.js est l'installation des
bibliothèques Node.js sur le système client. Pour effectuer
l'installation de Node.js, suivez les étapes ci-dessous ;
Etape 1) Allez sur le site https://nodejs.org/en/download/ et

téléchargez les fichiers binaires nécessaires. Dans notre exemple, nous
allons télécharger les fichiers d'installation 32 bits pour Node.js.
Étape 2) Double-cliquez sur le fichier.msi téléchargé pour démarrer

l'installation. Cliquez sur le bouton Exécuter dans le premier écran
pour commencer l'installation.
Étape 3) Dans l'écran suivant, cliquez sur le bouton "Suivant" pour
continuer l'installation.
Etape 4) Dans l'écran suivant Accepter le contrat de licence et cliquer

sur le bouton Suivant.
Étape 5) Dans l'écran suivant, choisissez l'emplacement où Node.js
doit être installé, puis cliquez sur le bouton Suivant.
1. Entrez d'abord l'emplacement du fichier pour l'installation de

Node.js. C'est là que les fichiers de Node.js seront stockés après
l'installation.
2. Cliquez sur le bouton Suivant pour poursuivre l'installation.
Etape 6) Acceptez les composants par défaut et cliquez sur le bouton
suivant.
Étape 7) Dans l'écran suivant, cliquez sur le bouton Installer pour

démarrer l'installation.
Étape 8) Cliquez sur le bouton Terminer pour terminer l'installation.
Installation d'un node par
l'intermédiaire d'un gestionnaire de
paquets
L'autre façon d'installer Node.js sur n'importe quelle machine cliente
est d'utiliser un "gestionnaire de paquets".
Sur Windows, le gestionnaire de paquets de nœuds est connu sous le

nom de Chocolatey. Il a été conçu pour être un cadre décentralisé pour
installer rapidement les applications et les outils dont vous avez
besoin.
Pour installer Node.js via Chocolatey, les étapes suivantes doivent être
effectuées.
Étape 1) Installation de Chocolatey - Le site Web de Chocolatey

(https://chocolatey.org/) contient des instructions très claires sur la
façon dont ce cadre doit être installé.
La première étape consiste à exécuter la commande ci-dessous

dans les fenêtres de l'invite de commande. Cette commande est
extraite du site web de Chocolatey et est la commande standard
pour l'installation de Node.js via Chocolatey.
La commande ci-dessous est une commande PowerShell qui
appelle le script PowerShell distant sur le site Chocolatey. Cette
commande doit être exécutée dans une fenêtre de commande
PowerShell.
Ce script PowerShell fait tout le travail nécessaire pour télécharger
les composants nécessaires et les installer en conséquence.
@powershell -NoProfile -ExecutionPolicy Bypass -Command "iex

((new-object
wet.webclient).DownloadString('https://chocolatey.org/install.ps1'))"
&& SET PATH=%PATH%;%ALLUSERSPROFILE%\chocolatey\bin
Etape 2) L'étape suivante est d'installer Node.js sur votre machine

locale en utilisant le gestionnaire de paquets Chocolatey. Ceci peut être
fait en exécutant la commande ci-dessous dans l'invite de commande.
cinst nodejs install

Si l'installation est réussie, vous obtiendrez le message de l'installation
réussie de Node.js.
Note : Si vous obtenez une erreur comme

"C:\ProgramData\chocolatey\lib\libreoffice\tools\chocolateyInstall.p
s1" Puis effacez manuellement le dossier dans le chemin d'accès.
Exécuter votre première application
Hello world dans Node.js
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éer le fichier Node.js avec le nom de fichier firstprogram.js

var http = require('http');
http.createServer(function (req, res) {

res.writeHead(200, {'Content-Type': 'text/html'});
res.end('Hello World!');
}).listen(8080);
Code Explication :
1. La fonctionnalité de base de la fonction "require" est qu'elle lit un

fichier JavaScript, exécute le fichier, puis retourne un objet. A l'aide de
cet objet, on peut ensuite utiliser les différentes fonctionnalités
disponibles dans le module appelé par la fonction requise. Donc dans
notre cas, puisque nous voulons utiliser la fonctionnalité de http et
nous utilisons la commande require(http).
2. Dans cette 2ème ligne de code, nous créons une application serveur
qui est basée sur une fonction simple. Cette fonction est appelée
chaque fois qu'une requête est faite à notre application serveur.
3. Lorsqu'une demande est reçue, nous demandons à notre fonction de

renvoyer une réponse "Hello World" au client. La fonction writeHead
est utilisée pour envoyer des données d'en-tête au client et tandis que
la fonction finale fermera la connexion au client.
4. Nous utilisons alors la fonction .listen pour faire en sorte que notre
application serveur écoute les requêtes des clients sur le port 8080.
Vous pouvez spécifier n'importe quel port disponible ici.
Exécuter le code
Etape 1) Sauvegardez le fichier sur votre ordinateur : C:\Users\Your
Name\Your Name\premierprogramme.js
Étape 2) Dans l'invite de commande, naviguez jusqu'au dossier dans

lequel le fichier est stocké. Entrez la commande
Node firstprogram.js
Étape 3) Maintenant, votre ordinateur fonctionne comme un serveur

! Si quelqu'un essaie d'accéder à votre ordinateur sur le port 8080, il
obtiendra un "Hello World ! message en retour!
Etape 4) Démarrez votre navigateur Internet, et tapez l'adresse :

http://localhost:8080
OutPut
Résumé
Nous avons vu l'installation de Node.js via le module d'installation

msi qui est disponible sur le site web de Node.js. Cette installation
installe les modules nécessaires à l'exécution d'une application
Node.js sur le client.
Node.js peut également être installé via un gestionnaire de paquets.
Le gestionnaire de paquets pour Windows est connu sous le nom
de Chocolatey. En exécutant des commandes simples dans l'invite
de commandes, le gestionnaire de paquets Chocolatey télécharge
automatiquement les fichiers nécessaires et les installe sur la
machine cliente.
Une simple application Node.js consiste à créer un serveur qui
écoute sur un port particulier. Lorsqu'une requête arrive sur le
serveur, le client envoie automatiquement une réponse'Hello
World' au client.
Chapitre 3 : Modules
Un module dans Node.js est une encapsulation logique de code dans

une seule unité. C'est toujours une bonne pratique de programmation
de toujours séparer le code de telle sorte qu'il soit plus facile à gérer et
à maintenir à des fins futures. C'est là que les modules de Node.js
entrent en action.
Comme chaque module est une entité indépendante avec sa propre

fonctionnalité encapsulée, il peut être géré comme une unité de travail
séparée.
Au cours de ce tutoriel, nous verrons comment nous pouvons utiliser

les modules dans Node.js.
Que sont les modules dans Node.js ?
Comme indiqué précédemment, les modules dans Node js sont une
façon d'encapsuler le code dans une unité logique séparée. Il existe de
nombreux modules prêts à l'emploi sur le marché qui peuvent être
utilisés dans Node js.
Voici quelques-uns des modules populaires qui sont utilisés dans une
application Node js.
1. Express framework - Express est un cadre d'application web

Node js minimal et flexible qui fournit un ensemble robuste de
fonctionnalités pour le web et les applications mobiles.
2. Socket.io - Socket.IO permet une communication
événementielle bidirectionnelle en temps réel. Ce module est bon
pour la création d'applications basées sur le chat.
3. Jade - Jade est un moteur de template haute performance et
implémenté avec JavaScript pour les nœuds et les navigateurs.
4. MongoDB - Le pilote MongoDB Node.js est le pilote node.js
officiellement supporté pour MongoDB.
5. Restify - restify est un framework léger, similaire à express pour
la construction d'API REST.
6. Bluebird - Bluebird est une bibliothèque de promesses complète
avec un accent sur les fonctionnalités innovantes et les
performances.
Utilisation des modules dans
Node.js
Afin d'utiliser les modules dans une application Node.js, ils doivent
d'abord être installés à l'aide du gestionnaire de paquets Node.
La ligne de commande ci-dessous montre comment un module

"express" peut être installé.
npm install express
La commande ci-dessus téléchargera les fichiers nécessaires qui

contiennent les "modules express" et s'occupera également de
l'installation.
Une fois le module installé, pour utiliser un module dans une
application Node.js, vous devez utiliser le mot-clé'require'. Ce
mot-clé est un moyen que Node.js utilise pour incorporer la
fonctionnalité d'un module dans une application.
Voyons un exemple d'utilisation du mot-clé "require". L'exemple de
code "Guru99" ci-dessous montre comment utiliser la fonction
requise.
var express=require('express');
var app=express();
app.set('view emngine','jade');
app.get('/',function(req,res)
{
});
var server=app.listen(3000,function()
{
});
1. Dans la première déclaration elle-même, nous utilisons le mot-clé

"require" pour inclure le module express. Le module "express" est
une bibliothèque JavaScript optimisée pour le développement de
Node.js. C'est l'un des modules Node.js les plus couramment
utilisés.
2. Une fois le module inclus, afin d'utiliser les fonctionnalités du
module, un objet doit être créé. Ici, un objet du module express
est créé.
3. Une fois que le module est inclus en utilisant la commande
"require" et qu'un "objet" est créé, les méthodes requises du
module express peuvent être invoquées. Ici, nous utilisons la
commande set pour définir le moteur de vue, qui est utilisé pour
définir le moteur de template utilisé dans Node.js. Note:-(Juste
pour la compréhension du lecteur, un moteur de template est une
approche pour injecter des valeurs dans une application en
ramassant des données à partir de fichiers de données. Ce
concept est assez célèbre dans Angular JS où les accolades
bouclées {{{clé}} sont utilisées pour substituer des valeurs dans la
page web. Le mot'clé' dans les accolades bouclées désigne
essentiellement la variable qui sera remplacée par une valeur lors
de l'affichage de la page.
4. Ici, nous utilisons la méthode d'écoute pour faire écouter
l'application sur un numéro de port particulier.
Création de modules NPM
Node.js a la possibilité de créer des modules personnalisés et vous
permet d'inclure ces modules personnalisés dans votre application
Node.js.
Examinons un exemple simple de la façon dont nous pouvons créer

notre propre module et inclure ce module dans notre fichier
d'application principal. Notre module ne fera qu'une simple tâche
d'ajouter 2 numéros.
Suivez les étapes ci-dessous pour voir comment nous pouvons créer
des modules et les inclure dans notre application.
Étape 1) Créer un fichier appelé "Addition.js" et inclure le code ci-

dessous. Ce fichier contiendra la logique de votre module.
Ci-dessous se trouve le code qui irait dans ce fichier ;

var exports=module.exports={};
exports.AddNumber=function(a,b)
{
return a+b;
};
1. Le mot-clé "exports" est utilisé pour s'assurer que la

fonctionnalité définie dans ce fichier est effectivement accessible
par d'autres fichiers.
2. Nous sommes en train de définir une fonction
appelée'AddNumber'. Cette fonction est définie pour prendre 2
paramètres, a et b. La fonction est ajoutée au module "exports"
pour faire de la fonction une fonction publique accessible par
d'autres modules d'application.
3. Nous faisons enfin de notre fonction return la valeur ajoutée des
paramètres.
Maintenant que nous avons créé notre module personnalisé qui a la

fonctionnalité d'ajouter 2 numéros. Il est maintenant temps de
créer une application, qui appellera ce module.
Dans la prochaine étape, nous verrons comment créer l'application

qui appellera notre module personnalisé.
Etape 2) Créez un fichier appelé "app.js", qui est votre fichier

d'application principal et ajoutez le code suivant
var Addition=require('./Addition.js');
console.log(Addition.AddNumber(1,2));
1. Nous utilisons le mot-clé "require" pour inclure la fonctionnalité

dans le fichier Addition.js.
2. Puisque les fonctions du fichier Addition.js sont maintenant
accessibles, nous pouvons maintenant faire un appel à la fonction
AddNumber. Dans la fonction, nous passons 2 nombres comme
paramètres. Nous affichons alors la valeur dans la console.
Sortie :
Lorsque vous exécutez le fichier app.js, vous obtiendrez une
sortie de valeur 3 dans le journal de la console.
Le résultat est que la fonction AddNumber dans le fichier
Addition.js a été appelée avec succès et que la valeur retournée
de 3 a été affichée dans la console.
Note : - Nous n'utilisons pas encore le "Node package manager" pour

installer notre module Addition.js. En effet, le module fait déjà partie
de notre projet sur la machine locale. Le gestionnaire de paquets Node
vient dans l'image lorsque vous publiez un module sur Internet que
nous voyons dans la rubrique suivante.
Modules d'extension
Lors de la création de modules, il est également possible d'étendre ou
d'hériter d'un module d'un autre module.
Dans la programmation moderne, il est assez courant de construire

une bibliothèque de modules communs et d'étendre les fonctionnalités
de ces modules communs si nécessaire.
Regardons un exemple de la façon dont nous pouvons étendre les

modules dans Node.js.
Etape 1) Créer le module de base.
Dans notre exemple, créez un fichier appelé "Tutorial.js" et placez le

code ci-dessous.
Dans ce code, nous sommes en train de créer une fonction qui renvoie
une chaîne de caractères à la console. La chaîne retournée est "Guru99
Tutorial".
exports.tutorial=function()
{
console.log("Guru99 Tutotial")
}
1. Le module d'exportation est utilisé de sorte que n'importe quelle

fonction définie dans ce fichier peut être disponible dans d'autres
modules de Node.js.
2. Nous sommes en train de créer une fonction appelée tutoriel qui
peut être utilisée dans d'autres modules Node.js.
3. Nous affichons une chaîne de caractères "Guru99 Tutorial" dans
la console lorsque cette fonction est appelée.
Maintenant que nous avons créé notre module de base appelé

Tutorial.js. Il est maintenant temps de créer un autre module qui
va étendre ce module de base.
Nous examinerons la façon d'y parvenir à l'étape suivante.
Etape 2) Ensuite, nous allons créer notre module étendu. Créez un

nouveau fichier appelé "NodeTutorial.js" et placez le code ci-
dessous dans le fichier.
var Tutor=require('./Tutorial.js');
exports.NodeTutorial=function()
{
console.log("Node Tutorial")
function pTutor()
{
var PTutor=Tutor
PTutor.tutorial;
}
}
Notez les points clés suivants au sujet du code ci-dessus
1. Nous utilisons la fonction "require" dans le nouveau fichier du

module lui-même. Puisque nous allons étendre le fichier de
module existant "Tutorial.js", nous devons d'abord l'inclure avant
de l'étendre.
2. Nous créons alors une fonction appelée "Nodetutorial". Cette
fonction fera 2 choses,
Il enverra une chaîne de caractères "Node Tutorial" à la
console.
Il enverra la chaîne de caractères "Guru99 Tutorial" du
module de base "Tutorial.js" à notre module étendu
"NodeTutorial.js".
1. Ici, nous effectuons la première étape pour envoyer une chaîne de

caractères à "Node Tutorial" à la console.
2. L'étape suivante est d'appeler la fonction à partir de notre module
Tutorial, qui va sortir la chaîne de caractères "Guru99 Tutorial"
vers la console.log.
Etape 3) Créez votre fichier app.js principal qui est votre fichier
d'application principal et incluez le code ci-dessous.
var localTutor=require('./NodeTutorial.js');
localTutor.NodeTutorial();
localTutor.NodeTutorial.pTutor();
Le code ci-dessus fait les choses suivantes ;
1. Notre principal fichier d'application s'appelle maintenant le

module "NodeTutorial".
2. Nous appelons la fonction "NodeTutorial". En appelant cette
fonction, le texte "Node Tutorial" sera affiché dans le journal de la
console.
3. Depuis que nous avons étendu notre module Tutorial.js et exposé
une fonction appelée pTutor. Il appelle également le module
tutoriel dans le module Tutorial.js, et le texte "Guru99 Tutorial"
sera également affiché sur la console.
Sortie :
Puisque nous avons exécuté le code app.js ci-dessus en utilisant Node,
nous obtiendrons la sortie suivante dans le fichier console.log.
Tutoriel sur les nœuds

Guru99 Tutoriel de Guru99
Publication des modules NPM(Node

Package Manager) Modules
On peut publier son propre module dans son propre dépôt Github.
En publiant votre module à un emplacement central, vous n'aurez pas

à vous installer sur toutes les machines qui en ont besoin.
Au lieu de cela, vous pouvez utiliser la commande d'installation de

npm et installer votre module npm publié.
Les étapes suivantes doivent être suivies pour publier votre module
npm
Etape 1) Créer votre référentiel sur GitHub (un outil de gestion de

référentiel de code en ligne). Il peut être utilisé pour héberger vos
dépôts de code.
Etape 2) Vous devez dire à votre installation locale npm qui vous
êtes. Ce qui signifie que nous devons dire à npm qui est l'auteur de ce
module, quel est l'identifiant email et toute URL d'entreprise
disponible qui doit être associée à cet identifiant. Tous ces détails
seront ajoutés à votre module npm lorsqu'il sera publié.
Les commandes ci-dessous définissent le nom, l'adresse e-mail et

l'URL de l'auteur du module npm.
npm set init.author.name "Guru99".

npm set init.author.author.email "guru99@gmail.com"
npm set init.author.url http://Guru99.com
Etape 3) L'étape suivante est de se connecter à npm en utilisant les

informations d'identification fournies lors de la dernière étape. Pour
vous connecter, vous devez utiliser la commande ci-dessous
npm login
Etape 4) Initialiser votre paquet - L'étape suivante est d'initialiser le

paquet pour créer le fichier package.json. Ceci peut être fait en
émettant la commande ci-dessous
npm init
Lorsque vous lancez la commande ci-dessus, vous serez invité à

répondre à certaines questions. Le plus important est le numéro de
version de votre module.
Etape 5) Publier sur GitHub - L'étape suivante est de publier vos

fichiers sources sur GitHub. Ceci peut être fait en exécutant les
commandes ci-dessous.
git add.
git commit -m "Initial release"
git tag v0.0.1
git push origin master --tags
Etape 6) Publier votre module - Le dernier bit est de publier votre

module dans le registre npm. Ceci se fait via la commande ci-dessous.
npm publish
Gestion des paquets tiers avec npm
Comme nous l'avons vu, le "Node package manager" a la capacité de
gérer les modules, qui sont requis par les applications Node.js.
Examinons quelques-unes des fonctions disponibles dans le

gestionnaire de paquets de nœuds pour la gestion des modules.
1. Installer les paquets en mode global - Les modules peuvent être

installés au niveau global, ce qui signifie simplement que ces
modules seraient disponibles pour tous les projets Node.js sur
une machine locale.
L'exemple ci-dessous montre comment installer le "module
express" avec l'option globale.
npm install express –global
L'option globale dans la déclaration ci-dessus est ce qui permet

d'installer les modules à un niveau global.
2. Liste de tous les paquets globaux installés sur une machine locale.
Ceci peut être fait en exécutant la commande suivante dans
l'invite de commande
npm list --global
Ci-dessous se trouve la sortie qui sera affichée, si vous avez déjà

installé le "module express" sur votre système.
Ici vous pouvez voir les différents modules installés sur la

machine locale.
3. Installer une version spécifique d'un paquet - Parfois, il peut être
nécessaire d'installer uniquement la version spécifique d'un
paquet. Une fois que vous savez quel est le paquet et la version
pertinente qui doit être installée, vous pouvez utiliser la
commande d'installation npm pour installer cette version
spécifique.
L'exemple ci-dessous montre comment installer le module appelé
underscore avec une version spécifique de 1.7.0.
npm install underscore@1.7.0
4. Mise à jour d'une version de paquet - Parfois, vous pouvez avoir

une ancienne version d'un paquet dans un système, et vous
pouvez vouloir mettre à jour vers la dernière version disponible
sur le marché. Pour ce faire, on peut utiliser la commande npm
update.
L'exemple ci-dessous montre comment mettre à jour le paquet
underscore vers la dernière version.
npm update underscore
5. Recherche d'un paquet particulier - Pour rechercher si une

version particulière est disponible sur le système local ou non,
vous pouvez utiliser la commande de recherche de npm.
L'exemple ci-dessous vérifiera si le module express est installé sur
la machine locale ou non.
npm search express
6. Désinstaller un paquet - La même chose dans laquelle vous

pouvez installer un paquet, vous pouvez aussi désinstaller un
paquet. La désinstallation d'un paquet se fait avec la commande
de désinstallation de npm.
L'exemple ci-dessous montre comment désinstaller le module
express.
npm uninstall express

Qu'est-ce que le fichier package.json
?
Le fichier "package.json" est utilisé pour contenir les métadonnées
d'un projet particulier. Cette information fournit au gestionnaire de
paquets du carrefour l'information nécessaire pour comprendre
comment le projet devrait être traité avec ses dépendances.
Les fichiers package.json contiennent des informations telles que la

description du projet, la version du projet dans une distribution
particulière, les informations de licence et les données de
configuration.
Le fichier package.json est normalement situé à la racine d'un projet

Node.js.
Prenons un exemple de la structure d'un module lorsqu'il est installé

via npm.
L'instantané ci-dessous montre le contenu du fichier du module

express lorsqu'il est inclus dans votre projet Node.js. A partir de
l'instantané, vous pouvez voir le fichier package.json dans le dossier
express.
Si vous ouvrez le fichier package.json, vous verrez beaucoup
d'informations dans le fichier.
Ci-dessous se trouve un instantané d'une partie du fichier. Le

express@~4.13.1 mentionne le numéro de version du module
express utilisé.
Résumé
Un module dans Node.js est une encapsulation logique de code

dans une seule unité. La séparation en modules rend le code plus
facile à gérer et à maintenir à des fins futures.
Il existe de nombreux modules disponibles sur le marché qui
peuvent être utilisés dans Node.js tels que express, underscore,
mongoDB, etc.
Le gestionnaire de paquets de nœuds (npm) est utilisé pour
télécharger et installer des modules qui peuvent ensuite être
utilisés dans une application Node.js.
On peut créer des modules NPM personnalisés, étendre ces
modules et publier ces modules.
Le gestionnaire de paquets Node dispose d'un ensemble complet de
commandes pour gérer les modules npm sur le système local tels
que l'installation, la désinstallation, la recherche, etc.
Le fichier package.json est utilisé pour contenir l'ensemble des
métadonnées d'un module npm.
Chapitre 4 : Créer un serveur et
obtenir des données
Le framework Node.js est principalement utilisé pour créer des

applications basées sur serveur. Le cadre peut facilement être utilisé
pour créer des serveurs web qui peuvent servir de contenu pour les
utilisateurs.
Il existe une variété de modules tels que les modules "http" et

"request", qui aident à traiter les requêtes liées au serveur dans
l'espace serveur web. Nous allons voir comment nous pouvons créer
une application de base de serveur web en utilisant Node js.
Node comme serveur web utilisant
HTTP
Regardons un exemple de comment créer et exécuter notre première
application Node js.
Notre application va créer un simple module serveur qui écoutera sur

le port no 7000. Si une demande est faite par l'intermédiaire du
navigateur sur ce port no, l'application serveur enverra une
réponse'Hello' World' au client.
var http=require('http')
var server=http.createServer((function(request,response)
{
response.writeHead(200,
{"Content-Type" : "text/plain"));
response.end("Hello World\n");
}));
server.listen(7000);
Code Explication :
1. La fonctionnalité de base de la fonction d'exigence est qu'il lit un

fichier javascript, exécute le fichier, puis procède au retour de
l'objet d'exportation. Ainsi, dans notre cas, puisque nous voulons
utiliser la fonctionnalité du module http, nous utilisons la
fonction require pour obtenir les fonctions requises à partir du
module http afin qu'il puisse être utilisé dans notre application.
2. Dans cette ligne de code, nous créons une application serveur qui
est basée sur une fonction simple. Cette fonction est appelée
chaque fois qu'une requête est faite à notre application serveur.
3. Lorsqu'une demande est reçue, nous vous demandons d'envoyer
une réponse avec un en-tête de type'200'. Ce numéro est la
réponse normale qui est envoyée dans un en-tête http lorsqu'une
réponse réussie est envoyée au client.
4. Dans la réponse elle-même, nous envoyons la chaîne'Hello
World'.
5. Nous utilisons alors la fonction server.listen pour faire en sorte
que notre application serveur écoute les requêtes des clients sur le
port no 7000. Vous pouvez spécifier n'importe quel port
disponible ici.
Si la commande est exécutée avec succès, la sortie suivante s'affiche

lorsque vous exécutez votre code dans le navigateur.
Sortie :
A partir de la sortie,
Vous pouvez clairement voir que si nous naviguons vers l'URL de
localhost sur le port 7000, vous verrez la chaîne'Hello World'
affichée dans la page.
Parce que dans notre code nous avons mentionné spécifiquement
pour le serveur d'écouter sur le port no 7000, nous sommes en
mesure de voir le résultat lors de la navigation vers cette url.
Voici le code de votre référence

var http=require('http')
var server=http.createServer((function(request,response)
{
response.writeHead(200,
{"Content-Type" : "text/plain"));
response.end("Hello World\n");
}));
server.listen(7000);
Traitement des requêtes GET dans
Node.js
Faire une requête GET pour obtenir les données d'un autre site est
relativement simple dans Node.js. Pour faire une requête Get dans le
node, nous devons d'abord avoir le module de requête installé. Ceci
peut être fait en exécutant la ligne suivante dans la ligne de commande
npm install request
La commande ci-dessus demande au gestionnaire de paquets Node de
télécharger les modules de requête requis et de les installer en
conséquence. Lorsque votre module npm a été installé avec succès, la
ligne de commande affichera le nom et la version du module installé :
<nom>@<version>.
Dans l'instantané ci-dessus, vous pouvez voir que le module'request'

avec le numéro de version 2.67.0 a été téléchargé et installé.
Voyons maintenant le code qui peut utiliser cette commande'request'.
var request = require("request");
request("http://www.google.com",function(error,response,body)
{
console.log(body);
});
Code Explication :
1. Nous utilisons le module'require' qui a été installé lors de la
dernière étape. Ce module possède les fonctions nécessaires qui
peuvent être utilisées pour effectuer des requêtes GET vers des
sites Web.
2. Nous faisons une demande GET à www.google.com et appelons
ensuite une fonction lorsqu'une réponse est reçue. Lorsqu'une
réponse est reçue, les paramètres (erreur, réponse et corps)
auront les valeurs suivantes
a. Erreur - En cas d'erreur reçue lors de l'utilisation de la
requête GET, celle-ci sera enregistrée ici.
b. Réponse- La réponse aura les en-têtes http qui sont renvoyés
dans la réponse.
c. Corps- Le corps contiendra l'intégralité du contenu de la
réponse envoyée par Google.
Dans ce cas, nous écrivons simplement le contenu reçu dans

le paramètre body dans le fichier console.log. Donc,
fondamentalement, tout ce que nous obtiendrons en allant sur
www.google.com sera écrit sur la console.log.
var request = require("request");
request("http://www.google.com",function(error,response,body)
{
console.log(body);
});
Résumé
Le framework Node.js peut être utilisé pour développer des
serveurs web en utilisant le module'http'. L'application peut être
faite pour écouter sur un port particulier et envoyer une réponse au
client chaque fois qu'une demande est faite à l'application.
Le module'demande' peut être utilisé pour obtenir des
informations à partir de sites Web. L'information contiendrait
l'intégralité du contenu de la page Web demandée au site Web
concerné.
Chapitre 5 : Node.js avec
Express
Dans ce tutoriel, nous examinerons également le cadre express. Ce

cadre est construit de telle manière qu'il agit comme un cadre
d'application web Node.js minimal et flexible, fournissant un
ensemble robuste de fonctionnalités pour la construction d'une
application web simple et multipage, et d'une application web hybride.
Qu'est-ce que Express.js ?
Express.js est un Node js web application server framework, qui est
spécifiquement conçu pour la construction d'applications web
monopage, multi-page et hybride.
Il est devenu le cadre de serveur standard pour node.js. Express est la

partie arrière de quelque chose connue sous le nom de pile MEAN.
Le MEAN est une pile logicielle JavaScript gratuite et open-source

pour la création de sites Web dynamiques et d'applications Web dont
les composants sont les suivants ;
1) MongoDB - La base de données standard NoSQL
2) Express.js - Le cadre par défaut des applications web
3) Angular.js - Le framework JavaScript MVC utilisé pour les

applications web.
4) Node.js - Framework utilisé pour les applications évolutives côté

serveur et réseau.
Le framework Express.js rend très facile le développement d'une

application qui peut être utilisée pour traiter de multiples types de
requêtes comme les requêtes GET, PUT, POST et DELETE.
Installation et utilisation d'Express
Express s'installe via le gestionnaire de paquets Node. Ceci peut être
fait en exécutant la ligne suivante dans la ligne de commande
npm install express

télécharger les modules express requis et de les installer en
conséquence.
Utilisons notre nouveau framework Express et créons une simple

application "Hello World".
Notre application va créer un simple module serveur qui écoutera sur

le port no 3000. Dans notre exemple, si une requête est faite via le
navigateur sur ce port no, alors l'application serveur enverra une
réponse'Hello' World' au client.
var app=express();
{
res.send('Hello World!');
});
var server=app.listen(3000,function() {});
Code Explication :
1. Dans notre première ligne de code, nous utilisons la fonction
require pour inclure le module express.
2. Avant de pouvoir commencer à utiliser le module express, nous
devons faire un objet du module express.
3. Nous créons ici une fonction de rappel. Cette fonction sera
appelée chaque fois que quelqu'un naviguera jusqu'à la racine de
notre application web qui est http://localhost:3000 . . La fonction
de rappel sera utilisée pour envoyer la chaîne'Hello World' à la
page web.
4. Dans la fonction de rappel, nous renvoyons la chaîne "Hello
World" au client. Le paramètre'res' est utilisé pour renvoyer le
contenu à la page web. Ce paramètre'res' est quelque chose qui est
fourni par le module'request' pour permettre d'envoyer du
contenu à la page web.
5. Nous utilisons alors la fonction listen to pour faire en sorte que
notre application serveur écoute les requêtes des clients sur le
port no 3000. Vous pouvez spécifier n'importe quel port
disponible ici.3

Sortie :

localhost sur le port 3000, vous verrez la chaîne'Hello World'
affichée dans la page.
Parce que dans notre code nous avons mentionné spécifiquement
pour le serveur d'écouter sur le port no 3000, nous sommes en
mesure de voir la sortie lors de la navigation vers cette URL.
Que sont les Routes
Le routage sert à déterminer la façon dont une application répond à
une demande d'un client à un point final particulier.
Par exemple, un client peut faire une requête GET, POST, PUT, PUT
ou DELETE http pour diverses URL comme celle montrée ci-dessous ;
http://localhost:3000/Books
http://localhost:3000/Students
Dans l'exemple ci-dessus,
Si une requête GET est faite pour la première URL, alors la réponse
devrait idéalement être une liste de livres.
Si la requête GET est faite pour la deuxième URL, alors la réponse
devrait idéalement être une liste d'Etudiants.
Ainsi, sur la base de l'URL à laquelle on accède, une fonctionnalité
différente sur le serveur web sera invoquée et, en conséquence, la
réponse sera envoyée au client. C'est le concept de routage.
Chaque route peut avoir une ou plusieurs fonctions de gestion, qui

sont exécutées lors de la mise en correspondance de la route.
La syntaxe générale d'un itinéraire est la suivante

app.METHOD(PATH, HANDLER)
où
1) app est une instance du module express
2) METHOD est une méthode de requête HTTP (GET, POST, PUT,

PUT ou DELETE).
3) PATH est un chemin sur le serveur.
4) HANDLER est la fonction exécutée lors de l'appariement de

l'itinéraire.
Examinons un exemple de la façon dont nous pouvons mettre en

œuvre des itinéraires en express. Notre exemple créera 3 routes
comme suit
1. Une route /Node qui affichera la chaîne de caractères "Tutorial

on Node" si l'on accède à cette route.
2. Une route /Angulaire qui affichera la chaîne de caractères
"Tutorial on Angular" si l'on accède à cette route.
3. Une route par défaut / qui affichera la chaîne de caractères
"Welcome to Guru99 Tutorials".
Notre code de base restera le même que les exemples précédents.

L'extrait ci-dessous est un add-on pour montrer comment le routage
est implémenté.
app.route('/Node).get(function(req.res)
{
res.send("Tutorial on Node");
});
app.route('/Angular).get(function(req.res)
{
res.send("Tutorial on Angular");
});
{
res.send('Welcome to Guru99 Tutorials');
});
Code Explication :
1. Ici, nous définissons un itinéraire si l'URL

http://localhost:3000/Node est sélectionné dans le
navigateur. Nous attachons à l'itinéraire une fonction de rappel
qui sera appelée lorsque nous naviguerons vers l'URL du Node.
La fonction a 2 paramètres.
Le paramètre principal que nous utiliserons est le paramètre'res'

qui peut être utilisé pour renvoyer des informations au client.
Le paramètre'req' contient des informations sur la requête en
cours. Parfois, des paramètres supplémentaires peuvent être
envoyés dans le cadre de la demande, et donc le paramètre'req'
peut être utilisé pour trouver les paramètres supplémentaires
envoyés.
2. Nous utilisons la fonction d'envoi pour renvoyer la chaîne

"Tutorial on Node" au client si l'itinéraire Node est choisi.
3. Ici, nous définissons un itinéraire si l'URL
http://localhost:3000/Angular est sélectionné dans le
navigateur. A l'itinéraire, nous attachons une fonction de rappel
qui sera appelée lorsque nous naviguerons vers l'URL Angular.
4. Nous utilisons la fonction d'envoi pour renvoyer la chaîne de
caractères "Tutorial on Angular" au client si la route Angular est
choisie.
5. Il s'agit de l'itinéraire par défaut qui est choisi lorsque l'on
navigue vers l'itinéraire de l'application -http://localhost:3000.
Lorsque l'itinéraire par défaut est choisi, le message "Welcome to
Guru99 Tutorials" sera envoyé au client.

Sortie :

localhost sur le port 3000, vous verrez la chaîne'Welcome to
Guru99 Tutorials' affichée sur la page.
Parce que dans notre code, nous avons mentionné que notre URL
par défaut afficherait ce message.
Vous pouvez voir que si l'URL a été changé en /Node, l'itinéraire du

Node respectif serait choisi et la chaîne "Tutorial On Node" est
affichée.
Vous pouvez voir que si l'URL a été changé en /Angular, l'itinéraire
du nœud respectif serait choisi et la chaîne de caractères "Tutorial
On Angular" est affichée.
Exemple de serveur Web utilisant
express.js
A partir de notre exemple ci-dessus, nous avons vu comment nous
pouvons décider quelle sortie afficher en fonction du routage. Ce type
de routage est ce qui est utilisé dans la plupart des applications web
modernes. L'autre partie d'un serveur web concerne l'utilisation de
modèles dans Node js.
Lors de la création rapide d'applications Node à la volée, un moyen

simple et rapide est d'utiliser des modèles pour l'application. Il existe
de nombreux cadres disponibles sur le marché pour la création de
modèles. Dans notre cas, nous prendrons l'exemple du cadre de jade
pour le modèle.
Jade s'installe via le gestionnaire de paquets Node. Ceci peut être fait
en exécutant la ligne suivante dans la ligne de commande
npm install jade

télécharger les modules jade requis et de les installer en conséquence.
Utilisons notre framework jade nouvellement installé et créons

quelques modèles de base.
Étape 1) La première étape consiste à créer un modèle en jade. Créez

un fichier appelé index.jade et insérez le code suivant
1. Ici nous spécifions que le titre de la page sera changé à n'importe
quelle valeur qui est passée quand ce modèle est invoqué.
2. Nous spécifions également que le texte dans la balise header sera
remplacé par ce qui est passé dans le template jade.
var app=express();
app.set('view engine','jade');
res.render('index',
{title:'Guru99',message:'Welcome'})
});
var server=app.listen(3000,function() {});
Code Explication :
1. La première chose à spécifier dans l'application est "moteur de
vue" qui sera utilisé pour le rendu des modèles. Puisque nous
allons utiliser jade pour rendre nos modèles, nous le spécifions en
conséquence.
2. La fonction de rendu est utilisée pour rendre une page Web. Dans
notre exemple, nous rendons le modèle (index.jade) qui a été créé
plus tôt.
3. Nous passons les valeurs de "Guru99" et "Welcome" aux
paramètres "title" et "message" respectivement. Ces valeurs
seront remplacées par les paramètres'title', et'message' déclarés
dans le modèle index.jade.

Sortie :
Nous pouvons voir que le titre de la page est réglé sur "Guru99" et
que l'en-tête de la page est réglé sur "Bienvenue".
C'est à cause du template jade qui est invoqué dans notre
application js node.
Résumé
Le cadre express est le cadre le plus communément utilisé pour le

développement des applications Node js. Le framework express est
construit sur le framework node.js et permet d'accélérer le
développement d'applications basées sur serveur.
Les routes sont utilisées pour détourner les utilisateurs vers
différentes parties des applications web en fonction de la demande
faite. La réponse pour chaque itinéraire peut varier en fonction de
ce qui doit être montré à l'utilisateur.
Les modèles peuvent être utilisés pour injecter du contenu de
manière efficace. Jade est l'un des moteurs de template les plus
populaires utilisés dans les applications Node.js.
Chapitre 6 : Node.js avec
MongoDB
La plupart des applications Web modernes disposent d'une sorte de

système de stockage de données à l'arrière-plan pour stocker les
données. Par exemple, si vous prenez le cas d'une application d'achat
en ligne, des données telles que le prix d'un article ou le nombre
d'articles d'un type particulier seraient stockées dans la base de
données.
Le framework Node js a la capacité de travailler avec des bases de

données qui sont communément requises par la plupart des
applications web modernes. Node js peut fonctionner aussi bien avec
des bases de données relationnelles (comme Oracle et MS SQL Server)
qu'avec des bases de données non relationnelles (comme MongoDB et
MySQL). Au cours de ce tutoriel, nous verrons comment nous pouvons
utiliser les bases de données à partir des applications Node js.
Bases de données Node.js et NoSQL
Au fil des années, les bases de données NoSQL telles que MongoDB et
MySQL sont devenues très populaires en tant que bases de données
pour le stockage de données. La capacité de ces bases de données à
stocker n'importe quel type de contenu et en particulier dans
n'importe quel format est ce qui rend ces bases de données si célèbres.
Node.js a la capacité de travailler avec MySQL et MongoDB comme

bases de données. Pour utiliser l'une ou l'autre de ces bases de
données, vous devez télécharger et utiliser les modules requis à l'aide
du gestionnaire de paquets Node.
Pour MySQL, le module requis s'appelle "mysql" et pour l'utilisation

de MongoDB, le module à installer est "Mongoose".
Avec ces modules, vous pouvez effectuer les opérations suivantes dans
Node.js
1. Gérer le pool de connexions - C'est ici que vous pouvez spécifier le

nombre de connexions à la base de données MySQL qui doivent
être maintenues et sauvegardées par Node.js.
2. Créer et fermer une connexion à une base de données. Dans les
deux cas, vous pouvez fournir une fonction de rappel qui peut être
appelée chaque fois que les méthodes de connexion "créer" et
"fermer" sont exécutées.
3. Les requêtes peuvent être exécutées pour obtenir des données des
bases de données respectives afin de récupérer les données.
4. Ces modules permettent également d'effectuer des manipulations
de données telles que l'insertion, l'effacement et la mise à jour des
données.
Pour les autres sujets, nous verrons comment nous pouvons travailler
avec les bases de données MongoDB dans Node.js.
Utilisation de MongoDB et Node.js
Comme nous l'avons vu plus haut, MongoDB est l'une des bases de
données les plus populaires utilisées avec Node.js.
Au cours de ce chapitre, nous allons voir
Comment établir des connexions avec une base de données MongoDB
Comment nous pouvons effectuer les opérations normales de lecture

des données d'une base de données ainsi que l'insertion, la
suppression et la mise à jour des enregistrements dans une base de
données mongoDB.
Pour les besoins de ce chapitre, supposons que les données mongoDB

ci-dessous sont en place.
Nom de la base de données : EmployeeDB
Nom de la collection : Employé

Documents
{
{Employeeid : 1, Employee Name : Guru99},
{Employeeid : 2, Employee Name : Joe},
{Employeeid : 3, Employee Name : Martin},
}
1. Installation des modules NPM Pour accéder à Mongo à partir

d'une application Node, un pilote est nécessaire. Il y a un certain
nombre de pilotes Mongo disponibles, mais MongoDB est parmi
les plus populaires. Pour installer le module MongoDB, exécutez
la commande suivante
npm install mongodb
2. Créer et fermer une connexion à une base de données MongoDB.

L'extrait de code ci-dessous montre comment créer et fermer une
connexion à une base de données MongoDB.
var MongoClient = require('mongodb').MongoClient;

var url = 'mongodb://localhost/EmployeeDB';
MongoClient.connect(url, function(err, db) {
cursor.log("connected");
db.close();
});
Code Explication :
1. La première étape est d'inclure le module mongoose qui se fait

par le biais de la fonction require. Une fois ce module en place,
nous pouvons utiliser les fonctions nécessaires disponibles dans
ce module pour créer des connexions à la base de données.
2. Ensuite, nous spécifions notre chaîne de connexion à la base de
données. Dans la chaîne de connexion, il y a 3 valeurs clés qui
sont transmises.
Le premier est'mongodb' qui spécifie que nous nous connectons à

une base de données mongoDB.
Le suivant est'localhost', ce qui signifie que nous nous connectons à
une base de données sur la machine locale.
Le suivant est'EmployeeDB' qui est le nom de la base de données
définie dans notre base de données MongoDB.
3. L'étape suivante consiste à se connecter à notre base de données.

La fonction de connexion prend en compte notre URL et a la
possibilité de spécifier une fonction de rappel. Il sera appelé
lorsque la connexion à la base de données sera ouverte. Cela nous
donne l'occasion de savoir si la connexion à la base de données a
été réussie ou non.
4. Dans la fonction, nous écrivons la chaîne de caractères
"Connexion établie" sur la console pour indiquer qu'une
connexion réussie a été créée.
5. Enfin, nous fermons la connexion à l'aide de l'instruction
db.close.
Si le code ci-dessus est exécuté correctement, la chaîne "Connected"

sera écrite sur la console comme indiqué ci-dessous.
3. Recherche de données dans une base de données

MongoDB - En utilisant le pilote MongoDB, nous pouvons
également récupérer des données à partir de la base de données
MongoDB.
La section ci-dessous montrera comment nous pouvons utiliser le

pilote pour récupérer tous les documents de notre collection
d'employés (Il s'agit de la collection de notre base de données
MongoDB qui contient tous les documents relatifs aux employés.
Chaque document a un ID d'objet, le nom de l'employé et l'ID de
l'employé pour définir les valeurs du document) dans notre base de
données EmployeeDB.
var cursor = db.collection('Employee').find();
cursor.each(function(err, doc) {
console.log(doc);
});
});
Code Explication :
1. Dans la première étape, nous créons un curseur (un curseur est

un pointeur qui est utilisé pour pointer vers les différents
enregistrements récupérés à partir d'une base de données. Le
curseur est ensuite utilisé pour itérer les différents
enregistrements de la base de données. Ici, nous définissons un
nom de variable appelé curseur qui sera utilisé pour stocker le
pointeur vers les enregistrements récupérés dans la base de
données. qui pointe vers les enregistrements récupérés dans la
collection MongoDb. Nous avons également la possibilité de
spécifier la collection " Employé " à partir de laquelle récupérer
les enregistrements. La fonction find() est utilisée pour spécifier
que nous voulons récupérer tous les documents de la collection
MongoDB.
2. Nous sommes en train d'itérer à travers notre curseur et pour
chaque document dans le curseur, nous allons exécuter une
fonction.
3. Notre fonction est simplement d'imprimer le contenu de chaque
document sur la console.
Note : - Il est également possible de récupérer un enregistrement

particulier à partir d'une base de données. Ceci peut être fait en
spécifiant la condition de recherche dans la fonction find(). Par
exemple, supposons que si vous vouliez simplement récupérer
l'enregistrement dont le nom de l'employé est Guru99, alors cette
instruction peut être écrite comme suit : "var
cursor=db.collection('Employee').find()".
Si le code ci-dessus est exécuté avec succès, la sortie suivante sera

affichée dans votre console.
Sortie :
Vous pourrez voir clairement que tous les documents de la

collection sont récupérés. Ceci est possible en utilisant la méthode
find() de la connexion mongoDB (db) et en itérant tous les
documents à l'aide du curseur.
4. Insertion de documents dans une collection - Les
documents peuvent être insérés dans une collection en utilisant la
méthode insertOne fournie par la bibliothèque MongoDB.
L'extrait de code ci-dessous montre comment insérer un
document dans une collection mongoDB.

db.collection('Employee').insertOne({
Employeeid: 4,
EmployeeName: "NewEmployee"
});
});
Code Explication du code:
1. Ici, nous utilisons la méthode insertOne de la bibliothèque

MongoDB pour insérer un document dans la collection des
employés.
2. Nous spécifions les détails du document de ce qui doit être inséré
dans la collection des employés.
Si vous vérifiez maintenant le contenu de votre base de données

MongoDB, vous trouverez l'enregistrement avec Employeeid de 4 et
EmployeeName de "NewEmployee" inséré dans la collection
Employee.
Note : La console n'affichera aucune sortie parce que l'enregistrement

est inséré dans la base de données et qu'aucune sortie ne peut être
affichée ici.
Pour vérifier que les données ont été correctement insérées dans la
base de données, vous devez exécuter les commandes suivantes dans
MongoDB
1. Utiliser EmployeeDB
2. db.Employee.find({Employeeid :4 })
La première déclaration garantit que vous êtes connecté à la base de

données EmployeeDb. Le deuxième énoncé cherche l'enregistrement
dont le numéro d'identification de l'employé est 4.
5. Mise à jour de documents dans une collection - Les

documents peuvent être mis à jour dans une collection en
utilisant la méthode updateOne fournie par la bibliothèque
MongoDB. L'extrait de code ci-dessous montre comment mettre à
jour un document dans une collection mongoDB.

db.collection('Employee').updateOne({
"EmployeeName": "NewEmployee"
}, {
$set: {
"EmployeeName": "Mohan"
}
});
});
Code Explication :
1. Ici, nous utilisons la méthode "updateOne" de la bibliothèque

MongoDB, qui est utilisée pour mettre à jour un document dans
une collection mongoDB.
2. Nous spécifions les critères de recherche du document à mettre à
jour. Dans notre cas, nous voulons trouver le document qui a le
nom de l'employé de "NewEmployee".
3. Nous voulons ensuite définir la valeur du nom de l'employé du
document de "NewEmployee" à "Mohan".

EmployeeName de "Mohan" mis à jour dans la collection Employee.
Pour vérifier que les données ont été correctement mises à jour dans la
MongoDB
2. db.Employee.find({Employeeid :4 })

données EmployeeDb. Le deuxième énoncé cherche l'enregistrement
dont le numéro d'identification de l'employé est 4.
6. Suppression de documents dans une collection - Les

documents peuvent être supprimés dans une collection à l'aide de
la méthode "deleteOne" fournie par la bibliothèque MongoDB.
L'extrait de code ci-dessous montre comment supprimer un
document d'une collection mongoDB.


db.collection('Employee').deleteOne(
{
}
);
});
Code Explication :
1. Nous utilisons ici la méthode "deleteOne" de la bibliothèque

MongoDB, qui permet de supprimer un document d'une
collection mongoDB.
2. Nous spécifions les critères de recherche du document à
supprimer. Dans notre cas, nous voulons trouver le document qui
a le nom de l'employé de "Mohan" et supprimer ce document.

EmployeeName de "Mohan" supprimé de la collection Employee.
Pour vérifier que les données ont été correctement mises à jour dans la
MongoDB
2. db.Employee.find()

données EmployeeDb. Le deuxième relevé recherche et affiche tous les
enregistrements de la collection des employés. Vous pouvez voir ici si
l'enregistrement a été supprimé ou non.
Comment construire une
application noeud express avec
MongoDB pour stocker et servir le
contenu.
Construire une application avec une combinaison des deux en utilisant
Express et MongoDB est très courant de nos jours.
Lorsque l'on travaille avec des applications web basées sur JavaScript,
on parlera normalement ici du terme MEAN stack.
Le terme MEAN stack fait référence à une collection de

technologies basées sur JavaScript utilisées pour développer des
applications web.
MEAN est l'acronyme de MongoDB, ExpressJS, AngularJS et
Node.js.
Il est donc toujours bon de comprendre comment Node.js et

MongoDB travaillent ensemble pour fournir des applications qui
interagissent avec les bases de données dorsales.
Voyons un exemple simple de la façon dont nous pouvons utiliser

"express" et "MongoDB" ensemble. Notre exemple utilisera la même
collection d'employés dans la base de données MongoDB
EmployeeDB.
Nous allons maintenant incorporer Express pour afficher les données
sur notre page Web lorsqu'elles sont demandées par l'utilisateur.
Lorsque notre application s'exécute sur Node.js, il se peut que l'on ait
besoin de naviguer jusqu'à l'URL
http://localhost:3000/Employeeid.
Lorsque la page est lancée, tous les numéros d'identification des

employés de la collection d'employés seront affichés. Voyons donc
l'extrait de code dans les sections qui nous permettront d'y parvenir.
Etape 1) Définir toutes les bibliothèques qui doivent être utilisées

dans notre application, qui dans notre cas est à la fois la bibliothèque
MongoDB et la bibliothèque express.
Code Explication :
1. Nous sommes en train de définir notre bibliothèque'express', qui

sera utilisée dans notre application.
2. Nous sommes en train de définir notre bibliothèque'express', qui
sera utilisée dans notre application pour se connecter à notre base
de données MongoDB.
3. Ici, nous définissons l'URL de notre base de données à laquelle se
connecter.
4. Enfin, nous sommes en train de définir une chaîne de caractères
qui sera utilisée pour stocker notre collection d'identifiants
d'employés qui devront être affichés dans le navigateur par la
suite.
Étape 2) Dans cette étape, nous allons maintenant obtenir tous les
documents de notre collection " Employés " et travailler avec eux en
conséquence.
Code Explication :
1. Nous sommes en train de créer une route vers notre application

appelée'Employeeid'. Ainsi, chaque fois que quelqu'un navigue
sur http://localhost:3000/Employeeid de notre application,
l'extrait de code défini pour cette route sera exécuté.
2. Ici, nous obtenons tous les enregistrements de notre
collection'Employee' par le biais de la commande
db.collection('Employee').find(). Nous assignons alors cette
collection à une variable appelée curseur. En utilisant cette
variable du curseur, nous pourrons parcourir tous les
enregistrements de la collection.
3. Nous utilisons maintenant la fonction cursor.each() pour
naviguer à travers tous les enregistrements de notre collection.
Pour chaque enregistrement, nous allons définir un extrait de
code sur ce qu'il faut faire quand on accède à chaque
enregistrement.
4. Enfin, nous voyons que si l'enregistrement retourné n'est pas nul,
alors nous prenons l'employé via la commande
"item.Employeeid". Le reste du code n'est que pour construire un
code HTML approprié qui permettra à nos résultats d'être
affichés correctement dans le navigateur.
Etape 3) Dans cette étape, nous allons envoyer notre sortie sur la
page web et faire écouter notre application sur un port particulier.
Code Explication :
1. Ici nous envoyons le contenu entier qui a été construit dans

l'étape précédente à notre page Web. Le paramètre'res' nous
permet d'envoyer du contenu à notre page web en guise de
réponse.
2. Nous faisons en sorte que toute notre application Node.js écoute
sur le port 3000.
Sortie :
Il montre clairement que toutes les pièces d'identité des employés

de la collection des employés ont été récupérées. C'est parce que
nous utilisons le pilote MongoDB pour nous connecter à la base de
données et récupérer tous les enregistrements des employés et
ensuite utilisé "express" pour afficher les enregistrements.

var express = require('express');
var app = express();
var str = "";
app.route('/Employeeid').get(function(req, res)
{
var cursor = db.collection('Employee').find();
//noinspection JSDeprecatedSymbols
cursor.each(function(err, item) {
if (item != null) {
str = str + " Employee id " +
item.Employeeid + "";
}
});
res.send(str);
db.close();
});
});
var server = app.listen(3000, function() {});
Note:cursor.each peut être déprécié en fonction de la version de votre

pilote MongoDB. Vous pouvez ajouter //noinspection
JSDeprecatedSymbols avant cursor.each pour contourner le problème.
Alternativement, vous pouvez utiliser forEach. Ci-dessous se trouve le
code d'exemple d'utilisation forEach.
var express = require('express');
var app = express();
var str = "";
app.route('/Employeeid').get(function(req, res) {
var collection = db.collection('Employee');
var cursor = collection.find({});
str = "";
cursor.forEach(function(item) {
if (item != null) {
str = str + " Employee id " +
item.Employeeid + "";
}
}, function(err) {
res.send(str);
db.close();
}
);
});
});
var server = app.listen(8080, function() {});
Résumé
Node.js est utilisé en conjonction avec les bases de données NoSQL

pour construire un grand nombre d'applications web modernes.
Certaines des bases de données communes utilisées sont MySQL et
MongoDB.
L'un des modules communs utilisés pour travailler avec les bases
de données MongoDB est un module appelé'MongoDB'. Ce module
est installé via le gestionnaire de paquets Node.
Avec le module MongoDB, il est possible d'interroger les
enregistrements d'une collection et d'effectuer les opérations
normales de mise à jour, de suppression et d'insertion.
Enfin, l'une des pratiques modernes consiste à utiliser le cadre
express avec MongoDB pour livrer des applications modernes. Le
cadre Express peut utiliser les données renvoyées par le pilote
MongoDB et afficher les données à l'utilisateur dans la page Web
en conséquence.
Chapitre 7 : Promesse,
Générateur, Événement et
Filestream
Dans les tutoriels précédents, vous auriez vu les fonctions de rappel

qui sont utilisées pour les événements asynchrones. Mais parfois les
fonctions de rappel peuvent devenir un cauchemar lorsqu'elles
commencent à s'imbriquer, et le programme commence à devenir long
et complexe.
Dans de tels cas, Node.js fournit des fonctionnalités supplémentaires

pour corriger les problèmes rencontrés lors de l'utilisation des
callbacks. Celles-ci sont classées en Promesses, génère et événements.
Au cours de ce tutoriel, nous allons apprendre et voir ces concepts plus
en détail.
Que sont les promesses
Avant de commencer avec des promesses, revoyons d'abord ce que
sont les fonctions de "callback" dans Node.js. Nous avons beaucoup vu
ces fonctions de rappel dans les chapitres précédents, alors passons
rapidement en revue l'une d'entre elles.
L'exemple ci-dessous montre un extrait de code, qui est utilisé pour se

connecter à une base de données MongoDB et effectuer une opération
de mise à jour sur l'un des enregistrements de la base de données.
1. Dans le code ci-dessus, la partie de la fonction(err,db) est connue

sous le nom de déclaration d'une fonction anonyme ou de rappel.
Lorsque le MongoClient crée une connexion à la base de données
MongoDB, il revient à la fonction de rappel une fois l'opération de
connexion terminée. Donc, dans un sens, les opérations de
connexion se font en arrière-plan, et quand c'est fait, il appelle
notre fonction de rappel. Rappelez-vous que c'est l'un des points
clés de Node.js pour permettre à de nombreuses opérations de se
produire simultanément et ainsi ne pas empêcher un utilisateur
d'effectuer une opération.
2. Le deuxième bloc de code est ce qui est exécuté lorsque la
fonction de rappel est effectivement appelée. La fonction de
rappel ne fait que mettre à jour un enregistrement dans notre
base de données MongoDB.
Alors, qu'est-ce qu'une promesse ? Eh bien, une promesse n'est qu'une

amélioration des fonctions de rappel dans Node.js. Au cours du cycle
de développement, il peut y avoir une instance où vous auriez besoin
d'imbriquer plusieurs fonctions de rappel ensemble. Cela peut devenir
une sorte de désordre et difficile à maintenir à un certain moment
dans le temps. En bref, une promesse est une amélioration des rappels
au travail qui vise à atténuer ces problèmes.
La syntaxe de base d'une promesse est montrée ci-dessous ;

var promise = doSomethingAync()
promise.then(onFulfilled, onRejected)
"doSomethingAync" est une fonction de rappel ou asynchrone qui

fait une sorte de traitement.
Cette fois, lors de la définition du rappel, il y a une valeur qui est
retournée appelée "promesse".
Lorsqu'une promesse est retournée, elle peut avoir 2 sorties. Ceci
est défini par la " clause de l'époque ". Soit l'opération peut être un
succès, ce qui est indiqué par le paramètre'onFulfilled'. Ou bien il
peut avoir une erreur qui est dénotée par le paramètre'onRejected'.
Note : L'aspect clé d'une promesse est donc la valeur de retour. Il n'y
a pas de concept de valeur de retour lorsqu'on travaille avec des
rappels normaux dans Node.js. En raison de la valeur de retour, nous
avons plus de contrôle sur la manière dont la fonction de rappel peut
être définie.
Dans le prochain sujet, nous verrons un exemple de promesses et

comment elles bénéficient des rappels.
Rappels aux promesses
Voyons maintenant un exemple de la façon dont nous pouvons utiliser
les " promises " à partir d'une application Node.js. Afin d'utiliser
promises dans une application Node.js, le module'promise' doit
d'abord être téléchargé et installé.
Nous modifierons ensuite notre code comme indiqué ci-dessous, qui

met à jour un nom d'Employé dans la collection'Employé' en utilisant
des promesses.
Étape 1) Installation des modules NPM
Pour utiliser Promises à partir d'une application Node JS, le module

Promises est nécessaire. Pour installer le module Promesse, exécutez
la commande ci-dessous
npm install promise
Étape 2) Modifier le code pour y inclure les promesses.

var Promise = require('promise');
MongoClient.connect(url)
.then(function(err, db) {
db.collection('Employee').updateOne({
"EmployeeName": "Martin"
}, {
$set: {
}
});
});
Code Explication:-
1. La première partie est d'inclure le module'promesse' qui nous

permettra d'utiliser la fonctionnalité de promesse dans notre
code.
2. Nous pouvons maintenant ajouter la fonction'then' à notre
fonction MongoClient.connect. Ainsi, lorsque la connexion à la
base de données est établie, nous devons exécuter l'extrait de
code défini par la suite.
3. Enfin, nous définissons notre extrait de code qui fait le travail de
mise à jour de EmployeeName de l'employé avec le nom de
"Martin" à "Mohan".
Note : -

MongoDB, vous constaterez que si un enregistrement avec le nom de
l'employé "Martin" existe, il sera mis à jour en "Mohan".
Pour vérifier que les données ont été correctement insérées dans la
MongoDB
2. db.Employee.find({EmployeeName :Mohan })

données EmployeeDb. La seconde recherche l'enregistrement qui
porte le nom de l'employé "Mohan".
Traiter les promesses emboîtées
Lors de la définition des promesses, il convient de noter que la
méthode "à l'époque" renvoie elle-même une promesse. Ainsi, dans un
sens, les promesses peuvent être imbriquées ou enchaînées les unes
aux autres.
Dans l'exemple ci-dessous, nous utilisons l'enchaînement pour définir

2 fonctions de rappel, qui insèrent toutes deux un enregistrement dans
la base de données MongoDB.
(Note : Le chaînage est un concept utilisé pour lier l'exécution des

méthodes les unes aux autres. Supposons que votre application ait 2
méthodes appelées'methodA' et'methodB'. Et la logique était telle
que'methodB' devrait être appelé après'methodA', alors vous
enchaîneriez l'exécution de telle sorte que'methodB' soit appelé
directement après'methodA').
La chose clé à noter dans cet exemple est que le code devient plus
propre, lisible et maintenable en utilisant des promesses imbriquées.
var Promise = require('promise');
MongoClient.connect(url)
.then(function(db) {
db.collection('Employee').insertOne({
Employeeid: 4,
EmployeeName: "NewEmployee"
})
.then(function(db1) {
db1.collection('Employee').insertOne({
Employeeid: 5,
EmployeeName: "NewEmployee1"
})
})
});
Code Explication:-
1. Nous sommes en train de définir 2 clauses "à l'époque" qui sont

exécutées l'une après l'autre. Dans la première clause, nous
passons le paramètre'db' qui contient notre connexion à la base
de données. Nous utilisons alors la propriété de collection de la
connexion'db' pour insérer des enregistrements dans la
collection'Employés'. La méthode'insertOne' est utilisée pour
insérer le document réel dans la collection des employés.
2. Nous utilisons alors la clause 2nd then pour insérer un autre
enregistrement dans la base de données.

MongoDB, vous trouverez les 2 enregistrements insérés dans la base
de données MongoDB.
Générer des promesses avec la
bibliothèque BlueBird
Bluebird est une bibliothèque Promise complète pour JavaScript. La
caractéristique la plus forte de Bluebird est qu'il vous permet de
"promettre" d'autres modules Node afin de les utiliser de manière
asynchrone. Promisify est un concept appliqué aux fonctions de
rappel. Ce concept est utilisé pour s'assurer que chaque fonction de
rappel qui est appelée renvoie une sorte de valeur.
Ainsi, si un module Node JS contient une fonction de rappel qui ne

renvoie pas de valeur, si nous promettons le module de nœud, toutes
les fonctions de ce module de nœud spécifique seraient
automatiquement modifiées pour s'assurer qu'il renvoie une valeur.
Vous pouvez donc utiliser BlueBird pour faire fonctionner le module

MongoDB de manière asynchrone. Cela ne fait qu'ajouter un autre
niveau de facilité lors de l'écriture des applications Node.js.
Nous examinerons un exemple d'utilisation du module bluebird.
Notre exemple va d'abord établir une connexion avec le "Employee

collection" dans la base de données "EmployeeDB". Si la connexion
"alors" est établie, il obtiendra tous les documents de la collection et
les affichera dans la console en conséquence.

Pour utiliser Bluebird à partir d'une application Node, le module
Bluebird est nécessaire. Pour installer le module Bluebird, exécutez la
commande ci-dessous
npm install bluebird
Étape 2) L'étape suivante est d'inclure le module bluebird dans votre

code et de promettre le module MongoDB en entier. Par promesse,
nous entendons que bluebird s'assurera que chaque méthode définie
dans la bibliothèque MongoDB renvoie une promesse.
Code Explication du code:-
1. La commande require est utilisée pour inclure la bibliothèque

Bluebird.
2. Utilisez la méthode .promiseifyAll() de Bluebird pour créer une
version asynchrone de toutes les méthodes fournies par le module
MongoDB. Ceci garantit que chaque méthode du module
MongoDB s'exécute en arrière-plan et qu'une promesse est
renvoyée pour chaque appel de méthode dans la bibliothèque
MongoDB.
Étape 3) L'étape finale est de se connecter à notre base de données,

de récupérer tous les enregistrements de notre collection et de les
afficher dans notre journal de console.
1. Vous remarquerez que nous utilisons la méthode "connectAsync"

au lieu de la méthode de connexion normale pour se connecter à
la base de données. Bluebird ajoute en fait le mot-clé Async à
chaque méthode de la bibliothèque MongoDB pour distinguer les
appels qui retournent des promesses et ceux qui ne le font pas. Il
n'y a donc aucune garantie que les méthodes sans le mot Async
retourneront une valeur.
2. Comme pour la méthode connectAsync, nous utilisons
maintenant la méthode findAsync pour retourner tous les
enregistrements de la collection'Employee' de mongoDB.
3. Enfin, si findAsync renvoie une promesse réussie, nous
définissons alors un bloc de code pour itérer chaque
enregistrement de la collection et les afficher dans le journal de la
console.
Si les étapes ci-dessus sont exécutées correctement, tous les

documents de la collection des employés seront affichés dans la
console comme indiqué dans la sortie ci-dessous.
var Promise = require('bluebird');
var mongoClient =
Promise.promisifyAll(require('mongodb')).MongoClient;

mongoClient.connectAsync('mongodb://localhost/EmployeeDB')
.then(function(db) {
return db.collection('Employee').findAsync({})
})
.then(function(cursor) {
cursor.each(function(err, doc) {
console.log(doc);
})
});
Créer une promesse personnalisée
Une promesse personnalisée peut être créée en utilisant un module de
nœud appelé'q'. La bibliothèque'q' doit être téléchargée et installée en
utilisant le gestionnaire de paquets de nœud. Après avoir utilisé la
bibliothèque'q', la méthode "denodeify" peut être appelée, ce qui fait
que n'importe quelle fonction devient une fonction qui retourne une
promesse.
Dans l'exemple ci-dessous, nous allons créer une fonction simple

appelée "Ajouter" qui ajoutera 2 numéros. Nous allons convertir cette
fonction en une fonction de retour de promesse.
Une fois cela fait, nous utiliserons la promesse retournée par la

fonction Ajouter pour afficher un message dans le fichier console.log.
Suivez les étapes ci-dessous pour créer notre fonction personnalisée

afin de retourner une promesse.
Pour utiliser'q' à partir d'une application Node JS, le module'q' est

nécessaire. Pour installer le module'q', exécutez la commande ci-
dessous
npm install q
Étape 2) Définir le code suivant qui sera utilisé pour créer la

promesse personnalisée.
var Q= require('q');
function Add() {
var a, b, c;
a=5;b=6;
c=a+b;
var Display_promise= Q.denodeify(Add);
var promise=Add;
promise.then
{console.log("Addition function complete");}
1. Le premier bit est d'inclure la bibliothèque'q' en utilisant le mot-

clé requis. En utilisant cette librairie, nous pourrons définir
n'importe quelle fonction pour retourner un rappel.
2. Nous sommes en train de créer une fonction appelée Add qui
ajoutera 2 nombres définis dans les variables a et b. La somme de
ces valeurs sera stockée dans la variable c.
3. Nous utilisons alors la bibliothèque q pour dénodifier (la méthode
utilisée pour convertir n'importe quelle fonction en une fonction
qui retournerait une promesse) notre fonction Ajouter ou pour
convertir notre fonction Ajouter à une fonction qui retourne une
promesse.
4. Nous appelons maintenant notre fonction "Ajouter" et sommes
en mesure d'obtenir une valeur de promesse de retour en raison
de l'étape précédente que nous avons effectuée de dénodifier la
fonction Ajouter.
5. Le mot-clé'then' est utilisé pour spécifier que si la fonction est
exécutée avec succès, alors affiche la chaîne de caractères
"Addition function completed" dans le fichier console.log.
Lorsque le code ci-dessus est exécuté, la sortie "Fonction d'addition
terminée" sera affichée dans le fichier console.log comme indiqué ci-
dessous.
Que sont les générateurs
Les générateurs sont devenus assez célèbres dans Node.js ces derniers
temps et cela probablement à cause de ce qu'ils sont capables de faire.
Les générateurs sont des exécutions de fonctions qui peuvent être

suspendues et reprises ultérieurement.
Les générateurs sont utiles lorsqu'il s'agit d'exécuter des concepts
tels que l'exécution paresseuse. Cela signifie essentiellement qu'en
suspendant l'exécution et en reprenant à volonté, nous ne pouvons
tirer des valeurs que lorsque nous en avons besoin.
Les générateurs ont les 2 méthodes clés suivantes
1. Méthode de rendement - La méthode de rendement est appelée

dans une fonction pour arrêter l'exécution de la fonction à la ligne
spécifique où la méthode de rendement est appelée.
2. Méthode suivante - Cette méthode est appelée depuis
l'application principale pour reprendre l'exécution d'une fonction
qui a une méthode de rendement. L'exécution de la fonction se
poursuivra jusqu'à la prochaine méthode de rendement ou
jusqu'à la fin de la méthode.
Examinons un exemple de la façon dont les générateurs peuvent être

utilisés.
Dans notre exemple, nous allons avoir une simple fonction Ajouter qui
ajoutera 2 nombres, mais nous continuerons à arrêter l'exécution de la
méthode à différents points pour montrer comment les générateurs
peuvent être utilisés.
function* Add(x) {
yield x + 1;
var y = yield(null);
y = 6
return x + y;
}
var gen = Add(5);
gen.next();
gen.next();
1. La première étape consiste à définir la "fonction" de notre

générateur. Notez que cela se fait en ajoutant un "*" au mot-clé de
la fonction. Nous sommes alors en train de définir une fonction
appelée Add qui prend un paramètre de x.
2. Le mot-clé yield est un mot-clé spécifique aux générateurs. Cela
en fait une construction puissante pour mettre en pause une
fonction au milieu de n'importe quoi. Ainsi ici, l'exécution de la
fonction sera arrêtée jusqu'à ce que nous invoquions la fonction
suivante(), ce qui sera fait à l'étape 4. A ce point, la valeur de x
deviendra 6 et l'exécution de la fonction sera arrêtée.
3. C'est là que nous appelons d'abord la fonction générateur et
envoyons la valeur de 5 à notre fonction Ajouter. Cette valeur sera
substituée dans le paramètre x de notre fonction Ajouter.
4. Une fois que nous appelons la fonction next(), la fonction Add()
reprendra l'exécution. Lorsque la prochaine instruction var y=
yield(null) sera exécutée, la fonction Add() arrêtera de nouveau
l'exécution.
5. Maintenant, après avoir appelé à nouveau la fonction next(), les
prochaines instructions seront exécutées, et la valeur combinée
de x=6 et y=6 sera ajoutée et retournée.
Rappels vs. générateurs
Les générateurs sont utilisés pour résoudre le problème de ce qu'on
appelle l'enfer du rappel. Parfois, les fonctions de rappel deviennent
tellement imbriquées pendant le développement d'une application
Node.js qu'il devient trop compliqué d'utiliser les fonctions de rappel.
C'est là que les générateurs sont utiles. L'un des exemples les plus
courants est la création de fonctions de minuterie.
Voyons l'exemple ci-dessous qui montre comment les générateurs

peuvent s'avérer utiles par rapport aux rappels.
Notre exemple ne fera que créer une simple fonction de temporisation.

Nous voudrions alors appeler cette fonction incorporant un retard de
1000, 2000 et 3000 ms.
Étape 1) Définir notre fonction de rappel avec le code de délai

nécessaire.
1. Ici, nous créons une fonction appelée Timedelay avec un

paramètre appelé ptime. Cela prendra le temps nécessaire que
nous voulons introduire dans notre application.
2. L'étape suivante consiste simplement à créer un message, qui sera
affiché à l'utilisateur disant que l'application va être en pause
pendant ces quelques millisecondes.
Étape 2) Regardons maintenant le code si nous incorporons les

rappels. Supposons que nous voulions incorporer des rappels basés
sur la valeur de 1000, 2000 et 3000 millisecondes, le code ci-dessous
montre comment nous devrions les mettre en œuvre en utilisant les
rappels.
Code Explication:-
1. Nous appelons le Timedelay comme un callback avec 1000
comme valeur.
2. Ensuite, nous voulons appeler à nouveau la fonction Timedelay
avec 2000 comme valeur.
3. Enfin, nous voulons appeler à nouveau la fonction Timedelay
avec 3000 comme valeur.
A partir du code ci-dessus, vous pouvez voir qu'il devient plus

désordonné car nous voulons commencer à appeler la fonction
plusieurs fois.
Etape 3) Voyons maintenant comment implémenter le même code en

utilisant des générateurs. A partir du code ci-dessous, vous pouvez
maintenant voir à quel point il est devenu simple d'implémenter la
fonction Timedelay en utilisant des générateurs.
1. Nous sommes en train de définir une fonction de générateur qui

sera utilisée pour appeler notre fonction Timedelay.
2. Nous appelons la fonction Yield avec la fonction Timedelay avec
1000 comme valeur de paramètre.
3. Nous appelons alors la fonction Yield et la fonction Timedelay
avec 2000 comme valeur de paramètre.
4. Enfin, nous appelons la fonction Yield avec la fonction Timedelay
avec 3000 comme valeur de paramètre.
Filestream dans Node.js
Node fait un usage intensif des flux comme mécanisme de transfert de
données.
Par exemple, lorsque vous sortez quelque chose vers la console en

utilisant la fonction console.log, vous utilisez en fait un flux pour
envoyer les données vers la console.
Node.js a également la capacité de diffuser en continu les données des

fichiers afin qu'elles puissent être lues et écrites de manière
appropriée. Nous allons maintenant examiner un exemple de la façon
dont nous pouvons utiliser les flux pour lire et écrire à partir de
fichiers. Pour cet exemple, nous devons suivre les étapes suivantes
Étape 1) Créez un fichier appelé data.txt qui contient les données ci-
dessous. Supposons que ce fichier soit stocké sur le lecteur D de notre
machine locale.
Tutoriel sur Node.js
Introduction
Événements
Générateurs
Connectivité des données
Utilisation du jasmin
Étape 2) Écrire le code pertinent qui utilisera les flux pour lire les
données du fichier.
var fs = require("fs");
var stream;
stream = fs.createReadStream("D://data.txt");
stream.on("data", function(data) {
var chunk = data.toString();
console.log(chunk);
});
1. Nous devons d'abord inclure les modules'fs' qui contiennent

toutes les fonctionnalités nécessaires à la création de flux.
2. Ensuite, nous créons un flux lisible en utilisant la méthode -
createReadStream. En entrée, nous indiquons l'emplacement de
notre fichier data.txt.
3. La fonction steam.on est un gestionnaire d'événements et dans
celui-ci, nous spécifions le premier paramètre comme'données'.
Cela signifie que chaque fois que des données arrivent dans le flux
à partir du fichier, alors exécutez une fonction de rappel. Dans
notre cas, nous sommes en train de définir une fonction de rappel
qui exécutera 2 étapes de base. Le premier est de convertir les
données lues à partir du fichier sous forme de chaîne de
caractères. La seconde serait d'envoyer la chaîne de caractères
convertie en sortie vers la console.
4. Nous prenons chaque morceau de données qui est lu à partir du
flux de données et le convertissons en une chaîne de caractères.
5. Enfin, nous envoyons la sortie de chaque morceau de corde
converti à la console.
Sortie :
Si le code est exécuté correctement, vous verrez la sortie ci-dessus

dans la console. Cette sortie sera la même que celle du fichier
data.txt.
Ecrire dans un fichier
De la même manière que nous créons un flux de lecture, nous pouvons

aussi créer un flux d'écriture pour écrire des données dans un fichier.
Créons d'abord un fichier vide sans contenu appelé data.txt.
Supposons que ce fichier est placé dans le lecteur D de notre
ordinateur.
Le code ci-dessous montre comment nous pouvons écrire des données

dans le fichier.
var fs = require("fs");
var stream;
stream = fs.createWriteStream("D://data.txt");
stream.write("Tutorial on Node.js")
stream.write("Introduction")
stream.write("Events")
stream.write("Generators")
stream.write("Data Connectivity")
stream.write("Using Jasmine")

1. Nous créons un flux inscriptible en utilisant la méthode
createWriteStream. En entrée, nous indiquons l'emplacement de
notre fichier data.txt.
2. Ensuite, nous avons utilisé la méthode stream.write pour écrire
les différentes lignes de texte dans notre fichier texte. Le flux se
chargera d'écrire ces données dans le fichier data.txt.
Si vous ouvrez le fichier data.txt, vous verrez maintenant les données

suivantes dans le fichier
Introduction
Événements
Générateurs
Tuyaux dans Node.js
Dans les applications Node, les flux peuvent être canalisés ensemble à
l'aide de la méthode pipe(), qui prend deux arguments :
Un flux d'écriture requis qui sert de destination pour les données et

les données.
Un objet optionnel utilisé pour passer dans les options.
Un exemple typique d'utilisation de tuyaux, si vous voulez transférer

des données d'un fichier à l'autre.
Voyons donc un exemple de la façon dont nous pouvons transférer des

données d'un fichier à l'autre à l'aide de tuyaux.
Étape 1) Créez un fichier appelé datainput.txt qui contient les

données ci-dessous. Supposons que ce fichier soit stocké sur le lecteur
D de notre machine locale.
Introduction
Événements
Générateurs
Etape 2) Créez un fichier vide vide appelé dataOutput.txt et placez-le
sur le lecteur D de votre machine locale.
Etape 3) Ecrire le code ci-dessous pour effectuer le transfert des

données du fichier datainput.txt vers le fichier dataOutput.txt.
1. Nous créons d'abord un "readstream" vers notre fichier

datainput.txt qui contient toutes nos données qui doivent être
transférées vers le nouveau fichier.
2. Nous devons ensuite créer un "writestream" vers notre fichier
dataOutput.txt, qui est notre fichier vide et qui est la destination
pour le transfert des données du fichier datainput.txt.
3. Nous utilisons ensuite la commande pipe pour transférer les
données du flux de lecture au flux d'écriture. La commande pipe
prendra toutes les données qui arrivent dans le readstream, et les
poussera vers le flux d'écriture.
Si vous ouvrez maintenant le fichier dataOutput.txt, vous verrez toutes

les données présentes dans le fichier datainput.txt.
Événements dans Node.js
Les événements sont l'un des concepts clés de Node.js et parfois
Node.js est désigné sous le nom de cadre événementiel.
Fondamentalement, un événement est quelque chose qui se produit.

Par exemple, si une connexion est établie à une base de données,
l'événement de connexion à la base de données est déclenché. La
programmation événementielle consiste à créer des fonctions qui
seront déclenchées lorsque des événements spécifiques sont
déclenchés.
Examinons un exemple de base de définition d'un événement dans

Node.js.
Nous allons créer un événement appelé'data_received'. Lorsque cet

événement est déclenché, le texte "données reçues" sera envoyé à la
console.
var events = require('events');
var eventEmitter = new events.EventEmitter();
eventEmitter.on('data_received', function() {
console.log('data received succesfully.');
});
eventEmitter.emit('data_received');
1. Utilisez la fonction require pour inclure le module'events'. Avec ce

module, vous pourrez créer des événements dans Node.js.
2. Créer un nouvel émetteur d'événements. Ceci est utilisé pour lier
l'événement, qui dans notre cas est "data_received" à une
fonction de rappel qui est définie à l'étape 3.
3. Nous définissons une fonction événementielle qui dit que si
l'événement "data_received" est déclenché, nous devons sortir le
texte "data_received" vers la console.
4. Enfin, nous avons un déclencheur manuel de notre événement à
l'aide de la fonction eventEmiter.emit. Ceci déclenchera
l'événement data_received.
Lors de l'exécution du programme, le texte "données reçues" sera

envoyé à la console comme indiqué ci-dessous.
Événements émettant
Lors de la définition d'événements, il existe différentes méthodes pour
les événements qui peuvent être invoqués. Ce sujet se concentre sur
l'examen détaillé de chacun d'entre eux.
1. Gestionnaires d'événement unique
Parfois, vous pouvez être intéressé à réagir à un événement seulement

la première fois qu'il se produit. Dans ces situations, vous pouvez
utiliser la méthode once().
Voyons comment nous pouvons utiliser la méthode once pour les

gestionnaires d'événements.
1. Ici, nous utilisons la méthode'once' pour dire que pour

l'événement'data_received,' la fonction callback ne doit être
exécutée qu'une seule fois.
2. Ici, nous déclenchons manuellement l'événement'data_received'.
3. Lorsque l'événement'data_received' est à nouveau déclenché,
cette fois-ci, rien ne se produira. C'est à cause de la première
étape où nous avons dit que l'événement ne pouvait être
déclenché qu'une seule fois.
Si le code est exécuté correctement, la sortie dans le journal

sera'data_received successfully'. Ce message n'apparaîtra qu'une seule
fois dans la console.
2. Inspecter les auditeurs de l'événement
A n'importe quel moment de sa vie, un émetteur d'événements peut

avoir zéro ou plus d'auditeurs attachés à l'émetteur d'événements. Les
auditeurs de chaque type d'événement peuvent être inspectés de
plusieurs façons.
Si vous êtes intéressé à déterminer uniquement le nombre d'auditeurs

connectés, ne cherchez pas plus loin que la méthode
EventEmitter.listenerCount().
(Note : Les auditeurs sont importants parce que l'émission principale

devrait savoir si des auditeurs sont ajoutés à la volée à un événement,
sinon l'émission fonctionnera mal parce que d'autres auditeurs seront
appelés.
1. Nous sommes en train de définir un type d'eventEmitter qui est

nécessaire pour utiliser les méthodes événementielles.
2. Nous sommes alors en train de définir un objet appelé émetteur
qui sera utilisé pour définir nos gestionnaires d'événements.
3. Nous sommes en train de créer 2 gestionnaires d'événements qui
ne font rien. Ceci est simple pour notre exemple afin de montrer
comment fonctionne la méthode listenerCount.
4. Maintenant, lorsque vous invoquez la méthode listenerCount sur
notre événement data_received, il enverra le nombre d'auditeurs
d'événements attachés à cet événement dans le journal de la
console.
Si le code est exécuté correctement, la valeur de 2 sera affichée dans le

journal de la console.
3. L'Événement newListener
Chaque fois qu'un nouveau gestionnaire d'événements est enregistré,

l'émetteur d'événements émet un événement newListener. Cet
événement est utilisé pour détecter les nouveaux gestionnaires
d'événements. Vous utilisez généralement l'événement newListener
lorsque vous avez besoin d'allouer des ressources ou d'effectuer une
action pour chaque nouveau gestionnaire d'événement.
var events = require('events');
var eventEmitter = events.EventEmitter;
var emitter = new eventEmitter();
emitter.on("newListener", function(eventName, listener) {
console.log("Added listener for " + eventName + " events");
});
emitter.on('data_received', function() {});
emitter.on('data_received', function() {});
1. Nous sommes en train de créer un nouveau gestionnaire

d'événements pour l'événement'newListener'. Ainsi, chaque fois
qu'un nouveau gestionnaire d'événement est enregistré, le texte
"Added listener for" + le nom de l'événement sera affiché dans la
console.
2. Ici, nous écrivons sur la console le texte "Added listener for" + le
nom de l'événement pour chaque événement enregistré.
3. Nous sommes en train de définir 2 gestionnaires d'événements
pour notre événement'data_received'.
Si le code ci-dessus est exécuté correctement, le texte ci-dessous sera

affiché dans la console. Il montre simplement que le gestionnaire
d'événements'newListener' a été déclenché deux fois.
Ajout d'un auditeur pour les événements data_received.
Ajout d'un auditeur pour les événements data_received.
Résumé
L'utilisation des fonctions de rappel dans Node.js a ses
inconvénients. Parfois, au cours du processus de développement,
l'utilisation imbriquée de fonctions de rappel peut rendre le code
plus désordonné et difficile à maintenir.
La plupart des problèmes avec les fonctions de rappel imbriquées
peuvent être atténués par l'utilisation de promesses et de
générateurs dans node.js.
Une Promesse est une valeur retournée par une fonction
asynchrone pour indiquer l'achèvement du traitement effectué par
la fonction asynchrone.
Les promesses peuvent être imbriquées les unes dans les autres
pour rendre le code meilleur et plus facile à maintenir lorsque de
nombreuses fonctions asynchrones doivent être appelées en même
temps.
Les générateurs peuvent également être utilisés pour atténuer les
problèmes liés aux rappels imbriqués et aider à éliminer ce que l'on
appelle l'enfer du rappel. Les générateurs sont utilisés pour arrêter
le traitement d'une fonction. Ceci est accompli par l'utilisation de la
méthode'yield' dans la fonction asynchrone.
Les flux sont utilisés dans Node.js pour lire et écrire les données
des périphériques d'entrée-sortie. Node.js utilise la bibliothèque'fs'
pour créer des flux lisibles et inscriptibles dans les fichiers. Ces flux
peuvent être utilisés pour lire et écrire des données à partir de
fichiers.
Les tuyaux peuvent être utilisés pour connecter plusieurs flux
ensemble. L'un des exemples les plus courants est de canaliser le
flux de lecture et d'écriture pour le transfert de données d'un fichier
à l'autre.
Node.js est aussi souvent étiqueté comme un cadre basé sur les
événements, et il est très facile de définir des événements dans
Node.js. Il est possible de définir des fonctions qui répondent à ces
événements.
Les événements exposent également les méthodes d'intervention
en cas d'événements clés. Par exemple, nous avons vu le
gestionnaire d'événements once() qui peut être utilisé pour
s'assurer qu'une fonction de rappel n'est exécutée qu'une seule fois
lorsqu'un événement est déclenché.
Chapitre 8 : Tester avec du
jasmin
Le test est un élément clé de toute application. Pour Node.js, le cadre

disponible pour les tests s'appelle Jasmine. Au début de l'an 2000, il
existait un cadre pour tester les applications javascript appelé JsUnit.
Plus tard, ce cadre a été mis à jour et est maintenant connu sous le
nom de jasmin.
Jasmine aide à automatiser les tests unitaires, ce qui est devenu une
pratique clé lors du développement et du déploiement d'applications
web modernes.
Dans ce tutoriel, vous apprendrez comment configurer votre

environnement avec jasmine et comment commencer à tester votre
première application Node.js avec jasmine.
Vue d'ensemble de Jasmine pour
tester les applications Node.js
Jasmine est un framework de test pour JavaScript de Behavior
Driven Development(BDD). Il ne repose pas sur les navigateurs,
les DOM ou tout autre framework JavaScript. Ainsi, il convient aux
sites Web, aux projets Node.js, ou à tout autre endroit où JavaScript
peut s'exécuter. Pour commencer à utiliser Jasmine, vous devez
d'abord télécharger et installer les modules Jasmine nécessaires.
Ensuite, vous devrez initialiser votre environnement et inspecter le

fichier de configuration de jasmine. Les étapes ci-dessous montrent
comment configurer Jasmine dans votre environnement.
Pour utiliser le framework jasmine à partir d'une application Node, le

module jasmine doit d'abord être installé. Pour installer le module
jasmine-node, exécutez la commande ci-dessous.
npm install jasmine-node
Etape 2) Initialisation du projet - En faisant cela, jasmine crée un

répertoire de spécification et de configuration json pour vous. Le
répertoire spec est utilisé pour stocker tous vos fichiers de test. En
faisant cela, jasmine saura où se trouvent tous vos tests, et pourra
ensuite les exécuter en conséquence. Le fichier JSON est utilisé pour
stocker des informations de configuration spécifiques sur jasmine.
Pour initialiser l'environnement jasmin, exécutez la commande ci-
dessous
jasmine init
Étape 3) Inspectez votre fichier de configuration. Le fichier de

configuration sera stocké dans le dossier spec/support sous le nom
jasmine.json. Ce fichier énumère les fichiers sources et les fichiers de
spécification que vous souhaitez inclure dans le runner Jasmine.
La capture d'écran ci-dessous montre un exemple typique du fichier

package.json pour jasmine.
1. Notez que le répertoire de spécifications est spécifié ici. Comme

indiqué précédemment, lorsque jasmine s'exécute, il recherche
tous les tests dans ce répertoire.
2. La prochaine chose à noter est le paramètre spec_files - Ceci
indique que les fichiers de test, quels qu'ils soient, doivent être
ajoutés avec le mot-clé'spec'.
Comment utiliser Jasmine pour
tester les applications Node.js ?
Afin d'utiliser Jasmine pour tester les applications Node.js, une série
d'étapes doit être suivie.
Dans notre exemple ci-dessous, nous allons définir un module qui

ajoute 2 nombres qui doivent être testés. Nous allons ensuite définir
un fichier de code séparé avec le code de test et ensuite utiliser jasmine
pour tester la fonction Ajouter en conséquence.
Etape 1) Définir le code à tester. Nous allons définir une fonction qui
va ajouter 2 nombres et retourner le résultat. Ce code va être écrit dans
un fichier appelé "Add.js".
exports.AddNumber=function(a,b)
{
return a+b;
};
Code Explication du code:
1. Le mot-clé "exports" est utilisé pour s'assurer que la

fonctionnalité définie dans ce fichier est effectivement accessible
par d'autres fichiers.
2. Nous sommes en train de définir une fonction
appelée'AddNumber'. Cette fonction est définie pour prendre 2
paramètres, a et b. La fonction est ajoutée au module "exports"
pour faire de la fonction une fonction publique accessible par
d'autres modules d'application.
3. Nous faisons enfin de notre fonction return la valeur ajoutée des
paramètres.
Etape 2) Ensuite nous devons définir notre code de test jasmin qui
sera utilisé pour tester notre fonction "Ajouter" dans le fichier Add.js.
Le code ci-dessous doit être mis dans un fichier appelé add-spec.js.
Note : - Le mot'spec' doit être ajouté au fichier de test pour qu'il

puisse être détecté par jasmine.
var app=require("../Add.js");
describe("Addition",function(){
it("The function should add 2 numbers",function() {
var value=app.AddNumber(5,6);
expect(value).toBe(11);
});
});
Code Explication :
1. Nous devons d'abord inclure notre fichier Add.js afin de pouvoir

tester la fonction'AddNumber' dans ce fichier.
2. Nous sommes en train de créer notre module de test. La première
partie du module de test est de décrire une méthode qui donne
fondamentalement un nom à notre test. Dans ce cas, le nom de
notre test est "Addition".
3. Le bit suivant est de donner une description de notre test en
utilisant la méthode'it'.
4. Nous invoquons maintenant notre méthode Addnumber et
envoyons 2 paramètres 5 et 6. Ceci sera transmis à notre méthode
Addnumber dans le fichier App.js. La valeur de retour est ensuite
stockée dans une variable appelée valeur.
5. L'étape finale est de faire la comparaison ou notre test réel.
Puisque nous nous attendons à ce que la valeur retournée par la
fonction Addnumber soit 11, nous définissons ceci en utilisant la
méthode expect(value).toBe(the expected value).
Sortie
1. Pour exécuter le test, il faut exécuter la commande jasmine.

2. La capture d'écran ci-dessous montre qu'après l'exécution de la
commande jasmine, il détectera qu'il y a un test appelé add-
spec.js et exécutera ce test en conséquence. S'il y a des erreurs
dans le test, il sera affiché en conséquence.
Résumé
Afin de tester une application Node.js, le framework jasmine doit

d'abord être installé. Ceci est fait en utilisant le gestionnaire de
paquets Node.
Le code de test doit être écrit dans un fichier séparé, et le mot'spec'
doit être ajouté au nom du fichier. Ce n'est que si cela est fait que
jasmine sera capable de détecter qu'un fichier doit être exécuté.
Pour exécuter le test, vous devez exécuter la commande jasmin.
Ceci trouvera tous les fichiers qui ont le mot'spec' attaché au
mot'spec' et exécutera le fichier en conséquence.
Une Dernière Chose...
VOUS AVEZ AIMÉ LE LIVRE ?

SI C'EST LE CAS, FAITES-LE MOI SAVOIR EN LAISSANT UN
COMMENTAIRE SUR AMAZON ! Les critiques sont l'âme des
auteurs indépendants. J'apprécierais même quelques mots et une
évaluation si c'est tout ce que vous avez le temps de faire.
SI VOUS N'AVEZ PAS AIMÉ CE LIVRE, ALORS DITES-LE-MOI !

EMAIL moi et dites-moi ce que vous n'avez pas aimé ! Par
phase, je peux le changer. Dans le monde d'aujourd'hui, un livre n'a
pas besoin d'être stagnant, il peut s'améliorer avec le temps et les
commentaires de lecteurs comme vous. Vous pouvez avoir un
impact sur ce livre, et je vous invite à me faire part de vos
commentaires. Aidez-nous à améliorer ce livre pour tout le monde
!

Apprenez NodeJS en 1 Jour-Complete Node JS Guide Avec Des Exemples

Hochgeladen von

Dokumentinformationen

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Apprenez NodeJS en 1 Jour-Complete Node JS Guide Avec Des Exemples

Hochgeladen von

Copyright:

Verfügbare Formate

Apprendre NodeJS en 1 jour

Par Krishna Rungta

Copyright 2018 - Tous droits réservés - Krishna Rungta

TOUS DROITS RÉSERVÉS. Aucune partie de cette publication ne

Chapitre 2: Télécharger et installer Node.js

Chapitre 4: Créer un serveur et obtenir des données

Chapitre 5: Node.js avec Express

Chapitre 6: Node.js avec MongoDB

Chapitre 7: Promesse, Générateur, Événement et

Chapitre 8: Test avec Jasmin

L'application web moderne a vraiment parcouru un long chemin au fil

Mais lorsqu'il s'agissait de développer des applications basées sur

Node.js est également basé sur le framework JavaScript, mais il est

Node.js est basé sur une architecture événementielle et une API

Sur une longue période de temps, le cadre disponible pour le

Beaucoup de travail a dû être fait pour maintenir l'information de

Mais avec les applications web de Node.js, vous pouvez maintenant

1. L'E/S asynchrone pilotée par événement aide au traitement

C'est très différent des autres langages de programmation. Un exemple

L'extrait de code ci-dessus se penche sur la lecture d'un fichier

2. Node utilise le moteur d'exécution JavaScript V8, celui qui est

Qui utilise Node.js ?

Le meilleur de tous, puisque Node.js est construit sur javascript, c'est

Quand ne pas utiliser Node.js

Node.js peut être utilisé pour un grand nombre d'applications à des

Le nœud est structuré pour être à filetage simple. Si une application

Pour commencer à construire vos applications Node.js, la première

Node.js a également la possibilité d'intégrer des fonctionnalités

Etape 1) Allez sur le site https://nodejs.org/en/download/ et

Étape 2) Double-cliquez sur le fichier.msi téléchargé pour démarrer

Etape 4) Dans l'écran suivant Accepter le contrat de licence et cliquer

1. Entrez d'abord l'emplacement du fichier pour l'installation de

Étape 7) Dans l'écran suivant, cliquez sur le bouton Installer pour

Sur Windows, le gestionnaire de paquets de nœuds est connu sous le

Étape 1) Installation de Chocolatey - Le site Web de Chocolatey

La première étape consiste à exécuter la commande ci-dessous

@powershell -NoProfile -ExecutionPolicy Bypass -Command "iex

Etape 2) L'étape suivante est d'installer Node.js sur votre machine

cinst nodejs install

Note : Si vous obtenez une erreur comme

Créer le fichier Node.js avec le nom de fichier firstprogram.js

http.createServer(function (req, res) {

1. La fonctionnalité de base de la fonction "require" est qu'elle lit un

3. Lorsqu'une demande est reçue, nous demandons à notre fonction de

Étape 2) Dans l'invite de commande, naviguez jusqu'au dossier dans

Étape 3) Maintenant, votre ordinateur fonctionne comme un serveur

Etape 4) Démarrez votre navigateur Internet, et tapez l'adresse :

Nous avons vu l'installation de Node.js via le module d'installation

Un module dans Node.js est une encapsulation logique de code dans

Comme chaque module est une entité indépendante avec sa propre

Au cours de ce tutoriel, nous verrons comment nous pouvons utiliser

1. Express framework - Express est un cadre d'application web

La ligne de commande ci-dessous montre comment un module

npm install express

La commande ci-dessus téléchargera les fichiers nécessaires qui

1. Dans la première déclaration elle-même, nous utilisons le mot-clé

Examinons un exemple simple de la façon dont nous pouvons créer

Étape 1) Créer un fichier appelé "Addition.js" et inclure le code ci-

Ci-dessous se trouve le code qui irait dans ce fichier ;

1. Le mot-clé "exports" est utilisé pour s'assurer que la

Maintenant que nous avons créé notre module personnalisé qui a la

Dans la prochaine étape, nous verrons comment créer l'application

Etape 2) Créez un fichier appelé "app.js", qui est votre fichier

1. Nous utilisons le mot-clé "require" pour inclure la fonctionnalité