Cours Intermédiaire Gratuit
Node.js — Les fondamentaux
Comprendre le moteur d'exécution Node.js : modules, asynchronisme, npm et création d'un petit serveur.
- 4 guides
- 44 notions
Les guides
- 01 Guide Lexique Node.js Expliquer chaque notion en la reliant à une opération du projet.
- 02 Guide Les essentiels de Node.js Choisir une instruction ou une commande et prévoir son effet.
- 03 Guide Atelier Node.js · À table ! Reproduire le projet, vérifier ses comportements et réussir une modification autonome.
- 04 Guide Ressources et bilan Justifier ses choix et retrouver une information dans la documentation.
Parcours conseillé
- 01. Node.js : exposer et tester une API HTTP de recettes, puis la consommer depuis le navigateur.
- 02. SCSS : organiser la présentation du mini-blog en modules et compiler une feuille CSS.
- 03. TypeScript : modéliser les recettes et vérifier les réponses de l’API avant de les afficher.
Sources et références
Atelier confirmé, étape 1/3. Reproduire les fichiers dans un projet local distinct de Technipédia. Les prérequis, résultats attendus et limites sont précisés dans les guides.
Fichiers d’exemple
package.json
{
"name": "a-table-mini-blog",
"private": true,
"type": "module",
"engines": {
"node": ">=24 <25"
},
"scripts": {
"start": "node src/index.js",
"dev": "node --watch src/index.js",
"test": "node --test"
}
}
src/recettes.js
export function recettesInitiales() {
// Un nouveau tableau à chaque serveur facilite l'isolation des tests.
return [
{ id: 1, titre: "Soupe de carottes", duree_minutes: 20, portions: 2, categorie: "Plat",
ingredients: ["4 carottes", "1 oignon", "500 ml d’eau"],
etapes: ["Éplucher et couper les légumes.", "Cuire dans l’eau 15 minutes puis mixer."] },
{ id: 2, titre: "Salade de tomates", duree_minutes: 10, portions: 2, categorie: "Entrée",
ingredients: ["3 tomates", "1 cuillère d’huile d’olive", "Quelques feuilles de basilic"],
etapes: ["Laver et couper les tomates.", "Ajouter l’huile et le basilic, mélanger."] },
{ id: 3, titre: "Tarte aux pommes", duree_minutes: 45, portions: 4, categorie: "Dessert",
ingredients: ["1 pâte brisée", "3 pommes", "2 cuillères de compote"],
etapes: ["Préchauffer le four à 180 °C et étaler la pâte.", "Garnir de compote et de pommes puis cuire 30 minutes."] }
];
}
export function filtrerRecettes(recettes, q = "", dureeMax = 0) {
const terme = q.trim().toLocaleLowerCase("fr");
return recettes.filter((recette) =>
recette.titre.toLocaleLowerCase("fr").includes(terme) &&
(dureeMax === 0 || recette.duree_minutes <= dureeMax)
);
}
export function validerRecette(valeur) {
if (typeof valeur !== "object" || valeur === null || Array.isArray(valeur)) {
return { erreurs: ["Le corps doit être un objet JSON."] };
}
const titre = typeof valeur.titre === "string" ? valeur.titre.trim() : "";
const categories = ["Entrée", "Plat", "Dessert"];
const listeValide = (liste) => Array.isArray(liste) && liste.length >= 1 && liste.length <= 30 &&
liste.every((ligne) => typeof ligne === "string" && ligne.trim().length >= 1 && ligne.length <= 500);
const erreurs = [];
if (titre.length < 3 || titre.length > 120) erreurs.push("Titre : 3 à 120 unités UTF-16.");
if (!Number.isInteger(valeur.duree_minutes) || valeur.duree_minutes < 1 || valeur.duree_minutes > 1440) {
erreurs.push("Durée : entier entre 1 et 1440.");
}
if (!Number.isInteger(valeur.portions) || valeur.portions < 1 || valeur.portions > 20) {
erreurs.push("Portions : entier entre 1 et 20.");
}
if (!categories.includes(valeur.categorie)) erreurs.push("Catégorie : Entrée, Plat ou Dessert.");
if (!listeValide(valeur.ingredients)) erreurs.push("Ingrédients : 1 à 30 lignes non vides, 500 unités UTF-16 par ligne au maximum.");
if (!listeValide(valeur.etapes)) erreurs.push("Étapes : 1 à 30 lignes non vides, 500 unités UTF-16 par ligne au maximum.");
if (erreurs.length) return { erreurs };
// Seules les propriétés autorisées sont conservées. L'id est produit par le serveur.
return { erreurs: [], recette: {
titre, duree_minutes: valeur.duree_minutes, portions: valeur.portions,
categorie: valeur.categorie,
ingredients: valeur.ingredients.map((ligne) => ligne.trim()),
etapes: valeur.etapes.map((ligne) => ligne.trim())
} };
}
src/server.js
import { createServer } from "node:http";
import { readFile } from "node:fs/promises";
import { recettesInitiales, filtrerRecettes, validerRecette } from "./recettes.js";
class ErreurHttp extends Error {
constructor(statut, message) { super(message); this.statut = statut; }
}
function json(reponse, statut, valeur, entetes = {}) {
reponse.writeHead(statut, {
"Content-Type": "application/json; charset=utf-8",
"Cache-Control": "no-store",
"X-Content-Type-Options": "nosniff",
...entetes
});
reponse.end(JSON.stringify(valeur));
}
async function lireJson(requete) {
const type = (requete.headers["content-type"] ?? "").split(";")[0].trim().toLowerCase();
if (type !== "application/json") throw new ErreurHttp(415, "Envoyer du JSON avec Content-Type: application/json.");
let taille = 0;
let tropGrand = false;
const morceaux = [];
// Ne plus conserver de données au-delà de la limite, mais finir de lire le flux.
for await (const morceau of requete) {
taille += morceau.length;
if (taille > 16 * 1024) { tropGrand = true; morceaux.length = 0; }
else if (!tropGrand) morceaux.push(morceau);
}
if (tropGrand) throw new ErreurHttp(413, "Corps limité à 16 Kio.");
try { return JSON.parse(Buffer.concat(morceaux).toString("utf8")); }
catch { throw new ErreurHttp(400, "JSON mal formé."); }
}
export function creerServeur() {
const recettes = recettesInitiales();
let prochainId = Math.max(...recettes.map((r) => r.id)) + 1;
// Liste fixe : le chemin demandé n'est jamais concaténé à un chemin de disque.
const fichiers = new Map([
["/", ["index.html", "text/html; charset=utf-8"]],
["/index.html", ["index.html", "text/html; charset=utf-8"]],
["/style.css", ["style.css", "text/css; charset=utf-8"]],
["/app.js", ["app.js", "text/javascript; charset=utf-8"]],
["/modeles.js", ["modeles.js", "text/javascript; charset=utf-8"]]
]);
const serveur = createServer(async (requete, reponse) => {
try {
const url = new URL(requete.url ?? "/", "http://localhost");
const chemin = url.pathname;
const methode = requete.method ?? "GET";
if (chemin === "/api/recettes") {
if (methode === "GET") {
const q = url.searchParams.get("q") ?? "";
const dureeSaisie = url.searchParams.get("duree") ?? "0";
if (q.length > 120 || !/^\d{1,4}$/.test(dureeSaisie) || Number(dureeSaisie) > 1440) {
throw new ErreurHttp(400, "Filtres invalides : q limité à 120 unités UTF-16, duree entre 0 et 1440.");
}
const donnees = filtrerRecettes(recettes, q, Number(dureeSaisie));
return json(reponse, 200, { donnees, total: donnees.length });
}
if (methode === "POST") {
const resultat = validerRecette(await lireJson(requete));
if (resultat.erreurs.length) return json(reponse, 422, { erreurs: resultat.erreurs });
const recette = { id: prochainId++, ...resultat.recette };
recettes.push(recette);
return json(reponse, 201, { donnees: recette }, { Location: `/api/recettes/${recette.id}` });
}
return json(reponse, 405, { erreur: "Méthode non autorisée." }, { Allow: "GET, POST" });
}
const fiche = /^\/api\/recettes\/([^/]+)$/.exec(chemin);
if (fiche) {
if (methode !== "GET") return json(reponse, 405, { erreur: "Méthode non autorisée." }, { Allow: "GET" });
const idSaisi = fiche[1];
const id = Number(idSaisi);
if (!/^[1-9]\d*$/.test(idSaisi) || !Number.isSafeInteger(id)) throw new ErreurHttp(400, "Identifiant invalide.");
const recette = recettes.find((r) => r.id === id);
if (!recette) throw new ErreurHttp(404, "Recette introuvable.");
return json(reponse, 200, { donnees: recette });
}
if (fichiers.has(chemin)) {
if (methode !== "GET") return json(reponse, 405, { erreur: "Méthode non autorisée." }, { Allow: "GET" });
const [nom, type] = fichiers.get(chemin);
const contenu = await readFile(new URL(`../public/${nom}`, import.meta.url));
reponse.writeHead(200, { "Content-Type": type, "X-Content-Type-Options": "nosniff" });
return reponse.end(contenu);
}
return json(reponse, 404, { erreur: "Adresse introuvable." });
} catch (erreur) {
if (erreur instanceof ErreurHttp) return json(reponse, erreur.statut, { erreur: erreur.message });
if (erreur?.code === "ENOENT") return json(reponse, 404, { erreur: "Fichier public absent." });
console.error("Erreur interne de la requête.");
if (!reponse.headersSent) json(reponse, 500, { erreur: "Erreur interne." });
else reponse.end();
}
});
serveur.requestTimeout = 15_000;
return serveur;
}
src/index.js
import { creerServeur } from "./server.js";
const port = Number(process.env.PORT ?? 3000);
if (!Number.isInteger(port) || port < 1 || port > 65535) throw new Error("PORT invalide.");
const serveur = creerServeur();
serveur.on("error", (erreur) => {
console.error(`Démarrage impossible : ${erreur.code ?? "erreur inconnue"}`);
process.exitCode = 1;
});
serveur.listen(port, "127.0.0.1", () => console.log(`À table ! http://127.0.0.1:${port}`));
public/index.html
<!doctype html>
<html lang="fr">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>À table ! · Le mini-blog connecté</title>
<link rel="stylesheet" href="/style.css">
<script type="module" src="/app.js"></script>
</head>
<body>
<a class="evitement" href="#contenu">Aller au contenu</a>
<header class="entete"><h1>À table !</h1><p>Nos recettes maison, servies par une API.</p></header>
<main id="contenu" class="conteneur">
<h2>Nos recettes</h2>
<form id="filtres">
<label for="recherche">Rechercher par titre</label>
<input id="recherche" name="q" type="search" maxlength="120">
<label for="duree-max">Durée maximale</label>
<select id="duree-max" name="duree">
<option value="0">Toutes les durées</option>
<option value="20">20 minutes</option>
<option value="45">45 minutes</option>
</select>
<button type="submit">Rechercher</button>
<button type="reset">Réinitialiser</button>
</form>
<p id="message" role="status" aria-live="polite">Chargement des recettes…</p>
<div id="liste" class="recettes"></div>
<noscript>Activer JavaScript pour consulter cette version connectée du blog. La version HTML du parcours débutant reste consultable sans script.</noscript>
</main>
<footer class="pied"><p>À table ! · L’Akadémie du Digital</p></footer>
</body>
</html>
public/app.js
const formulaire = document.querySelector("#filtres");
const recherche = document.querySelector("#recherche");
const dureeMax = document.querySelector("#duree-max");
const liste = document.querySelector("#liste");
const message = document.querySelector("#message");
let numeroRequete = 0;
function afficher(recettes) {
liste.replaceChildren();
for (const recette of recettes) {
const article = document.createElement("article");
article.className = "recette";
const titre = document.createElement("h3");
titre.textContent = recette.titre;
const meta = document.createElement("p");
meta.className = "meta";
meta.textContent = `${recette.duree_minutes} min · ${recette.portions} personnes · ${recette.categorie}`;
article.append(titre, meta);
for (const [intitule, lignes, balise] of [
["Ingrédients", recette.ingredients, "ul"],
["Préparation", recette.etapes, "ol"]
]) {
const sousTitre = document.createElement("h4");
sousTitre.textContent = intitule;
const groupe = document.createElement(balise);
for (const ligne of lignes) {
const item = document.createElement("li");
item.textContent = ligne;
groupe.append(item);
}
article.append(sousTitre, groupe);
}
liste.append(article);
}
}
async function charger() {
// Une ancienne réponse ne doit pas remplacer une recherche plus récente.
const numero = ++numeroRequete;
const params = new URLSearchParams({ q: recherche.value.trim(), duree: dureeMax.value });
message.textContent = "Chargement…";
liste.replaceChildren();
try {
const reponse = await fetch(`/api/recettes?${params}`);
if (!reponse.ok) throw new Error(`Erreur HTTP ${reponse.status}`);
// Le client TypeScript ajoutera une validation explicite de ce contrat JSON.
const resultat = await reponse.json();
if (numero !== numeroRequete) return;
afficher(resultat.donnees);
message.textContent = resultat.total === 0 ? "Aucune recette trouvée." : `${resultat.total} recette(s) trouvée(s).`;
} catch (erreur) {
if (numero === numeroRequete) message.textContent = "Impossible de charger les recettes. Vérifier le serveur puis réessayer.";
}
}
formulaire.addEventListener("submit", (evenement) => { evenement.preventDefault(); void charger(); });
formulaire.addEventListener("reset", () => { setTimeout(() => { void charger(); }, 0); });
void charger();
public/style.css
/* Le sélecteur universel inclut aussi les pseudo-éléments. */
*, *::before, *::after { box-sizing: border-box; }
:root {
--fond: #fff8ed;
--texte: #29251f;
--accent: #8b351b;
--carte: #ffffff;
}
body {
margin: 0;
font-family: system-ui, sans-serif;
line-height: 1.6;
color: var(--texte);
background: var(--fond);
}
.entete, .pied { padding: 1.5rem 1rem; text-align: center; }
.entete { background: var(--accent); color: white; }
.entete a { color: inherit; }
nav { display: flex; justify-content: center; flex-wrap: wrap; gap: 1rem; }
a { color: var(--accent); text-underline-offset: 0.2em; }
.conteneur { width: min(100% - 2rem, 70rem); margin-inline: auto; }
section { margin-block: 2rem; }
h1, h2, h3, h4 { line-height: 1.25; }
.recettes { display: grid; grid-template-columns: 1fr; gap: 1.25rem; }
.recette {
padding: 1.25rem;
border: 1px solid #cbbba9;
border-radius: 0.75rem;
background: var(--carte);
overflow-wrap: anywhere;
}
.recette h3 { margin-top: 0; color: var(--accent); }
.meta { font-weight: 600; }
img { display: block; max-width: 100%; height: auto; }
figure { margin: 0; }
label { font-weight: 600; }
input, select, button, textarea { font: inherit; max-width: 100%; }
input, select, textarea { padding: 0.5rem; border: 1px solid #796e61; border-radius: 0.25rem; }
button { padding: 0.5rem 1rem; border: 0; border-radius: 0.25rem; background: var(--accent); color: white; cursor: pointer; }
#filtres { display: flex; align-items: center; flex-wrap: wrap; gap: 0.75rem; }
/* Une règle display ne doit pas réafficher un contrôle marqué hidden. */
[hidden] { display: none !important; }
:focus-visible { outline: 3px solid #185ea0; outline-offset: 4px; }
.evitement { position: absolute; top: 0; left: 1rem; padding: 0.5rem; background: white; transform: translateY(-120%); }
.evitement:focus { transform: translateY(0); }
.pied { border-top: 1px solid #cbbba9; }
@media (min-width: 48rem) {
.recettes { grid-template-columns: repeat(3, minmax(0, 1fr)); }
}
test/api.test.js
import test from "node:test";
import assert from "node:assert/strict";
import { creerServeur } from "../src/server.js";
test("API : filtrer, valider, créer et retrouver une recette", async (t) => {
const serveur = creerServeur();
await new Promise((resolve, reject) => { serveur.once("error", reject); serveur.listen(0, "127.0.0.1", resolve); });
t.after(() => new Promise((resolve, reject) => serveur.close((erreur) => erreur ? reject(erreur) : resolve())));
const origine = `http://127.0.0.1:${serveur.address().port}`;
const appeler = (chemin, options) => fetch(origine + chemin, options);
const liste = await appeler("/api/recettes");
assert.equal(liste.status, 200);
assert.equal((await liste.json()).total, 3);
const rapide = await (await appeler("/api/recettes?duree=20")).json();
assert.deepEqual(rapide.donnees.map((r) => r.titre), ["Soupe de carottes", "Salade de tomates"]);
const vide = await (await appeler("/api/recettes?q=tarte&duree=20")).json();
assert.equal(vide.total, 0);
assert.equal((await appeler("/api/recettes?duree=abc")).status, 400);
assert.equal((await appeler("/api/recettes/abc")).status, 400);
assert.equal((await appeler("/api/recettes/9999")).status, 404);
const recette = { titre: "Compote d’automne <maison>", duree_minutes: 15, portions: 2,
categorie: "Dessert", ingredients: ["2 pommes"], etapes: ["Cuire puis écraser."] };
const poster = (valeur) => appeler("/api/recettes", {
method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify(valeur)
});
assert.equal((await poster({ ...recette, duree_minutes: -1 })).status, 422);
const creation = await poster(recette);
assert.equal(creation.status, 201);
const emplacement = creation.headers.get("location");
const fiche = await (await appeler(emplacement)).json();
assert.equal(fiche.donnees.titre, recette.titre);
assert.equal((await (await appeler("/api/recettes")).json()).total, 4);
assert.equal((await appeler("/api/recettes", { method: "DELETE" })).status, 405);
assert.equal((await appeler("/src/server.js")).status, 404);
});
compote.json
{
"titre": "Compote de pommes",
"duree_minutes": 15,
"portions": 2,
"categorie": "Dessert",
"ingredients": [
"2 pommes",
"Un peu d’eau"
],
"etapes": [
"Couper les pommes.",
"Cuire puis écraser."
]
}
Dans la même catégorie
Développement et production · Débutant
HTML — Les bases
Structurer une page web sémantique et accessible, pas à pas, avec le fil rouge « À table ! » : un mini-blog de recettes.
Développement et production · Débutant
CSS — Les bases
Mettre en forme et rendre responsive le mini-blog de recettes : sélecteurs, boîtes, flexbox, grille et mobile d'abord.
Développement et production · Débutant
JavaScript — Les bases
Rendre la page interactive : variables, fonctions, DOM et événements pour filtrer les recettes sans recharger.