Nodejs: Les Modules

Un module est fichier js contenant un ensemble de fonctions et objets qui peuvent être importer et utiliser dans un projet NodeJs.

Dans NodeJs existe deux types de modules :

Module interne:créer dans le projet

module externe:importer de l'extérieur principalement ( CommonJS modules standard)


Exemple de modules externes

  1. 1http :créer et gérer le serveur http
  2. 2url: parse et gérer les url
  3. 3fs :file system gère les I/O et le système du fichiers
  4. 4util :un ensemble de fonctions utilitaires
  5. 5mysql :Gestion des transaction dans la base de données
Exemples
Express.js Modules:
express: Le module principal d'Express.js, utilisé pour créer des applications web.

const express = require('express');
const app = express();

app.get('/', (req, res) => {
  res.send('Bonjour, Express.js!');
});

app.listen(3000, () => {
  console.log('Serveur en cours d\'exécution sur http://localhost:3000');
});
body-parser
body-parser: Middleware pour traiter les données du corps des requêtes HTTP.

const express = require('express');
const bodyParser = require('body-parser');

const app = express();

app.use(bodyParser.urlencoded({ extended: true }));

app.post('/submit', (req, res) => {
  const formData = req.body;
  res.json(formData);
});

app.listen(3000, () => {
  console.log('Serveur en cours d\'exécution sur http://localhost:3000');
});
morgan
morgan: Middleware de journalisation des requêtes HTTP.

const express = require('express');
const morgan = require('morgan');

const app = express();

app.use(morgan('dev'));

app.get('/', (req, res) => {
  res.send('Page d\'accueil');
});

app.listen(3000, () => {
  console.log('Serveur en cours d\'exécution sur http://localhost:3000');
});
path
path: Module pour manipuler les chemins de fichiers.

const path = require('path');

const filePath = '/chemin/vers/mon/fichier.txt';
const fileName = path.basename(filePath);

console.log(`Nom du fichier: ${fileName}`);
http
http: Module pour créer un serveur HTTP.

const http = require('http');

const server = http.createServer((req, res) => {
  res.writeHead(200, { 'Content-Type': 'text/plain' });
  res.end('Bonjour, serveur HTTP!');
});

server.listen(3000, '127.0.0.1', () => {
  console.log('Serveur en cours d\'exécution sur http://127.0.0.1:3000/');
});
fs
fs: Module pour effectuer des opérations de fichier système.

const fs = require('fs');

fs.readFile('monFichier.txt', 'utf8', (err, data) => {
  if (err) {
    console.error(err);
    return;
  }
  console.log(data);
});
events
events: Module pour émettre et écouter des événements.

const EventEmitter = require('events');

class MonEmitter extends EventEmitter {}

const monEmitter = new MonEmitter();

monEmitter.on('evenement', () => {
  console.log('Événement déclenché!');
});

monEmitter.emit('evenement');
util
util : Module pour des utilitaires généraux.

const util = require('util');

const promiseFunction = util.promisify(someCallbackFunction);

promiseFunction()
  .then(result => console.log(result))
  .catch(error => console.error(error));
crypto
crypto : Module pour effectuer des opérations de cryptographie.

const crypto = require('crypto');

const hash = crypto.createHash('sha256');
hash.update('Hello, crypto!');
const hashedValue = hash.digest('hex');

console.log(`Valeur hashée: ${hashedValue}`);
events
os : Module pour accéder à des fonctionnalités liées au système d'exploitation.

const os = require('os');

console.log(`Nom de l'hôte: ${os.hostname()}`);
console.log(`Type de système d'exploitation: ${os.type()}`);
cookie-parser
Modules Express.js :
cookie-parser : Middleware pour analyser les cookies dans les requêtes.

const express = require('express');
const cookieParser = require('cookie-parser');

const app = express();
app.use(cookieParser());

app.get('/', (req, res) => {
  res.send(`Vos cookies: ${JSON.stringify(req.cookies)}`);
});

app.listen(3000, () => {
  console.log('Serveur en cours d\'exécution sur http://localhost:3000');
});
cors
cors : Middleware pour gérer les requêtes CORS (Cross-Origin Resource Sharing).

const express = require('express');
const cors = require('cors');

const app = express();
app.use(cors());

app.get('/api/data', (req, res) => {
  res.json({ message: 'Données de l\'API' });
});

app.listen(3000, () => {
  console.log('Serveur en cours d\'exécution sur http://localhost:3000');
});
mongoose
mongoose : Module pour interagir avec MongoDB.

const mongoose = require('mongoose');

mongoose.connect('mongodb://localhost/maBaseDeDonnees', { useNewUrlParser: true, useUnifiedTopology: true });

