Node.js

Le runtime JavaScript événementiel qui a révolutionné le développement côté serveur en offrant une approche asynchrone et non-bloquante.

Retour aux compétences Documentation officielle

Pour les non-initiés

Qu'est-ce que Node.js ?

Imaginez que JavaScript, le langage de programmation qui anime les sites web dans votre navigateur, puisse également être utilisé pour créer les serveurs qui alimentent ces sites. C'est exactement ce que permet Node.js.

Créé en 2009, Node.js a révolutionné le développement web en permettant aux développeurs d'utiliser le même langage (JavaScript) à la fois pour le frontend (l'interface que vous voyez) et le backend (le serveur invisible qui traite les données).

Pourquoi Node.js est si spécial ?

Rapidité

Node.js est conçu pour être extrêmement rapide et peut gérer de nombreuses connexions simultanées avec peu de ressources.

Écosystème

Avec npm (Node Package Manager), les développeurs ont accès à la plus grande bibliothèque de logiciels open-source au monde.

En résumé, Node.js est la technologie qui a rendu possible la création d'applications web modernes comme Netflix, LinkedIn, PayPal ou Uber, en offrant la rapidité et la flexibilité nécessaires pour traiter des millions d'utilisateurs simultanément.

Pour les développeurs

Fonctionnement technique

Node.js est un environnement d'exécution JavaScript construit sur le moteur V8 de Chrome. Il utilise un modèle événementiel, non-bloquant et asynchrone qui le rend léger et efficace, parfait pour les applications intensives en données qui s'exécutent sur des appareils distribués.

Les concepts fondamentaux

Serveur HTTP simple

Node.js permet de créer facilement des serveurs web sans framework externe, bien que la plupart des développeurs utilisent des frameworks comme Express pour simplifier le développement.

Serveur HTTP avec Node.js

// Un serveur HTTP simple avec Node.js
const http = require('http');

const server = http.createServer((req, res) => {
  res.statusCode = 200;
  res.setHeader('Content-Type', 'text/plain');
  res.end('Bonjour depuis Node.js!');
});

const PORT = process.env.PORT || 3000;
server.listen(PORT, () => {
  console.log(`Serveur démarré sur le port ${PORT}`);
});

API REST avec Express

Express.js est le framework le plus populaire pour Node.js, permettant de créer rapidement des API REST robustes et des applications web.

API REST avec Express.js

// API REST avec Express.js
const express = require('express');
const app = express();

// Middleware pour parser le JSON
app.use(express.json());

// Base de données simulée
const users = [
  { id: 1, name: 'Marie Dupont', email: 'marie@example.com' },
  { id: 2, name: 'Jean Martin', email: 'jean@example.com' }
];

// Route pour obtenir tous les utilisateurs
app.get('/api/users', (req, res) => {
  res.json(users);
});

// Route pour obtenir un utilisateur spécifique
app.get('/api/users/:id', (req, res) => {
  const user = users.find(u => u.id === parseInt(req.params.id));
  
  if (!user) {
    return res.status(404).json({ error: 'Utilisateur non trouvé' });
  }
  
  res.json(user);
});

// Route pour créer un nouvel utilisateur
app.post('/api/users', (req, res) => {
  const newUser = {
    id: users.length + 1,
    name: req.body.name,
    email: req.body.email
  };
  
  users.push(newUser);
  res.status(201).json(newUser);
});

app.listen(3000, () => {
  console.log('API démarrée sur le port 3000');
});

Programmation asynchrone

La gestion asynchrone est au cœur de Node.js, permettant de traiter des opérations longues sans bloquer l'exécution du programme.

Asynchrone avec Promises et async/await

// Exemple d'opérations asynchrones avec Promises et async/await
const fs = require('fs').promises;

// Fonction qui lit un fichier de manière asynchrone
async function readConfigFile(path) {
  try {
    console.log(`Lecture du fichier ${path}...`);
    const data = await fs.readFile(path, 'utf8');
    return JSON.parse(data);
  } catch (error) {
    console.error('Erreur lors de la lecture du fichier:', error.message);
    throw error;
  }
}

// Fonction qui utilise la configuration pour une opération
async function initializeApp() {
  try {
    const config = await readConfigFile('./config.json');
    console.log('Configuration chargée:', config);
    
    if (config.databaseUrl) {
      // Simulation de connexion à la base de données
      await connectToDatabase(config.databaseUrl);
      console.log('Connexion à la base de données établie');
    }
    
    return { status: 'success', config };
  } catch (error) {
    console.error('Initialisation échouée:', error);
    return { status: 'error', error: error.message };
  }
}

// Fonction simulée de connexion à une base de données
function connectToDatabase(url) {
  return new Promise((resolve, reject) => {
    // Simulation d'une opération asynchrone
    setTimeout(() => {
      console.log(`Tentative de connexion à ${url}`);
      
      if (url.includes('localhost')) {
        resolve({ connected: true });
      } else {
        reject(new Error('Impossible de se connecter à la base de données'));
      }
    }, 1000);
  });
}

