Node.js : comprendre et démarrer côté serveur

Node.js permet d’exécuter du JavaScript en dehors du navigateur, directement sur un serveur ou votre machine. Grâce à lui, un même langage sert au front-end et au back-end : le développeur web peut construire une application complète sans changer de langage. Ce guide explique ce qu’est Node.js, comment il fonctionne et comment apprendre Node.js à travers un premier serveur.

Qu’est-ce qu’un runtime ?

JavaScript, à l’origine, ne tournait que dans les navigateurs. Node.js est un runtime : un environnement qui embarque le moteur JavaScript de Chrome (V8) et l’entoure de tout ce qu’il faut pour agir hors du navigateur — accès aux fichiers, au réseau, au système. Là où le JavaScript du navigateur manipule une page, celui de Node.js peut lire un disque, écouter un port réseau ou parler à une base de données.

Si les bases du langage ne sont pas encore acquises, notre guide pour apprendre JavaScript est le préalable idéal, car Node.js utilise exactement la même syntaxe.

Installer et lancer Node.js

Une fois Node installé, vous disposez de la commande node. Créez un fichier bonjour.js :

console.log("Bonjour depuis Node.js !");
console.log("Version de Node :", process.version);

Exécutez-le en ligne de commande :

node bonjour.js

Le message s’affiche dans le terminal. Vous venez d’exécuter du JavaScript côté serveur, sans navigateur.

Les modules : organiser son code

Node encourage à découper le code en modules, des fichiers réutilisables qui exportent des fonctions ou des valeurs. La syntaxe moderne utilise export et import (activez-la avec "type": "module" dans votre package.json).

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

// index.js
import { additionner } from "./math.js";
console.log(additionner(2, 3)); // 5

Node fournit aussi des modules intégrés pour les tâches système, importables sans installation : fs (fichiers), http (serveur web), path (chemins), os (système), et bien d’autres.

npm : l’écosystème de paquets

npm (Node Package Manager) est installé avec Node. Il donne accès à un immense catalogue de bibliothèques open source et gère les dépendances de votre projet.

npm init -y            # crée un package.json
npm install express    # installe une bibliothèque

Le fichier package.json liste vos dépendances et vos scripts. Un dossier node_modules contient le code installé (à ne jamais versionner). Vous pouvez définir des raccourcis dans la section scripts :

{
  "scripts": {
    "start": "node index.js",
    "dev": "node --watch index.js"
  }
}

Lancez-les avec npm run dev. L’option --watch redémarre le serveur à chaque modification.

Créer un serveur HTTP

C’est le cas d’usage emblématique de Node : servir des requêtes web. Le module intégré http suffit pour un premier serveur.

import { createServer } from "http";

const serveur = createServer((req, res) => {
  res.writeHead(200, { "Content-Type": "application/json" });
  res.end(JSON.stringify({ message: "Bonjour, Coder Studio !" }));
});

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

Lancez-le avec node index.js, puis ouvrez http://localhost:3000 : votre serveur répond. En pratique, on utilise souvent un framework comme Express pour simplifier le routage, mais comprendre le module http de base aide à saisir ce qui se passe réellement. Ce serveur est la porte d’entrée d’une API REST, le format d’échange standard entre front-end et back-end.

L’asynchrone : le cœur de Node

Node est conçu pour être non bloquant. Plutôt que d’attendre qu’une opération lente (lecture de fichier, requête réseau, accès base de données) se termine, il continue à traiter d’autres tâches, puis reprend quand le résultat est prêt. C’est ce qui lui permet de gérer de nombreuses connexions simultanées avec peu de ressources.

La syntaxe moderne pour cela est async/await. Comparez une lecture de fichier bloquante et non bloquante :

import { readFile } from "fs/promises";

async function lireFichier() {
  try {
    const contenu = await readFile("data.txt", "utf-8");
    console.log(contenu);
  } catch (err) {
    console.error("Erreur de lecture :", err.message);
  }
}

lireFichier();
console.log("Cette ligne s'affiche AVANT le contenu du fichier");

Le message final s’affiche en premier : pendant la lecture du fichier, Node ne reste pas bloqué. Ce modèle asynchrone est la clé de sa performance, et il faut prendre l’habitude de raisonner avec await et la gestion d’erreurs par try/catch.

Les cas d’usage de Node.js

Node est particulièrement adapté à plusieurs situations :

API et services web : back-end d’applications, points d’accès aux données ;
temps réel : chats, notifications, jeux, grâce à sa gestion efficace des connexions ;
outils en ligne de commande : de nombreux outils de développement (bundlers, linters) tournent sous Node ;
microservices : de petits services légers et indépendants.

À l’inverse, pour des calculs lourds et intensifs en CPU (traitement d’images massif, calcul scientifique), d’autres environnements peuvent être plus adaptés, car le modèle mono-thread de Node y est moins à l’aise.

Les prochaines étapes

Avec ces bases — runtime, modules, npm, serveur HTTP et asynchrone — vous avez de quoi construire un vrai back-end. La suite logique est d’apprendre un framework comme Express pour structurer vos routes, puis de connecter une base de données. Ajouter TypeScript à votre projet Node fiabilisera aussi grandement le code à mesure qu’il grandit ; notre guide TypeScript montre comment l’intégrer progressivement.