Node.js : débuter le développement côté serveur

Pendant longtemps, JavaScript n’a vécu que dans le navigateur. Node.js a changé la donne en 2009 : c’est un runtime — un environnement d’exécution — qui permet de faire tourner du code JavaScript directement sur un serveur, en dehors de tout navigateur. Concrètement, avec Node.js, le même langage sert à écrire l’interface d’un site et sa logique côté serveur : lire des fichiers, interroger une base de données, exposer une API. Ce guide pose toutes les bases dont un débutant a besoin pour démarrer sereinement.

Qu’est-ce que Node.js, exactement

Node.js n’est ni un langage ni un framework : c’est un runtime JavaScript côté serveur. Il embarque le moteur V8, celui-là même qui exécute JavaScript dans le navigateur Chrome, et l’entoure d’un ensemble de bibliothèques permettant d’accéder au système : le réseau, les fichiers, les processus. Là où le JavaScript du navigateur peut manipuler une page web mais pas toucher au disque dur, Node.js peut lire et écrire des fichiers, ouvrir un serveur sur un port, se connecter à une base de données.

Sa grande particularité tient à son modèle d’exécution : Node.js est non bloquant et orienté événements. Plutôt que d’attendre qu’une lecture de fichier se termine avant de passer à la suite, il lance l’opération et continue à traiter d’autres tâches, revenant au résultat quand il est prêt. Cette approche le rend particulièrement efficace pour les applications qui passent beaucoup de temps à attendre des entrées/sorties : serveurs web, API, applications temps réel.

Pour vérifier que Node.js est installé sur votre machine, ouvrez un terminal :

node --version
npm --version

Si ces commandes renvoient des numéros de version, tout est prêt. Sinon, téléchargez la version LTS (Long Term Support, la plus stable) depuis le site officiel nodejs.org.

npm, le gestionnaire de paquets

En installant Node.js, vous obtenez automatiquement npm (Node Package Manager). C’est l’outil qui télécharge et gère les bibliothèques externes — appelées paquets ou modules — dont votre projet a besoin. L’écosystème npm est colossal : on y trouve un paquet pour presque tout, du framework web au simple utilitaire de formatage de dates.

Pour initialiser un nouveau projet, on crée d’abord un fichier de configuration :

mkdir mon-projet
cd mon-projet
npm init -y

La commande npm init -y génère un fichier package.json avec des valeurs par défaut. Pour ajouter une dépendance, par exemple le framework Express, on écrit :

npm install express

npm télécharge alors Express et toutes ses sous-dépendances dans un dossier node_modules, et l’enregistre dans le package.json. Ce dossier node_modules ne doit jamais être versionné avec Git : il se reconstitue à partir du package.json avec un simple npm install.

Comprendre le package.json

Le fichier package.json est la carte d’identité de votre projet. Il décrit son nom, sa version, ses dépendances et les scripts que l’on peut lancer. Un exemple typique :

{
  "name": "mon-projet",
  "version": "1.0.0",
  "type": "module",
  "scripts": {
    "start": "node server.js",
    "dev": "node --watch server.js"
  },
  "dependencies": {
    "express": "^4.19.2"
  }
}

Deux éléments méritent l’attention. La section scripts permet de définir des raccourcis : npm run dev exécutera la commande associée, ici avec l’option --watch qui redémarre le serveur à chaque modification de fichier. Le champ "type": "module", lui, active la syntaxe moderne des modules ES (avec import/export), que nous verrons plus bas.

Les modules : organiser son code

Un projet Node.js réel se découpe en plusieurs fichiers, chacun exposant des fonctions ou des valeurs réutilisables ailleurs. C’est le rôle des modules. Node.js supporte deux syntaxes.

La syntaxe moderne (ES Modules)

C’est celle à privilégier aujourd’hui, activée par "type": "module" dans le package.json :

// fichier maths.js
export function additionner(a, b) {
  return a + b;
}

// fichier server.js
import { additionner } from "./maths.js";
console.log(additionner(2, 3)); // 5

La syntaxe historique (CommonJS)

Vous la croiserez encore souvent dans des projets ou des tutoriels plus anciens :

// fichier maths.js
function additionner(a, b) {
  return a + b;
}
module.exports = { additionner };