// Utilisation des fonctions
initializeApp()
  .then(result => {
    console.log('Application initialisée avec succès:', result);
  })
  .catch(error => {
    console.error('Erreur globale:', error);
    process.exit(1);
  });

Streams et traitement de fichiers

Les streams sont une fonctionnalité puissante de Node.js qui permet de traiter efficacement de grandes quantités de données.

Traitement de fichiers avec streams

// Exemple d'utilisation des streams pour traiter de grands fichiers
const fs = require('fs');
const path = require('path');
const zlib = require('zlib');

// Chemin des fichiers d'entrée et de sortie
const inputFile = path.join(__dirname, 'fichier-volumineux.log');
const outputFile = path.join(__dirname, 'fichier-traité.log.gz');

// Création des streams
const readStream = fs.createReadStream(inputFile, { encoding: 'utf8' });
const gzipStream = zlib.createGzip();
const writeStream = fs.createWriteStream(outputFile);

// Gestion des événements
readStream.on('error', (error) => {
  console.error('Erreur de lecture:', error);
});

writeStream.on('error', (error) => {
  console.error('Erreur d'écriture:', error);
});

writeStream.on('finish', () => {
  console.log(`Traitement terminé. Fichier compressé créé: ${outputFile}`);
});

// Traitement du flux de données ligne par ligne
let lineCount = 0;
let totalBytes = 0;

// Création d'un Transform stream pour traiter les données
const { Transform } = require('stream');
const lineProcessor = new Transform({
  transform(chunk, encoding, callback) {
    const data = chunk.toString();
    
    // Compter les lignes
    const lines = data.split('\n');
    lineCount += lines.length - 1;
    
    // Compter les octets
    totalBytes += Buffer.byteLength(data);
    
    // Modification des données (exemple: convertir en majuscules)
    const processed = data.toUpperCase();
    
    // Passer les données modifiées au prochain stream
    callback(null, processed);
  }
});

// Chaînage des streams
readStream
  .pipe(lineProcessor)
  .pipe(gzipStream)
  .pipe(writeStream);

// Rapport une fois terminé
writeStream.on('finish', () => {
  console.log(`Statistiques:
  - Lignes traitées: ${lineCount}
  - Octets traités: ${totalBytes} bytes
  - Taille du fichier compressé: ${fs.statSync(outputFile).size} bytes
  - Taux de compression: ${((1 - fs.statSync(outputFile).size / totalBytes) * 100).toFixed(2)}%`);
});

Avantages techniques

Performance non-bloquante grâce à la boucle d'événements (event loop) qui permet de gérer de nombreuses connexions simultanées
Npm (Node Package Manager) offre plus d'un million de packages réutilisables
Même langage pour le frontend et le backend, facilitant le développement full-stack
Écosystème mature avec des solutions pour presque tous les cas d'usage
Support TypeScript pour un développement plus robuste avec vérification de types

Frameworks populaires

Express.js - Le framework web minimaliste le plus populaire pour Node.js
Nest.js - Framework progressif inspiré d'Angular pour construire des applications côté serveur efficaces et évolutives
Fastify - Framework web focalisé sur les performances et la faible surcharge
Koa.js - Conçu par l'équipe d'Express, plus léger et avec un meilleur support des fonctionnalités modernes de JavaScript
Hapi.js - Framework robuste pour construire des API et services

Applications concrètes

Cas d'usage

Applications temps réel

Idéal pour les chats, jeux en ligne, tableaux de bord en direct et outils collaboratifs grâce à sa nature événementielle.

APIs et microservices

Excellent pour construire des API RESTful et GraphQL performantes et des architectures de microservices évolutives.

Outils de ligne de commande

Facilite la création d'outils CLI performants avec des packages comme Commander, Inquirer et Chalk.

Streaming et traitement de données

Parfait pour les applications nécessitant le traitement de grandes quantités de données ou des transformations en streaming.

Entreprises qui utilisent Node.js

De nombreuses entreprises de premier plan utilisent Node.js dans leur stack technologique:

Netflix

PayPal

Uber

NASA

Walmart

Trello

Medium

Ressources complémentaires

Toutes les compétences

Technologies associées

Node.js

Qu'est-ce que Node.js ?

Pourquoi Node.js est si spécial ?

Rapidité

Écosystème

Fonctionnement technique

Les concepts fondamentaux

Serveur HTTP simple

API REST avec Express

Programmation asynchrone

Streams et traitement de fichiers

Avantages techniques

Frameworks populaires

Cas d'usage

Applications temps réel

APIs et microservices

Outils de ligne de commande

Streaming et traitement de données

Entreprises qui utilisent Node.js

Ressources complémentaires

Documentation officielle

Express.js

npm

Technologies associées

React

Jest

Webpack

ESLint

Prettier

Next.js

GitHub Actions

TypeScript

ExpressJs