Avez-vous une question? (216) 97 656 803 hajjriadh@gmail.com
Laravel

TP 1 : première application Node.js avec npm

Ce travail pratique fait réaliser une première application Node.js complète : un gestionnaire de tâches en ligne de commande (ajouter, lister, terminer, supprimer, statistiques) dont les données sont ...

0 chapitres 0 QCM Accès gratuit
Dans cet article

À propos de ce cours

Ce travail pratique fait réaliser une première application Node.js complète : un gestionnaire de tâches en ligne de commande (ajouter, lister, terminer, supprimer, statistiques) dont les données sont enregistrées dans un fichier JSON. Il mobilise tout le chapitre : création du package.json, dépendance chalk, scripts, découpage en trois modules ES (règles de gestion, stockage avec fs/promises, point d'entrée qui lit process.argv), gestion des erreurs et code de sortie, tests avec node:test, puis installation de la commande taches avec bin et npm link. L'énoncé comprend le cahier des charges, l'architecture, les étapes, les livrables, un barème sur 20, des pistes pour aller plus loin et un corrigé complet testé.
  1. Objectifs

    • Créer un projet Node.js complet avec npm : package.json, dépendance, scripts, tests.
    • Organiser le code en modules ES, chacun avec une seule responsabilité.
    • Utiliser les modules natifs fs/promises et path pour enregistrer des données dans un fichier JSON.
    • Lire les arguments de la ligne de commande et transformer le projet en commande installable.
  2. Présentation du TP

    • Vous allez réaliser taches, un gestionnaire de tâches en ligne de commande. Les tâches sont enregistrées dans un fichier taches.json, et l'affichage est mis en couleur avec le paquet npm chalk.
    • Ce TP mobilise tout le chapitre 4 : npm et package.json (leçons 4.1 à 4.3), scripts (4.4), installation globale (4.5), modules ES (4.7) et modules natifs (4.8).
    • Durée indicative : 3 heures. Prérequis : Node.js 22 ou plus récent, Visual Studio Code.
  3. Cahier des charges

    • L'application accepte les commandes suivantes :
    CommandeEffetMessage affiché
    ajouter "titre"Ajoute une tâche non terminéeTâche ajoutée : titre
    listerAffiche toutes les tâches, avec leur numéro et leur état[x] 1. Installer Node.js LTS
    terminer <n°>Marque une tâche comme terminéeTâche n° 1 terminée.
    supprimer <n°>Supprime une tâcheTâche n° 2 supprimée.
    statsAffiche le bilan3 tâche(s) : 1 terminée(s), 2 à faire
    Aucune commande, ou commande inconnueAffiche l'aideLa liste des commandes
    • Règles de gestion :
      • le titre est obligatoire : un titre vide affiche « Erreur : Le titre de la tâche est obligatoire. » ;
      • chaque tâche reçoit un numéro égal au plus grand numéro existant plus 1 : un numéro n'est jamais réutilisé, même après une suppression ;
      • un numéro inexistant affiche « Erreur : Aucune tâche n° 9. » ;
      • en cas d'erreur, le programme se termine avec le code de sortie 1 ;
      • au premier lancement, quand taches.json n'existe pas encore, la liste est vide (pas d'erreur).
    • Exemple de session (les deux lignes d'en-tête que npm affiche avant chaque script sont omises) :
    npm start -- ajouter "Installer Node.js LTS"
    Tâche ajoutée : Installer Node.js LTS
    npm start -- ajouter "Lire la leçon sur npm"
    Tâche ajoutée : Lire la leçon sur npm
    npm start -- ajouter "Rendre le TP 1"
    Tâche ajoutée : Rendre le TP 1
    npm start -- terminer 1
    Tâche n° 1 terminée.
    npm start -- lister
    [x] 1. Installer Node.js LTS
    [ ] 2. Lire la leçon sur npm
    [ ] 3. Rendre le TP 1
    npm start -- stats
    3 tâche(s) : 1 terminée(s), 2 à faire
    npm start -- terminer 9
    Erreur : Aucune tâche n° 9.
  4. Architecture du projet

    • Le code est réparti en trois modules, chacun avec une seule responsabilité :
    • Architecture du TP 1 : index.js, taches.js, stockage.js et le fichier taches.json
    gestionnaire-taches/
    ├── src/
    │   ├── index.js       # lit la commande, appelle les autres modules, affiche (chalk)
    │   ├── taches.js      # règles de gestion : fonctions pures, sans affichage ni fichier
    │   └── stockage.js    # lecture et écriture de taches.json (fs/promises, path)
    ├── test/
    │   └── taches.test.js # tests de taches.js avec node:test
    ├── .gitignore
    ├── package.json
    └── package-lock.json
  5. taches.js ne fait ni affichage ni accès au fichier: ses fonctions reçoivent un tableau de tâches et renvoient un nouveau tableau. Elles sont ainsi très faciles à tester.
  6. Travail demandé

    1. Initialiser le projet
      • Créez le dossier gestionnaire-taches, puis son package.json.
      • Configurez : la description, "type": "module", "main": "src/index.js", engines.node à >=22, et les scripts start (node src/index.js) et test (node --test).
      • Installez chalk. Vérifiez dans package.json qu'il est bien dans dependencies.
      • Créez le .gitignore: node_modules/ et taches.json.
    2. Écrire les règles de gestion (taches.js)
      • Exportez quatre fonctions :
        • ajouter(taches, titre) renvoie un nouveau tableau avec la tâche { id, titre, terminee: false, creeLe }; creeLe est la date au format ISO ;
        • terminer(taches, id) et supprimer(taches, id) renvoient un nouveau tableau ;
        • statistiques(taches) renvoie { total, terminees, restantes }.
      • En cas de problème, les fonctions lèvent une erreur (throw new Error(…)) avec les messages du cahier des charges.
    3. Écrire le stockage (stockage.js)
      • Exportez charger(), qui lit taches.json et renvoie le tableau, ou [] si le fichier n'existe pas (erreur ENOENT), et enregistrer(taches), qui écrit le fichier, indenté sur 2 espaces.
      • Le fichier se trouve dans le dossier courant (process.cwd()). Si la variable d'environnement TACHES_FICHIER existe, on utilise son chemin à la place.
    4. Écrire le point d'entrée (index.js)
      • Lisez la commande et ses arguments dans process.argv.slice(2).
      • Chargez les tâches, exécutez la commande avec un switch, enregistrez si nécessaire, et affichez le résultat avec chalk : vert pour les succès, rouge pour les erreurs, jaune pour [ ], vert pour [x].
      • Entourez le tout d'un try...catch: en cas d'erreur, affichez le message avec console.error et mettez process.exitCode = 1.
    5. Tester
      • Dans test/taches.test.js, écrivez au moins quatre tests avec node:test et node:assert/strict: ajout, titre vide refusé, numéros non réutilisés après suppression, statistiques.
      • Lancez npm test: tous les tests doivent passer.
    6. Installer la commande taches
      • Ajoutez la ligne #!/usr/bin/env node en tout début de index.js et la propriété "bin": { "taches": "src/index.js" } dans package.json.
      • Dans le dossier du projet, lancez npm link. La commande taches est alors disponible dans n'importe quel dossier : taches lister. Pour la retirer : npm unlink -g gestionnaire-taches.
  7. Livrables et barème

    • Le dossier du projet sans node_modules (une archive .zip ou un dépôt Git), avec un court README.md qui explique l'installation et les commandes. Le correcteur doit pouvoir lancer npm install, npm test et npm start.
    CritèrePoints
    package.json complet (type, main, scripts, engines, dependencies, bin) et .gitignore3
    Découpage en modules ES respecté (aucun affichage ni fichier dans taches.js)3
    Les cinq commandes fonctionnent conformément au cahier des charges5
    Règles de gestion : titre obligatoire, numéros jamais réutilisés, numéro inexistant3
    Stockage : premier lancement sans erreur, TACHES_FICHIER, JSON lisible2
    Tests : au moins quatre, tous réussis avec npm test2
    Commande taches installée avec npm link, README, qualité du code2
    Total20
  8. Pour aller plus loin

    • Ajouter une commande vider qui supprime toutes les tâches terminées.
    • Ajouter une priorité : ajouter "titre" --priorite haute, et trier la liste par priorité.
    • Afficher la date de création au format JJ/MM/AAAA avec toLocaleDateString('fr-FR') ou le paquet dayjs.
    • Enregistrer chaque action dans un fichier journal.log grâce à un EventEmitter (leçon 4.8).
  9. Corrigé

    • Essayez de réaliser le TP par vous-même avant de consulter le corrigé.
    • Étape 1 : initialisation et package.json
      mkdir gestionnaire-taches && cd gestionnaire-taches
      npm init -y
      npm pkg set description="Gestionnaire de tâches en ligne de commande" type=module main=src/index.js engines.node=">=22"
      npm pkg set scripts.start="node src/index.js" scripts.test="node --test" bin.taches=src/index.js
      npm install chalk
      {
        "name": "gestionnaire-taches",
        "version": "1.0.0",
        "description": "Gestionnaire de tâches en ligne de commande",
        "type": "module",
        "main": "src/index.js",
        "bin": {
          "taches": "src/index.js"
        },
        "scripts": {
          "start": "node src/index.js",
          "test": "node --test"
        },
        "engines": {
          "node": ">=22"
        },
        "author": "",
        "license": "ISC",
        "dependencies": {
          "chalk": "^6.0.1"
        }
      }
      Étape 2 : src/taches.js
      // taches.js : les règles de gestion des tâches (sans affichage ni fichier)
      export function ajouter(taches, titre) {
        const texte = titre?.trim();
        if (!texte) throw new Error('Le titre de la tâche est obligatoire.');
        const id = taches.length === 0 ? 1 : Math.max(...taches.map((t) => t.id)) + 1;
        const tache = { id, titre: texte, terminee: false, creeLe: new Date().toISOString() };
        return [...taches, tache];
      }
      
      export function terminer(taches, id) {
        const existe = taches.some((t) => t.id === id);
        if (!existe) throw new Error(`Aucune tâche n° ${id}.`);
        return taches.map((t) => (t.id === id ? { ...t, terminee: true } : t));
      }
      
      export function supprimer(taches, id) {
        const restantes = taches.filter((t) => t.id !== id);
        if (restantes.length === taches.length) throw new Error(`Aucune tâche n° ${id}.`);
        return restantes;
      }
      
      export function statistiques(taches) {
        const terminees = taches.filter((t) => t.terminee).length;
        return { total: taches.length, terminees, restantes: taches.length - terminees };
      }

      Chaque fonction renvoie un nouveau tableau ([...taches, tache], map, filter) au lieu de modifier celui qu'elle reçoit : le code est plus prévisible et les tests plus simples.

      Étape 3 : src/stockage.js
      // stockage.js : lire et enregistrer les tâches dans un fichier JSON
      import { readFile, writeFile } from 'node:fs/promises';
      import path from 'node:path';
      
      const FICHIER = process.env.TACHES_FICHIER ?? path.join(process.cwd(), 'taches.json');
      
      export async function charger() {
        try {
          const texte = await readFile(FICHIER, 'utf8');
          return JSON.parse(texte);
        } catch (erreur) {
          if (erreur.code === 'ENOENT') return [];   // premier lancement : pas encore de fichier
          throw erreur;
        }
      }
      
      export async function enregistrer(taches) {
        await writeFile(FICHIER, JSON.stringify(taches, null, 2), 'utf8');
      }
      Étape 4 : src/index.js
      #!/usr/bin/env node
      // index.js : point d'entrée, lit la commande et affiche le résultat
      import chalk from 'chalk';
      import { charger, enregistrer } from './stockage.js';
      import { ajouter, terminer, supprimer, statistiques } from './taches.js';
      
      const [commande, ...args] = process.argv.slice(2);
      
      function afficherAide() {
        console.log(`
      ${chalk.bold('Gestionnaire de tâches')}
      
        ${chalk.cyan('ajouter')} "titre"   ajoute une tâche
        ${chalk.cyan('lister')}            affiche toutes les tâches
        ${chalk.cyan('terminer')} <n°>     marque une tâche comme terminée
        ${chalk.cyan('supprimer')} <n°>    supprime une tâche
        ${chalk.cyan('stats')}             affiche le bilan
      `);
      }
      
      function afficherListe(taches) {
        if (taches.length === 0) return console.log(chalk.gray('Aucune tâche pour le moment.'));
        for (const t of taches) {
          const case_ = t.terminee ? chalk.green('[x]') : chalk.yellow('[ ]');
          const titre = t.terminee ? chalk.gray.strikethrough(t.titre) : t.titre;
          console.log(`${case_} ${chalk.bold(t.id)}. ${titre}`);
        }
      }
      
      try {
        let taches = await charger();
      
        switch (commande) {
          case 'ajouter':
            taches = ajouter(taches, args.join(' '));
            await enregistrer(taches);
            console.log(chalk.green(`Tâche ajoutée : ${taches.at(-1).titre}`));
            break;
          case 'lister':
            afficherListe(taches);
            break;
          case 'terminer':
            taches = terminer(taches, Number(args[0]));
            await enregistrer(taches);
            console.log(chalk.green(`Tâche n° ${args[0]} terminée.`));
            break;
          case 'supprimer':
            taches = supprimer(taches, Number(args[0]));
            await enregistrer(taches);
            console.log(chalk.green(`Tâche n° ${args[0]} supprimée.`));
            break;
          case 'stats': {
            const s = statistiques(taches);
            console.log(`${s.total} tâche(s) : ${chalk.green(s.terminees + ' terminée(s)')}, ${chalk.yellow(s.restantes + ' à faire')}`);
            break;
          }
          default:
            afficherAide();
        }
      } catch (erreur) {
        console.error(chalk.red(`Erreur : ${erreur.message}`));
        process.exitCode = 1;
      }

      process.exitCode = 1 signale l'échec au terminal (et aux scripts qui enchaînent avec &&) tout en laissant Node.js terminer proprement.

      Étape 5 : test/taches.test.js
      // taches.test.js : tests des règles de gestion avec le module natif node:test
      import { test } from 'node:test';
      import assert from 'node:assert/strict';
      import { ajouter, terminer, supprimer, statistiques } from '../src/taches.js';
      
      test('ajouter crée une tâche avec le numéro 1', () => {
        const taches = ajouter([], 'Lire le cours');
        assert.equal(taches.length, 1);
        assert.equal(taches[0].id, 1);
        assert.equal(taches[0].terminee, false);
      });
      
      test('ajouter refuse un titre vide', () => {
        assert.throws(() => ajouter([], '   '), /obligatoire/);
      });
      
      test('les numéros ne sont jamais réutilisés après une suppression', () => {
        let taches = ajouter(ajouter([], 'A'), 'B');   // n° 1 et 2
        taches = supprimer(taches, 1);
        taches = ajouter(taches, 'C');
        assert.deepEqual(taches.map((t) => t.id), [2, 3]);
      });
      
      test('terminer et statistiques', () => {
        let taches = ajouter(ajouter([], 'A'), 'B');
        taches = terminer(taches, 2);
        assert.deepEqual(statistiques(taches), { total: 2, terminees: 1, restantes: 1 });
      });
      
      test('terminer une tâche inexistante provoque une erreur', () => {
        assert.throws(() => terminer([], 5), /Aucune tâche n° 5/);
      });
      npm test
      …
      # tests 5
      # suites 0
      # pass 5
      # fail 0
      Étape 6 : installer la commande
      npm link
      added 1 package, and audited 3 packages in 310ms
      
      cd ..
      taches ajouter "Tester la commande globale"
      Tâche ajoutée : Tester la commande globale
      taches lister
      [ ] 1. Tester la commande globale

      Le fichier taches.json est créé dans le dossier courant : chaque dossier a donc sa propre liste. Pour une liste unique, définissez TACHES_FICHIER vers un chemin fixe, par exemple dans votre dossier personnel.

Cet article vous a-t-il aidé ?