Node.js, le JavaScript côté serveur

T'as déjà parlé à un backend sans le savoir. Ton appli météo de l'étape 4 demande les températures à Open-Meteo : ton navigateur est le client, et le programme qui tourne chez Open-Meteo et répond, c'est le serveur, le backend de quelqu'un d'autre. Dans ce parcours, tu passes de l'autre côté : c'est toi qui vas écrire ce programme.

1. Ouvre ton appli météo dans le navigateur (en ligne ou avec Live Server).
2. Ouvre les outils de développement (F12), onglet Réseau (Network), et clique sur le filtre Fetch/XHR.
3. Recharge la page (F5). Une ligne forecast?latitude=... apparaît : clique dessus.
4. Lis l'onglet En-têtes (Headers), puis l'onglet Réponse (Response).

Tu peux aussi coller l'adresse de la requête directement dans la barre d'adresse : le serveur te répond, sans page autour.

https://api.open-meteo.com/v1/forecast?latitude=48.85&longitude=2.35&current=temperature_2m,wind_speed_10m

• La méthode GET : « donne-moi quelque chose ». Il en existe d'autres (envoyer, modifier, supprimer), tu les verras à l'étape 3.
• L'adresse : le serveur (api.open-meteo.com), le chemin (/v1/forecast) et les paramètres après le ?.
• Le code de statut 200 : « tout va bien ». Un 404 voudrait dire « introuvable ».
• La réponse : du JSON, que ton response.json() transforme en objet.

Le backend que tu vas construire fera pareil pour ta to-do list : recevoir des requêtes, garder les tâches, renvoyer du JSON. Mais d'abord, il faut faire tourner du JavaScript en dehors du navigateur.

Request URL      https://api.open-meteo.com/v1/forecast?latitude=48.85&longitude=2.35&current=temperature_2m,wind_speed_10m
Request Method   GET
Status Code      200 OK
Content-Type     application/json; charset=utf-8

{
  "latitude": 48.853382,
  "longitude": 2.355208,
  "timezone": "GMT",
  "current_units": { "time": "iso8601", "interval": "seconds", "temperature_2m": "°C", "wind_speed_10m": "km/h" },
  "current": { "time": "2026-10-08T06:30", "interval": 900, "temperature_2m": 10.8, "wind_speed_10m": 14.8 }
}

Jusqu'ici, ton JavaScript tournait dans le navigateur. Node.js, c'est le même langage, mais qui tourne directement sur ton ordi (et plus tard sur un serveur). Pas de page, pas de document : à la place, il peut lire des fichiers, parler au réseau, attendre des requêtes. C'est ce qui fait un backend.

1. Va sur nodejs.org et télécharge la version LTS (« Long Term Support » : la version stable, maintenue longtemps). Il te faut Node 22 ou plus récent.
2. Lance l'installeur, garde les options par défaut. Si Node est déjà installé (étape 6 du frontend), vérifie juste la version.
3. Ferme et rouvre VS Code, puis ouvre son terminal : Terminal → Nouveau terminal.

$ node --version
$ npm --version

# Lance le « REPL » : tu tapes du JS, Node répond tout de suite
$ node

Dans le REPL (le terminal affiche >), essaie quelques lignes, puis sors avec .exit ou Ctrl + C deux fois :

2 + 3
const prenom = "Alex"
`Salut ${prenom}`
[1, 2, 3].map((n) => n * 2)
typeof document
.exit

• Le $ ne se tape pas : il marque le début d'une commande.
• npm arrive avec Node : c'est l'outil qui installe des paquets de code écrits par d'autres (mission 6).
• REPL : Read, Eval, Print, Loop. Il lit ta ligne, l'exécute, affiche le résultat, recommence. Comme la console du navigateur, mais sans page.
• typeof document donne 'undefined' : la preuve qu'il n'y a pas de page HTML ici.

$ node --version
v24.11.0
$ npm --version
11.6.2

$ node
Welcome to Node.js v24.11.0.
Type ".help" for more information.
> 2 + 3
5
> const prenom = "Alex"
undefined
> `Salut ${prenom}`
'Salut Alex'
> [1, 2, 3].map((n) => n * 2)
[ 2, 4, 6 ]
> typeof document
'undefined'
> .exit

Le REPL, c'est pour tester. Pour un vrai programme, tu écris un fichier et tu le donnes à Node. Crée un dossier api-taches (pas dans mon-site : c'est un projet à part), ouvre-le dans VS Code, et crée hello.js :

// Ton premier programme Node.js
console.log("Salut depuis Node.js !");

// process.argv : tout ce que t'as tapé après « node »
console.log(process.argv);

// Le 3e élément (index 2) : le premier mot après le nom du fichier
const name = process.argv[2] || "inconnu";
console.log(`Bonjour ${name}, on est le ${new Date().toLocaleDateString("fr-FR")}`);