const Schema = mongoose.Schema;
const monSchema = new Schema({
  nom: String,
  age: Number
});

const MonModele = mongoose.model('MonModele', monSchema);

const nouvelObjet = new MonModele({ nom: 'John', age: 30 });

nouvelObjet.save((err, objetEnregistre) => {
  if (err) return console.error(err);
  console.log('Objet enregistré:', objetEnregistre);
});
jsonwebtoken
jsonwebtoken : Module pour la création et la vérification des jetons d'authentification.

const express = require('express');
const jwt = require('jsonwebtoken');

const app = express();

app.get('/login', (req, res) => {
  // Simulation d'une authentification réussie
  const utilisateur = { id: 1, nom: 'JohnDoe' };

  // Création du jeton d'authentification
  const token = jwt.sign({ utilisateur }, 'cléSecrète');

  res.json({ token });
});

app.get('/protected', (req, res) => {
  // Vérification du jeton d'authentification
  const token = req.headers.authorization.split(' ')[1];
  jwt.verify(token, 'cléSecrète', (err, decoded) => {
    if (err) return res.sendStatus(403);

    res.json({ message: 'Ressource protégée', utilisateur: decoded.utilisateur });
  });
});

app.listen(3000, () => {
  console.log('Serveur en cours d\'exécution sur http://localhost:3000');
});
passport
passport : Middleware pour l'authentification dans Express.js.
Exemple (utilisation avec passport-local) :

const express = require('express');
const passport = require('passport');
const LocalStrategy = require('passport-local').Strategy;

const app = express();

app.use(express.urlencoded({ extended: true }));
app.use(require('express-session')({ secret: 'cléSecrète', resave: true, saveUninitialized: true }));

app.use(passport.initialize());
app.use(passport.session());

passport.use(new LocalStrategy((username, password, done) => {
  // Logique d'authentification ici
  if (username === 'john' && password === 'doe') {
    return done(null, { id: 1, username: 'john' });
  } else {
    return done(null, false, { message: 'Identifiants incorrects' });
  }
}));

passport.serializeUser((utilisateur, done) => {
  done(null, utilisateur.id);
});

passport.deserializeUser((id, done) => {
  // Recherche de l'utilisateur dans la base de données par exemple
  const utilisateur = { id: 1, username: 'john' };
  done(null, utilisateur);
});

app.post('/login', passport.authenticate('local', {
  successRedirect: '/accueil',
  failureRedirect: '/login',
  failureFlash: true
}));

app.get('/accueil', (req, res) => {
  res.send(`Bienvenue, ${req.user.username}!`);
});

app.listen(3000, () => {
  console.log('Serveur en cours d\'exécution sur http://localhost:3000');
});
socket.io
socket.io : Module pour la communication en temps réel entre le serveur et le client.

const express = require('express');
const http = require('http');
const socketIO = require('socket.io');

const app = express();
const server = http.createServer(app);
const io = socketIO(server);

io.on('connection', (socket) => {
  console.log('Nouvelle connexion socket!');

  socket.on('message', (data) => {
    console.log('Message reçu:', data);
    io.emit('message', data); // Diffuse le message à tous les clients connectés
  });

  socket.on('disconnect', () => {
    console.log('Connexion socket fermée');
  });
});

app.get('/', (req, res) => {
  res.sendFile(__dirname + '/index.html');
});

server.listen(3000, () => {
  console.log('Serveur en cours d\'exécution sur http://localhost:3000');
});
helmet
helmet : Middleware pour améliorer la sécurité en ajoutant divers en-têtes HTTP.

const express = require('express');
const helmet = require('helmet');

const app = express();

app.use(helmet());

app.get('/', (req, res) => {
  res.send('Bienvenue sur une page sécurisée!');
});

app.listen(3000, () => {
  console.log('Serveur en cours d\'exécution sur http://localhost:3000');
});

Exemple d'un module interne (locale)
module personnalisé peut être une excellente façon d'organiser votre code de manière modulaire.
créer un module qui gère des opérations mathématiques de base.
1. Création du module operationsMathematiques.js :

// operationsMathematiques.js

// Définition du module avec une fonction pour ajouter deux nombres
module.exports = {
  // Fonction pour additionner deux nombres
  addition: function(a, b) {
    return a + b;
  },

  // Fonction pour soustraire deux nombres
  soustraction: function(a, b) {
    return a - b;
  },

  // Fonction pour multiplier deux nombres
  multiplication: function(a, b) {
    return a * b;
  },

  // Fonction pour diviser deux nombres
  division: function(a, b) {
    // Vérification pour éviter la division par zéro
    if (b !== 0) {
      return a / b;
    } else {
      throw new Error('Division par zéro non autorisée');
    }
  }
};
2. Utilisation du module dans un fichier principal app.js :

