Introduction à Node.js : Guide Complet pour Débutants

Node.js a révolutionné le développement web en permettant d'utiliser JavaScript côté serveur. Créé en 2009, il est devenu incontournable pour le développement backend moderne. Ce guide vous accompagne dans vos premiers pas.

Qu'est-ce que Node.js ?

Node.js est un environnement d'exécution JavaScript construit sur le moteur V8 de Chrome. Il permet d'exécuter du JavaScript en dehors du navigateur, ouvrant la voie au développement backend, aux scripts système et aux applications en temps réel.

Caractéristiques principales

Non-bloquant : Architecture événementielle asynchrone
Rapide : Propulsé par le moteur V8 de Google
NPM : Le plus grand écosystème de packages au monde
JavaScript partout : Même langage frontend et backend

Installation

Via le site officiel

Téléchargez la version LTS depuis nodejs.org pour plus de stabilité.

Via NVM (recommandé)

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

# Installer Node.js
nvm install --lts
nvm use --lts

# Vérifier l'installation
node --version
npm --version

Premier programme

Créez un fichier hello.js :

console.log('Bonjour depuis Node.js !');

// Accès aux informations système
console.log('Version Node:', process.version);
console.log('Plateforme:', process.platform);
console.log('Répertoire courant:', process.cwd());

Exécutez-le :

node hello.js

Le système de modules

CommonJS (traditionnel)

// math.js - Export
function addition(a, b) {
  return a + b;
}

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

module.exports = { addition, multiplication };

// app.js - Import
const { addition, multiplication } = require('./math');
console.log(addition(2, 3)); // 5

ES Modules (moderne)

// math.mjs ou avec "type": "module" dans package.json
export function addition(a, b) {
  return a + b;
}

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

// app.mjs
import multiplication, { addition } from './math.mjs';

Les modules natifs essentiels

fs - Système de fichiers

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

// Lecture synchrone (bloquante)
const contenu = fs.readFileSync('fichier.txt', 'utf8');

// Lecture asynchrone avec callback
fs.readFile('fichier.txt', 'utf8', (err, data) => {
  if (err) throw err;
  console.log(data);
});

// Lecture avec Promises (recommandé)
async function lireFichier() {
  try {
    const data = await fsPromises.readFile('fichier.txt', 'utf8');
    console.log(data);
  } catch (err) {
    console.error('Erreur:', err);
  }
}

// Écriture
await fsPromises.writeFile('sortie.txt', 'Contenu à écrire');

path - Chemins de fichiers

const path = require('path');

// Joindre des chemins (portable)
const chemin = path.join(__dirname, 'dossier', 'fichier.txt');

// Informations sur un chemin
console.log(path.basename('/chemin/vers/fichier.txt')); // fichier.txt
console.log(path.dirname('/chemin/vers/fichier.txt'));  // /chemin/vers
console.log(path.extname('fichier.txt'));               // .txt

// Résoudre un chemin relatif
const absolu = path.resolve('dossier', 'fichier.txt');

http - Serveur web basique

const http = require('http');

const server = http.createServer((req, res) => {
  res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
  res.end('<h1>Bienvenue sur mon serveur Node.js !</h1>');
});

const PORT = 3000;
server.listen(PORT, () => {
  console.log(`Serveur démarré sur http://localhost:${PORT}`);
});

NPM : Le gestionnaire de packages

Initialiser un projet

# Créer package.json interactif
npm init

# Créer avec valeurs par défaut
npm init -y

Gérer les dépendances

# Installer une dépendance
npm install express

# Installer en dev uniquement
npm install --save-dev nodemon

# Installer globalement
npm install -g typescript

# Installer depuis package.json
npm install

Scripts NPM

{
  "scripts": {
    "start": "node app.js",
    "dev": "nodemon app.js",
    "test": "jest",
    "build": "tsc"
  }
}

npm run dev
npm start  # 'run' optionnel pour start et test

Premier serveur web complet

Créons un petit serveur qui gère différentes routes :

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

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

  // Définir le type de contenu
  res.setHeader('Content-Type', 'application/json; charset=utf-8');

  // Router simple
  if (path === '/' && req.method === 'GET') {
    res.writeHead(200);
    res.end(JSON.stringify({ message: 'Bienvenue sur l\'API' }));
  }
  else if (path === '/api/users' && req.method === 'GET') {
    const users = [
      { id: 1, nom: 'Alice' },
      { id: 2, nom: 'Bob' }
    ];
    res.writeHead(200);
    res.end(JSON.stringify(users));
  }
  else if (path === '/api/health' && req.method === 'GET') {
    res.writeHead(200);
    res.end(JSON.stringify({ status: 'ok', timestamp: new Date() }));
  }
  else {
    res.writeHead(404);
    res.end(JSON.stringify({ error: 'Route non trouvée' }));
  }
});

const PORT = process.env.PORT || 3000;
server.listen(PORT, () => {
  console.log(`API démarrée sur http://localhost:${PORT}`);
});

Gestion des erreurs

// Erreurs synchrones
try {
  const data = JSON.parse(invalidJson);
} catch (err) {
  console.error('Erreur de parsing:', err.message);
}

// Erreurs asynchrones avec Promises
async function chargerConfig() {
  try {
    const config = await fsPromises.readFile('config.json', 'utf8');
    return JSON.parse(config);
  } catch (err) {
    console.error('Impossible de charger la config:', err.message);
    return {}; // Valeur par défaut
  }
}

// Gestion globale des erreurs non capturées
process.on('uncaughtException', (err) => {
  console.error('Exception non capturée:', err);
  process.exit(1);
});

process.on('unhandledRejection', (reason, promise) => {
  console.error('Promise rejetée:', reason);
});

Prochaines étapes

Maintenant que vous avez les bases de Node.js, vous pouvez :

Apprendre Express.js pour créer des API REST plus facilement
Explorer les bases de données avec MongoDB ou PostgreSQL
Découvrir les WebSockets avec Socket.IO pour le temps réel
Tester votre code avec Jest ou Mocha

Node.js ouvre un monde de possibilités. Dans les prochains articles, nous approfondirons chacun de ces sujets pour vous accompagner vers la maîtrise du développement backend JavaScript.