// fichier server.js
const { additionner } = require("./maths.js");

Node.js fournit aussi des modules natifs, intégrés au runtime, qu’on importe sans rien installer : fs pour les fichiers, http pour le réseau, path pour manipuler des chemins, crypto pour la cryptographie. Ce sont les briques de base sur lesquelles reposent la plupart des bibliothèques de l’écosystème.

Votre premier serveur HTTP

Rien ne vaut un exemple concret. Voici un serveur web minimal écrit uniquement avec le module natif http, sans aucune dépendance :

import { createServer } from "http";

const serveur = createServer((requete, reponse) => {
  reponse.writeHead(200, { "Content-Type": "text/plain; charset=utf-8" });
  reponse.end("Bonjour depuis Node.js !");
});

serveur.listen(3000, () => {
  console.log("Serveur à l'écoute sur http://localhost:3000");
});

Enregistrez ce code dans server.js, lancez node server.js, puis ouvrez votre navigateur sur http://localhost:3000. Le message s’affiche. Chaque fois qu’une requête arrive, la fonction passée à createServer est appelée avec deux objets : requete (ce que le client demande) et reponse (ce que le serveur renvoie). On écrit un code de statut 200, un en-tête indiquant le type de contenu, puis le corps de la réponse.

En pratique, on écrit rarement un serveur directement avec le module http : c’est verbeux et fastidieux dès qu’il faut gérer plusieurs routes. C’est précisément pour cela qu’existe Express, le framework minimaliste que nous verrons plus bas.

L’event loop et l’asynchrone

Le concept le plus déroutant pour un débutant est le fonctionnement asynchrone de Node.js. Contrairement à un langage qui exécute les instructions une par une en attendant que chacune se termine, Node.js s’appuie sur une event loop (boucle d’événements) : un mécanisme qui orchestre les opérations longues sans bloquer le reste du programme.

Prenons une lecture de fichier. En version bloquante, le programme s’arrête tant que le fichier n’est pas lu. En version asynchrone, il lance la lecture et continue :

import { readFile } from "fs/promises";

console.log("1 — je lance la lecture");

const contenu = await readFile("data.txt", "utf-8");
console.log("3 — fichier lu :", contenu);

console.log("2 — cette ligne s'affiche pendant l'attente");

Pour manipuler ce code asynchrone proprement, JavaScript propose les promesses et la syntaxe async/await, bien plus lisible que les anciennes fonctions de rappel imbriquées. Une fonction marquée async peut utiliser await pour attendre le résultat d’une promesse sans bloquer l’event loop. Si le sujet vous intéresse, notre guide dédié aux promesses et à async/await en JavaScript approfondit ces mécanismes essentiels.

Cette architecture explique pourquoi Node.js excelle pour les serveurs : un seul processus peut gérer des milliers de connexions simultanées, car il ne reste jamais bloqué à attendre une base de données ou un fichier — il passe à la requête suivante et revient quand la réponse arrive.

L’écosystème autour de Node.js

Node.js seul ne fait que le strict nécessaire ; sa force vient de son écosystème. Quelques bibliothèques que vous rencontrerez très vite :

Express : le framework web minimaliste de référence pour construire des API et des serveurs. Il simplifie radicalement la gestion des routes et des requêtes.
Fastify et Koa : des alternatives à Express, orientées performance ou modernité.
Prisma et Sequelize : des ORM (Object-Relational Mapping) pour dialoguer avec une base de données sans écrire de SQL à la main.
Nodemon : un utilitaire de développement qui redémarre le serveur à chaque modification (aujourd’hui concurrencé par l’option native --watch).
Vitest et Jest : des outils pour écrire des tests automatisés.

La logique est toujours la même : npm install le paquet, puis on l’importe dans son code. Cette modularité est ce qui rend Node.js si productif pour prototyper comme pour construire des applications de production.

Par où continuer

Vous disposez maintenant des fondations : un runtime installé, la compréhension de npm et des modules, un premier serveur, et une idée claire du modèle asynchrone. La suite logique consiste à quitter le module http brut pour un vrai framework, structurer un projet en routes et middlewares, puis connecter une base de données. Chaque étape s’appuie sur ce que vous venez de voir — Node.js récompense la pratique régulière bien plus que la théorie.