// app.js

// Import du module personnalisé
const operationsMathematiques = require('./operationsMathematiques');

// Utilisation des fonctions du module
const resultatAddition = operationsMathematiques.addition(5, 3);
console.log('Résultat de l\'addition:', resultatAddition);

const resultatSoustraction = operationsMathematiques.soustraction(10, 4);
console.log('Résultat de la soustraction:', resultatSoustraction);

const resultatMultiplication = operationsMathematiques.multiplication(2, 6);
console.log('Résultat de la multiplication:', resultatMultiplication);

try {
  const resultatDivision = operationsMathematiques.division(8, 2);
  console.log('Résultat de la division:', resultatDivision);
} catch (erreur) {
  console.error('Erreur:', erreur.message);
}
Exemple2
1. Module listeTaches.js :

// listeTaches.js

let taches = [];

function ajouterTache(nouvelleTache) {
  taches.push(nouvelleTache);
}

function obtenirListeTaches() {
  return taches;
}

module.exports = {
  ajouterTache,
  obtenirListeTaches
};
2. Fichier principal app.js avec Express.js :

// app.js

const express = require('express');
const listeTaches = require('./listeTaches');

const app = express();
const port = 3000;

// Ajout de quelques tâches à la liste
listeTaches.ajouterTache('Faire les courses');
listeTaches.ajouterTache('Répondre aux e-mails');
listeTaches.ajouterTache('Exercice physique');

// Route pour obtenir la liste des tâches
app.get('/taches', (req, res) => {
  const taches = listeTaches.obtenirListeTaches();
  res.json({ taches });
});

// Démarrage du serveur Express
app.listen(port, () => {
  console.log(`Serveur en cours d'exécution sur http://localhost:${port}`);
});
Exemple3
création d'articles, la récupération de la liste des articles, et la récupération d'un article spécifique. 1. Module gestionArticles.js :

// gestionArticles.js

let articles = [];

function creerArticle(titre, contenu) {
  const nouvelArticle = {
    id: articles.length + 1,
    titre,
    contenu,
    dateCreation: new Date().toLocaleString()
  };
  articles.push(nouvelArticle);
  return nouvelArticle;
}

function obtenirListeArticles() {
  return articles;
}

function obtenirArticleParId(articleId) {
  return articles.find(article => article.id === articleId);
}

module.exports = {
  creerArticle,
  obtenirListeArticles,
  obtenirArticleParId
};
2. Fichier principal app.js avec Express.js :

// app.js

const express = require('express');
const gestionArticles = require('./gestionArticles');

const app = express();
const port = 3000;

// Middleware pour permettre la lecture du corps des requêtes au format JSON
app.use(express.json());

// Route pour créer un nouvel article
app.post('/articles', (req, res) => {
  const { titre, contenu } = req.body;
  const nouvelArticle = gestionArticles.creerArticle(titre, contenu);
  res.status(201).json({ message: 'Article créé avec succès', article: nouvelArticle });
});

// Route pour obtenir la liste des articles
app.get('/articles', (req, res) => {
  const listeArticles = gestionArticles.obtenirListeArticles();
  res.json({ articles: listeArticles });
});

// Route pour obtenir un article spécifique par son ID
app.get('/articles/:id', (req, res) => {
  const articleId = parseInt(req.params.id);
  const article = gestionArticles.obtenirArticleParId(articleId);
  if (article) {
    res.json({ article });
  } else {
    res.status(404).json({ message: 'Article non trouvé' });
  }
});

// Démarrage du serveur Express
app.listen(port, () => {
  console.log(`Serveur en cours d'exécution sur http://localhost:${port}`);
});
Hello.js
/*Création d'un objet vide*/
var Hello={};
/*Ajouter des fonctions à l'objet Hello*/
Hello.fr = function () {
return "Bonjour tout le monde";
};

Hello.en = function () {
return "Hello World";
};

Hello.es = function () {
return "Holla";
};
/*Exporter le module pour rendre les fonctions accéssible de l'extérieur*/
module.exports = Hello
Créer le serveur TestModule.js pour utiliser le module Hello.js
var http = require("http");
/*importer le module Hello*/
var hello = require('./Hello.js');
http.createServer(function (request, response) {
var message="";
/*Appler la fonction fr du module Hello*/
if (request.url == '/fr') {
message=hello.fr();
}

else if (request.url == '/es') {
message=hello.es();
}

else{
message=hello.en();
}


/*Afficher le contenu en Format Text*/
response.writeHead(200, {'Content-Type': 'text/plain'});
response.end(message);

}).listen(8081);








Cours et TPs