Node.js : le guide complet pour développeurs Back-end

Qu'est-ce que Node.js ?

Node.js est un environnement d'exécution JavaScript côté serveur, construit sur le moteur V8 de Google Chrome. Il permet d'exécuter du code JavaScript en dehors du navigateur, directement sur votre serveur ou machine locale.

Créé en 2009 par Ryan Dahl, Node.js révolutionne le développement back-end en permettant aux développeurs JavaScript de créer des applications serveur complètes avec un seul langage : JavaScript.

Pourquoi utiliser Node.js ?

Node.js offre plusieurs avantages majeurs qui en font un choix populaire pour le développement back-end :

• JavaScript partout : Utilisez le même langage côté client et serveur
• Performance élevée : Architecture non-bloquante et asynchrone
• Écosystème riche : NPM propose plus de 2 millions de packages
• Scalabilité : Idéal pour les applications temps réel et microservices
• Communauté active : Support constant et mises à jour régulières

Installation de Node.js

Il existe plusieurs méthodes pour installer Node.js sur votre machine :

1. Installation via le site officiel

Téléchargez l'installateur depuis nodejs.org. Deux versions sont disponibles :

• LTS (Long Term Support) : Recommandée pour la production
• Current : Version avec les dernières fonctionnalités

2. Installation via NVM (recommandé)

NVM (Node Version Manager) permet de gérer plusieurs versions de Node.js sur une même machine :

# Installation de NVM (Linux/Mac)
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.0/install.sh | bash

# Installation de Node.js LTS
nvm install --lts

# Vérifier la version installée
node --version
npm --version

Créer votre premier serveur HTTP

Voici un exemple minimal d'un serveur HTTP en Node.js :

// server.js
const http = require('http');

const hostname = '127.0.0.1';
const port = 3000;

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

server.listen(port, hostname, () => {
  console.log(`Serveur en écoute sur http://${hostname}:${port}/`);
});

Pour lancer ce serveur :

# Exécutez le fichier
node server.js

# Ouvrez votre navigateur à http://127.0.0.1:3000
# Vous verrez : "Bonjour depuis Node.js !"

Serveur avec routing basique

const http = require('http');
const url = require('url');

const server = http.createServer((req, res) => {
  const parsedUrl = url.parse(req.url, true);
  const pathname = parsedUrl.pathname;

  res.setHeader('Content-Type', 'application/json; charset=utf-8');

  if (pathname === '/') {
    res.statusCode = 200;
    res.end(JSON.stringify({ message: 'Accueil' }));
  } else if (pathname === '/about') {
    res.statusCode = 200;
    res.end(JSON.stringify({ message: 'À propos' }));
  } else {
    res.statusCode = 404;
    res.end(JSON.stringify({ error: 'Page non trouvée' }));
  }
});

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

Modules et NPM

NPM (Node Package Manager) est le gestionnaire de packages par défaut de Node.js. Il vous permet d'installer, gérer et partager des bibliothèques JavaScript.

Initialiser un projet Node.js

# Créer un nouveau projet
mkdir mon-projet-nodejs
cd mon-projet-nodejs

# Initialiser package.json
npm init -y

# Installer une dépendance (exemple : Express)
npm install express

# Installer une dépendance de développement
npm install --save-dev nodemon

Structure du package.json

{
  "name": "mon-projet-nodejs",
  "version": "1.0.0",
  "description": "Mon premier projet Node.js",
  "main": "index.js",
  "scripts": {
    "start": "node index.js",
    "dev": "nodemon index.js"
  },
  "dependencies": {
    "express": "^4.18.2"
  },
  "devDependencies": {
    "nodemon": "^3.0.1"
  }
}

Créer vos propres modules

// utils.js (module personnalisé)
function addition(a, b) {
  return a + b;
}

function multiplication(a, b) {
  return a * b;
}

module.exports = { addition, multiplication };

// index.js (fichier principal)
const { addition, multiplication } = require('./utils');

console.log(addition(5, 3));        // 8
console.log(multiplication(5, 3));  // 15

Architecture événementielle

Node.js utilise une architecture non-bloquante et asynchrone basée sur une boucle d'événements (Event Loop). Cette approche permet de traiter des milliers de connexions simultanées sans créer de threads supplémentaires.

Exemple de code synchrone (bloquant)

const fs = require('fs');

// Lecture synchrone - bloque l'exécution
const data = fs.readFileSync('fichier.txt', 'utf8');
console.log(data);
console.log('Fin du programme');

Exemple de code asynchrone (non-bloquant)

const fs = require('fs');

// Lecture asynchrone - ne bloque pas
fs.readFile('fichier.txt', 'utf8', (err, data) => {
  if (err) {
    console.error('Erreur de lecture :', err);
    return;
  }
  console.log(data);
});

console.log('Fin du programme');
// "Fin du programme" s'affiche AVANT le contenu du fichier

Utilisation des Promises

const fs = require('fs').promises;

// Avec Promises
fs.readFile('fichier.txt', 'utf8')
  .then(data => {
    console.log(data);
  })
  .catch(err => {
    console.error('Erreur :', err);
  });

// Avec async/await (syntaxe moderne)
async function lireFichier() {
  try {
    const data = await fs.readFile('fichier.txt', 'utf8');
    console.log(data);
  } catch (err) {
    console.error('Erreur :', err);
  }
}

lireFichier();

Bonnes pratiques

• Gestion des erreurs : Toujours gérer les erreurs dans les callbacks et promises
• Variables d'environnement : Utilisez dotenv pour stocker les secrets
• Sécurité : Installez helmet pour sécuriser vos applications Express
• Logging : Utilisez winston ou pino pour les logs structurés
• Tests : Intégrez Jest ou Mocha pour les tests unitaires
• Linting : Configurez ESLint pour maintenir la qualité du code
• Process manager : Utilisez PM2 pour la production (voir l'article dédié)

Exemple de gestion d'erreur robuste

// Mauvaise pratique
app.get('/users/:id', (req, res) => {
  const user = getUser(req.params.id); // Peut planter
  res.json(user);
});

// Bonne pratique
app.get('/users/:id', async (req, res, next) => {
  try {
    const user = await getUser(req.params.id);
    if (!user) {
      return res.status(404).json({ error: 'Utilisateur introuvable' });
    }
    res.json(user);
  } catch (error) {
    next(error); // Passe l'erreur au middleware de gestion d'erreurs
  }
});

Configuration avec dotenv

// Installation
npm install dotenv

// .env (ne jamais committer ce fichier)
PORT=3000
DB_HOST=localhost
DB_USER=admin
DB_PASS=secret123

// server.js
require('dotenv').config();

const port = process.env.PORT || 3000;
const dbHost = process.env.DB_HOST;

console.log(`Serveur démarré sur le port ${port}`);

Conclusion

Node.js est un outil puissant et polyvalent pour le développement back-end. Sa performance, son écosystème riche et sa facilité d'utilisation en font un choix de premier ordre pour créer des applications web modernes, des APIs REST, des microservices et des outils en ligne de commande.

Pour aller plus loin, consultez notre article sur PM2 pour apprendre à déployer vos applications Node.js en production de manière professionnelle.