$ node hello.js Alex
$ node hello.js

• node hello.js : Node lit le fichier et l'exécute de haut en bas, puis s'arrête. Le console.log écrit dans le terminal, plus dans la console du navigateur.
• process : un objet fourni par Node qui décrit le programme en cours. Il n'existe pas dans le navigateur.
• process.argv : un tableau avec tout ce que t'as tapé. Index 0 : le chemin de Node. Index 1 : ton fichier. À partir de 2 : tes mots à toi.
• || "inconnu" : si rien n'est tapé, process.argv[2] vaut undefined, donc on prend la valeur de secours.

$ node hello.js Alex
Salut depuis Node.js !
[ '/usr/local/bin/node', '/Users/alex/api-taches/hello.js', 'Alex' ]
Bonjour Alex, on est le 08/10/2026

$ node hello.js
Salut depuis Node.js !
[ '/usr/local/bin/node', '/Users/alex/api-taches/hello.js' ]
Bonjour inconnu, on est le 08/10/2026

Un projet Node a une carte d'identité : le fichier package.json. Il dit comment s'appelle le projet, quels paquets il utilise, quelles commandes il propose. Dans le terminal, toujours dans api-taches :

$ npm init -y

Ouvre le package.json créé et mets "type": "module" (remplace "commonjs" s'il est là, sinon ajoute la ligne, sans oublier la virgule avant) :

{
  "name": "api-taches",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "type": "module"
}

Maintenant, on découpe l'appli en deux fichiers : un qui s'occupe des données, un qui parle avec toi. Crée storage.js et cli.js :

// Version provisoire : les tâches sont écrites en dur
const tasks = [
  { id: 1, text: "Installer Node.js", done: true },
  { id: 2, text: "Écrire mon premier module", done: false },
];

export function loadTasks() {
  return tasks;
}

import { loadTasks } from "./storage.js";

const tasks = loadTasks();

for (const task of tasks) {
  const box = task.done ? "[x]" : "[ ]";
  console.log(`${box} ${task.id}  ${task.text}`);
}

$ node cli.js

• npm init -y : crée package.json en répondant « oui » à toutes les questions.
• "type": "module" : dit à Node d'utiliser import et export, la syntaxe moderne, la même que dans le navigateur.
• export devant une fonction : elle peut être utilisée par d'autres fichiers. Sans export, elle reste privée.
• import { loadTasks } from "./storage.js" : le ./ veut dire « dans ce dossier », et l'extension .js est obligatoire.
• Une tâche, c'est { id, text, done } : exactement le même objet que dans ta to-do list du frontend. C'est voulu, ton front parlera à ce backend à l'étape 5.

$ node cli.js
[x] 1  Installer Node.js
[ ] 2  Écrire mon premier module

Au frontend, tes tâches survivaient grâce à localStorage. Côté serveur, pas de navigateur, donc pas de localStorage. À la place, Node peut écrire dans de vrais fichiers. On range les tâches dans tasks.json. Remplace storage.js :

import { readFileSync, writeFileSync, existsSync } from "node:fs";

const FILE = "tasks.json";

export function loadTasks() {
  if (!existsSync(FILE)) return [];
  return JSON.parse(readFileSync(FILE, "utf8"));
}

export function saveTasks(tasks) {
  writeFileSync(FILE, JSON.stringify(tasks, null, 2));
}

Puis cli.js, qui comprend maintenant deux commandes, add et list :

import { loadTasks, saveTasks } from "./storage.js";

// node cli.js add Acheter du pain → command = "add", args = ["Acheter", "du", "pain"]
const [command, ...args] = process.argv.slice(2);
const tasks = loadTasks();

if (command === "add") {
  const text = args.join(" ").trim();
  if (text === "") {
    console.log('Écris le texte de la tâche : node cli.js add "Acheter du pain"');
  } else {
    const task = { id: Date.now(), text: text, done: false };
    tasks.push(task);
    saveTasks(tasks);
    console.log(`Ajoutée : ${task.text} (id ${task.id})`);
  }
} else if (command === "list") {
  if (tasks.length === 0) {
    console.log("Aucune tâche pour l'instant.");
  }
  for (const task of tasks) {
    const box = task.done ? "[x]" : "[ ]";
    console.log(`${box} ${task.id}  ${task.text}`);
  }
} else {
  console.log("Commandes : add, list");
}

$ node cli.js list
$ node cli.js add "Acheter du pain"
$ node cli.js add Réviser les tableaux
$ node cli.js list

• node:fs : le module « file system » fourni avec Node, rien à installer. Le préfixe node: dit « module intégré à Node ».
• existsSync(FILE) : le fichier existe ? La première fois, non : on renvoie un tableau vide au lieu de planter.
• readFileSync(FILE, "utf8") : lit le fichier et renvoie son texte. JSON.parse le transforme en tableau, comme avec localStorage.getItem.
• JSON.stringify(tasks, null, 2) : le 2 indente le JSON, pour que tu puisses lire tasks.json à l'œil nu.
• process.argv.slice(2) enlève les deux premiers éléments, et const [command, ...args] range le premier mot dans command et tous les autres dans le tableau args.
• id: Date.now() : le nombre de millisecondes depuis 1970, comme au frontend. Un nombre différent à chaque ajout.

$ node cli.js list
Aucune tâche pour l'instant.

$ node cli.js add "Acheter du pain"
Ajoutée : Acheter du pain (id 1791441260454)

$ node cli.js add Réviser les tableaux
Ajoutée : Réviser les tableaux (id 1791441260654)

$ node cli.js list
[ ] 1791441260454  Acheter du pain
[ ] 1791441260654  Réviser les tableaux

[
  {
    "id": 1791441260454,
    "text": "Acheter du pain",
    "done": false
  },
  {
    "id": 1791441260654,
    "text": "Réviser les tableaux",
    "done": false
  }
]

Il manque deux commandes pour avoir une vraie to-do list : done pour cocher ou décocher, remove pour supprimer. Les deux reçoivent un id. Voici le cli.js complet :

import { loadTasks, saveTasks } from "./storage.js";

const [command, ...args] = process.argv.slice(2);
const tasks = loadTasks();

// Trouve une tâche à partir de l'id tapé ("1791441260454" → nombre)
function findTask(idText) {
  const id = Number(idText);
  return tasks.find((task) => task.id === id);
}

if (command === "add") {
  const text = args.join(" ").trim();
  if (text === "") {
    console.log('Écris le texte de la tâche : node cli.js add "Acheter du pain"');
  } else {
    const task = { id: Date.now(), text: text, done: false };
    tasks.push(task);
    saveTasks(tasks);
    console.log(`Ajoutée : ${task.text} (id ${task.id})`);
  }
} else if (command === "list") {
  if (tasks.length === 0) {
    console.log("Aucune tâche pour l'instant.");
  }
  for (const task of tasks) {
    const box = task.done ? "[x]" : "[ ]";
    console.log(`${box} ${task.id}  ${task.text}`);
  }
} else if (command === "done") {
  const task = findTask(args[0]);
  if (!task) {
    console.log("Tâche introuvable. Tape node cli.js list pour voir les id.");
  } else {
    task.done = !task.done;
    saveTasks(tasks);
    console.log(task.done ? `Faite : ${task.text}` : `À refaire : ${task.text}`);
  }
} else if (command === "remove") {
  const task = findTask(args[0]);
  if (!task) {
    console.log("Tâche introuvable. Tape node cli.js list pour voir les id.");
  } else {
    const rest = tasks.filter((t) => t.id !== task.id);
    saveTasks(rest);
    console.log(`Supprimée : ${task.text}`);
  }
} else {
  console.log(`Commandes :
  node cli.js add "Texte"   ajoute une tâche
  node cli.js list          affiche les tâches
  node cli.js done <id>     coche ou décoche une tâche
  node cli.js remove <id>   supprime une tâche`);
}

# Recopie un id affiché par list (le tien est différent)
$ node cli.js list
$ node cli.js done 1791441260454
$ node cli.js list
$ node cli.js done 42
$ node cli.js remove 1791441260654
$ node cli.js

• Number(idText) : ce qui vient du terminal est du texte. Sans la conversion, "1791441260454" === 1791441260454 est faux et on ne trouverait jamais la tâche.
• tasks.find(...) : renvoie la première tâche qui correspond, ou undefined. D'où le if (!task).
• task.done = !task.done : inverse la valeur. true devient false et l'inverse, comme une case qu'on coche et décoche.
• filter garde toutes les tâches sauf celle à supprimer. On sauvegarde ce nouveau tableau.
• Le dernier else affiche l'aide quand la commande est vide ou inconnue. Un bon programme explique comment s'en servir.

$ node cli.js done 1791441260454
Faite : Acheter du pain

$ node cli.js list
[x] 1791441260454  Acheter du pain
[ ] 1791441260654  Réviser les tableaux

$ node cli.js done 42
Tâche introuvable. Tape node cli.js list pour voir les id.

$ node cli.js remove 1791441260654
Supprimée : Réviser les tableaux

$ node cli.js
Commandes :
  node cli.js add "Texte"   ajoute une tâche
  node cli.js list          affiche les tâches
  node cli.js done <id>     coche ou décoche une tâche
  node cli.js remove <id>   supprime une tâche

Un paquet, c'est du code écrit par quelqu'un d'autre, que tu installes au lieu de le réécrire. Il y en a des millions sur npmjs.com. On en installe un tout petit : picocolors, pour mettre de la couleur dans le terminal.

$ npm install picocolors

Trois choses apparaissent : un dossier node_modules (le code du paquet), un fichier package-lock.json (les versions exactes installées), et une section dependencies dans package.json. Profites-en pour le ranger et ajouter un script start (supprime aussi hello.js, il a fait son temps) :

{
  "name": "api-taches",
  "version": "1.0.0",
  "description": "Le backend de ma to-do list",
  "type": "module",
  "scripts": {
    "start": "node cli.js"
  },
  "dependencies": {
    "picocolors": "^1.1.1"
  }
}

Puis colore cli.js :

import pc from "picocolors";
import { loadTasks, saveTasks } from "./storage.js";

const [command, ...args] = process.argv.slice(2);
const tasks = loadTasks();

// Trouve une tâche à partir de l'id tapé ("1791441260454" → nombre)
function findTask(idText) {
  const id = Number(idText);
  return tasks.find((task) => task.id === id);
}

if (command === "add") {
  const text = args.join(" ").trim();
  if (text === "") {
    console.log(pc.red('Écris le texte de la tâche : node cli.js add "Acheter du pain"'));
  } else {
    const task = { id: Date.now(), text: text, done: false };
    tasks.push(task);
    saveTasks(tasks);
    console.log(pc.green(`Ajoutée : ${task.text}`) + pc.dim(` (id ${task.id})`));
  }
} else if (command === "list") {
  if (tasks.length === 0) {
    console.log(pc.dim("Aucune tâche pour l'instant."));
  }
  for (const task of tasks) {
    const box = task.done ? pc.green("[x]") : "[ ]";
    const text = task.done ? pc.dim(task.text) : task.text;
    console.log(`${box} ${pc.dim(task.id)}  ${text}`);
  }
} else if (command === "done") {
  const task = findTask(args[0]);
  if (!task) {
    console.log(pc.red("Tâche introuvable. Tape node cli.js list pour voir les id."));
  } else {
    task.done = !task.done;
    saveTasks(tasks);
    console.log(task.done ? pc.green(`Faite : ${task.text}`) : `À refaire : ${task.text}`);
  }
} else if (command === "remove") {
  const task = findTask(args[0]);
  if (!task) {
    console.log(pc.red("Tâche introuvable. Tape node cli.js list pour voir les id."));
  } else {
    const rest = tasks.filter((t) => t.id !== task.id);
    saveTasks(rest);
    console.log(pc.yellow(`Supprimée : ${task.text}`));
  }
} else {
  console.log(`${pc.bold("Commandes :")}
  node cli.js add "Texte"   ajoute une tâche
  node cli.js list          affiche les tâches
  node cli.js done <id>     coche ou décoche une tâche
  node cli.js remove <id>   supprime une tâche`);
}

# Lance le script "start" (ce qui suit -- est passé à cli.js)
$ npm start -- list

# Relance le programme tout seul à chaque sauvegarde d'un fichier .js
$ node --watch cli.js list

• import pc from "picocolors" : pas de ./, donc Node va chercher le paquet dans node_modules.
• pc.green(...), pc.dim(...) : entourent le texte de codes spéciaux que le terminal affiche en couleur.
• "scripts" : des raccourcis. npm start lance node cli.js. Les autres noms se lancent avec npm run nom.
• "^1.1.1" : « la version 1.1.1 ou une plus récente, tant qu'elle commence par 1 ».
• node --watch : relance le fichier dès que tu sauvegardes du code. Pratique pour tester une modif sans retaper la commande. Ctrl + C pour l'arrêter.

node_modules peut peser des centaines de Mo et se recrée avec un simple npm install : il ne va jamais dans Git. Crée le .gitignore, puis sauvegarde le projet sur GitHub comme à l'étape 5 (un dépôt api-taches vide) :

node_modules/

$ git init
$ git add .
$ git status
$ git commit -m "Gestionnaire de tâches en ligne de commande"
$ git remote add origin https://github.com/TON-PSEUDO/api-taches.git
$ git push -u origin main

• package-lock.json, lui, va dans Git : il garantit que tout le monde installe les mêmes versions.
• Quelqu'un clone ton dépôt ? Il tape npm install, et npm recrée node_modules à partir de package.json.

$ npm install picocolors
added 1 package, and audited 2 packages in 329ms

found 0 vulnerabilities

$ npm start -- list

> api-taches@1.0.0 start
> node cli.js list

[x] 1791441260454  Acheter du pain
[ ] 1791441290229  Appeler Sam

api-taches/
├── .gitignore
├── cli.js
├── node_modules/        (ignoré par Git)
├── package-lock.json
├── package.json
├── storage.js
└── tasks.json