Node.js : Coder une liste de tâches ou todo pas à pas

Il y a quelque chose de presque magique dans le fait de créer une application simple, utile et concrète avec Node.js. Vous tapez quelques lignes, vous relancez le serveur, et soudain votre projet prend forme sous vos yeux. C’est exactement ce que l’on va faire ici. Si vous débutez, ne vous inquiétez pas : vous serez guidé de manière progressive, avec des explications détaillées et un langage accessible. L’objectif est de vous permettre de comprendre chaque étape, pas simplement de recopier du code.

La création d’une liste de tâches peut sembler banale, pourtant c’est un exercice incroyablement formateur pour découvrir le fonctionnement de Node.js. Ce petit projet vous permettra de comprendre comment créer un serveur, stocker des données, gérer des routes et manipuler les requêtes et réponses. C’est un excellent entraînement pour tous ceux qui souhaitent se lancer dans des projets plus ambitieux par la suite.

• Comprendre concrètement comment créer une application complète en Node.js, depuis le serveur jusqu’à la gestion des données.
• Savoir construire une API capable de gérer des tâches, avec ajout, modification, suppression et sauvegarde persistante.
• Être capable de relier un backend Node.js à une interface simple pour obtenir une liste de tâches fonctionnelle et évolutive.

Comprendre Node.js avant de coder une vraie liste de tâches

Avant de créer une application de gestion de tâches, il est essentiel de comprendre sur quoi repose Node.js. L’idée n’est pas de vous assommer avec de la théorie compliquée, mais plutôt de vous montrer les bases indispensables pour avancer avec confiance.

Qu’est-ce que Node.js exactement ?

Node.js est une plateforme qui vous permet d’exécuter du JavaScript en dehors du navigateur. Pendant longtemps, JavaScript était limité aux pages web. Avec Node.js, ce langage devient capable de faire tourner des serveurs, dialoguer avec des bases de données, manipuler des fichiers, ou même piloter des robots.

Node.js se distingue par une manière de fonctionner très fluide, basée sur un moteur asynchrone. Cela signifie qu’il peut gérer plusieurs actions en même temps sans perdre en performance. Pour une liste de tâches, cela semble peut-être anodin, mais dans des applications plus grandes, cette capacité fait toute la différence.

Pourquoi Node.js est idéal pour un projet de liste de tâches ?

Une liste de tâches implique plusieurs opérations essentielles : récupérer des données, en ajouter, en supprimer, afficher le tout au navigateur. Node.js simplifie ces opérations car il a été pensé pour gérer facilement les requêtes HTTP. En d’autres termes, vous construisez un serveur qui écoute vos demandes et leur répond.

Pour apprendre, une liste de tâches est un terrain de jeu idéal. Ce projet vous oblige à comprendre les fondations du développement backend, sans vous perdre dans des détails techniques trop lourds. À la fin, vous aurez un véritable mini-service web fonctionnel, totalement construit de vos mains.

Préparer l’environnement de travail

C’est souvent l’étape que les débutants redoutent le plus. Pourtant, avec un peu de méthode, tout se passe très bien. Vous allez voir que la préparation est simple et rapide.

Installer Node.js sur votre machine

Dans la plupart des cas, il suffit de télécharger Node.js depuis son site officiel. Après l’installation, vous pouvez vérifier que tout fonctionne grâce à deux petites commandes :

• node -v affiche la version de Node.js installée
• npm -v affiche la version de npm, le gestionnaire de paquets intégré

Si ces deux commandes répondent correctement, vous êtes prêt à commencer.

Créer le dossier de votre projet

Vous pouvez créer un dossier nommé, par exemple, todo-nodejs. À l’intérieur, vous initialisez votre projet avec la commande :

npm init -y

Cette commande génère un fichier très important : package.json. Ce fichier sert à organiser votre projet et à déclarer vos dépendances. Même si vous ne comprenez pas tout tout de suite, vous verrez que son rôle deviendra clair au fil du tutoriel.

Construire votre premier serveur Node.js

C’est l’une des étapes les plus satisfaisantes : transformer un simple fichier JavaScript en un serveur capable d’écouter et de répondre à vos requêtes.

Créer le fichier principal

Dans votre dossier, créez un fichier nommé server.js. Ce fichier va contenir votre code backend. Pour l’instant, allez droit au but et ajoutez un petit serveur minimaliste :

const http = require('http');

const server = http.createServer((req, res) => {
    res.writeHead(200, { 'Content-Type': 'text/plain' });
    res.end('Votre serveur Node.js fonctionne');
});

server.listen(3000, () => {
    console.log('Serveur démarré sur https://localhost:3000');
});

Ce code fait trois choses très importantes. Il crée un serveur HTTP, définit la manière dont il répondra à vos requêtes, et l’écoute sur le port 3000. Ouvrez votre navigateur et tapez l’adresse indiquée dans la console. Si le message apparaît, votre serveur fonctionne.

Comment fonctionne réellement ce serveur ?

Lorsqu’un utilisateur tape une adresse dans son navigateur, celui-ci envoie une requête HTTP. Votre serveur l’intercepte et décide quoi renvoyer. Pour le moment, votre réponse est très simple, mais nous allons progressivement la complexifier pour gérer une véritable liste de tâches.

Node.js fonctionne de manière asynchrone. Cela signifie que tant que vous ne renvoyez pas de réponse, il reste en attente. Dès que vous utilisez res.end(), la communication est terminée et la réponse part vers le navigateur.

Passer d’un simple serveur à une vraie API

Un serveur sans routes, c’est comme un téléphone sans touches : ça ne sert pas à grand-chose. Vous allez maintenant apprendre à créer des routes afin de gérer différentes fonctionnalités.

Gérer plusieurs routes à la main

Avant d’utiliser un framework comme Express, il est instructif de voir comment Node.js gère les routes en natif. Ajoutez ceci dans votre server.js :

const http = require('http');

let tasks = [];

const server = http.createServer((req, res) => {
    if (req.url === '/tasks' && req.method === 'GET') {
        res.writeHead(200, { 'Content-Type': 'application/json' });
        res.end(JSON.stringify(tasks));
    }

    else if (req.url === '/tasks' && req.method === 'POST') {
        let body = '';
        req.on('data', chunk => {
            body += chunk.toString();
        });

        req.on('end', () => {
            const newTask = JSON.parse(body);
            tasks.push(newTask);
            res.writeHead(201, { 'Content-Type': 'application/json' });
            res.end(JSON.stringify(newTask));
        });
    }

    else {
        res.writeHead(404, { 'Content-Type': 'text/plain' });
        res.end('Route introuvable');
    }
});

server.listen(3000);

Vous avez maintenant deux routes fonctionnelles :

• Une route GET pour récupérer les tâches
• Une route POST pour ajouter une tâche

Et mine de rien, vous venez de créer la base d’une API.

Comprendre ce qu’est une API

Une API est un système qui permet à différents logiciels de communiquer. Dans ce cas, votre navigateur et votre serveur échangent des données au format JSON. Cette manière d’échanger est devenue un standard parce qu’elle est lisible, simple à mettre en place et compatible avec quasiment tous les langages modernes.

Améliorer votre API et enrichir votre liste de tâches

À ce stade, votre application commence à ressembler à quelque chose. Vous avez un serveur Node.js fonctionnel, une structure de données, et deux routes capables d’échanger des informations. Pourtant, une vraie liste de tâches a besoin d’un peu plus. Il faut pouvoir supprimer une tâche, la modifier, peut-être lui attribuer un identifiant, et surtout éviter de tout perdre lorsque vous redémarrez le serveur.

Vous allez voir que cette étape est particulièrement formatrice. Beaucoup de développeurs commettent l’erreur d’aller trop vite, mais prendre le temps de créer soi-même ces routes permet de comprendre en profondeur le fonctionnement d’une API.

Ajouter un identifiant unique à chaque tâche

Aujourd’hui, vos tâches sont simplement stockées dans un tableau. Le problème, c’est qu’une tâche n’a pas d’identifiant propre. Cela rend difficile la suppression ou la mise à jour d’un élément précis. Vous allez donc améliorer la structure de vos données en attribuant à chaque tâche un identifiant généré automatiquement.

Dans le même fichier, modifiez la partie POST ainsi :

else if (req.url === '/tasks' && req.method === 'POST') {
    let body = '';
    req.on('data', chunk => {
        body += chunk.toString();
    });

    req.on('end', () => {
        const newTaskData = JSON.parse(body);
        const newTask = {
            id: Date.now(),
            title: newTaskData.title,
            done: false
        };
        tasks.push(newTask);

        res.writeHead(201, { 'Content-Type': 'application/json' });
        res.end(JSON.stringify(newTask));
    });
}

Pourquoi utiliser Date.now() ? Pour un débutant, c’est la solution la plus simple, car la valeur générée est toujours unique à la milliseconde près. Vous n’avez donc pas à installer de librairie pour gérer les identifiants. Ce n’est pas parfait pour les très gros projets, mais pour une liste de tâches locale, c’est largement suffisant.

Supprimer une tâche existante

Une fonction indispensable dans une liste de tâches est la suppression. Que ce soit pour effacer une tâche accomplie ou corriger une erreur, l’utilisateur doit pouvoir retirer un élément.

Ajoutez ce bloc :

else if (req.url.startsWith('/tasks/') && req.method === 'DELETE') {
    const id = parseInt(req.url.split('/')[2]);

    const index = tasks.findIndex(task => task.id === id);

    if (index !== -1) {
        const deleted = tasks.splice(index, 1)[0];
        res.writeHead(200, { 'Content-Type': 'application/json' });
        res.end(JSON.stringify(deleted));
    } else {
        res.writeHead(404, { 'Content-Type': 'text/plain' });
        res.end('Tâche introuvable');
    }
}

À travers ce code, vous venez d’apprendre un concept central dans toutes les API modernes : l’extraction de paramètres depuis l’URL. En effet, l’identifiant de la tâche se trouve après /tasks/, d’où l’intérêt d’un split.

Petit détail technique : vous utilisez ici la méthode DELETE, parfaitement adaptée pour supprimer une ressource. Ce respect des conventions HTTP est important si, plus tard, vous décidez de connecter votre API à un frontend moderne ou à une application mobile.

Marquer une tâche comme terminée

Parfois, vous ne voulez pas supprimer une tâche. Vous voulez simplement la mettre à jour. C’est exactement ce que vous allez faire ici.

Ajoutez cette nouvelle route :

else if (req.url.startsWith('/tasks/') && req.method === 'PUT') {
    let body = '';
    req.on('data', chunk => {
        body += chunk.toString();
    });

    req.on('end', () => {
        const id = parseInt(req.url.split('/')[2]);
        const updatedData = JSON.parse(body);

        const task = tasks.find(t => t.id === id);

        if (task) {
            task.title = updatedData.title ?? task.title;
            task.done = updatedData.done ?? task.done;

            res.writeHead(200, { 'Content-Type': 'application/json' });
            res.end(JSON.stringify(task));
        } else {
            res.writeHead(404, { 'Content-Type': 'text/plain' });
            res.end('Tâche introuvable');
        }
    });
}

Vous venez d’ajouter une véritable fonctionnalité de mise à jour. Votre API sait désormais :

• gérer l’ajout,
• gérer la lecture,
• gérer la suppression,
• et modifier une ressource existante.

À ce stade, vous pourriez presque brancher un frontend complet… mais nous allons d’abord simplifier votre vie avec Express.

Passer au framework Express pour gagner en confort

Node.js est puissant, mais gérer manuellement toutes les routes devient rapidement épuisant. C’est un peu comme bricoler une étagère sans tournevis : on peut le faire, mais c’est franchement laborieux. Express est ce fameux tournevis.

Ce framework est très populaire car il simplifie énormément la gestion des requêtes, des réponses, et de la structure d’un projet. Beaucoup de développeurs l’utilisent quotidiennement, car il permet de gagner du temps sans sacrifier la compréhension.

Installer Express. Dans votre terminal, tapez simplement :

npm install express

Votre fichier package.json ajoutera automatiquement Express à vos dépendances, ce qui signifie que votre projet saura qu’il en a besoin pour fonctionner.

Réécrire votre serveur avec Express

Créez un nouveau fichier nommé app.js. Voici une première version simplifiée :

const express = require('express');
const app = express();
const port = 3000;

app.use(express.json());

let tasks = [];

app.get('/tasks', (req, res) => {
    res.json(tasks);
});

app.post('/tasks', (req, res) => {
    const newTask = {
        id: Date.now(),
        title: req.body.title,
        done: false
    };
    tasks.push(newTask);
    res.status(201).json(newTask);
});

app.delete('/tasks/:id', (req, res) => {
    const id = parseInt(req.params.id);
    const index = tasks.findIndex(task => task.id === id);

    if (index !== -1) {
        const deleted = tasks.splice(index, 1)[0];
        res.json(deleted);
    } else {
        res.status(404).send('Tâche introuvable');
    }
});

app.put('/tasks/:id', (req, res) => {
    const id = parseInt(req.params.id);
    const task = tasks.find(t => t.id === id);

    if (task) {
        task.title = req.body.title ?? task.title;
        task.done = req.body.done ?? task.done;
        res.json(task);
    } else {
        res.status(404).send('Tâche introuvable');
    }
});

app.listen(port, () => {
    console.log(`Serveur Express lancé sur https://localhost:${port}`);
});

Cette fois, votre API paraît déjà bien plus claire. Express rend la lecture du code plus fluide, plus logique. Vous récupérez facilement les paramètres, les routes sont plus lisibles, et les réponses sont plus simples à renvoyer.

C’est pour cette raison qu’Express est utilisé depuis des années par des milliers de développeurs professionnels. Pour une liste de tâches comme pour une API très complexe, il offre une base solide et élégante.

Pourquoi Express est plus agréable au quotidien ?

En réalité, Express vous retire une grande quantité de travail invisible. Par exemple, sans Express :

• Vous devez gérer l’analyse du body.
• Vous devez construire les en-têtes HTTP à la main.
• Vous devez parcourir l’URL pour trouver les paramètres.
• Vous devez créer vos propres systèmes de gestion des routes.

Avec Express, toutes ces tâches sont automatisées, ce qui vous laisse vous concentrer sur le vrai but : votre application et vos fonctionnalités.

Une anecdote pour illustrer : un développeur m’avait confié qu’il avait passé un mois entier à inventer son propre mini-framework… avant de découvrir Express. Après avoir migré son code, il a réduit son projet de 800 lignes à 200. Et il m’a avoué que le plus dur avait été de reconnaître que la solution existait déjà.

Construire un mini frontend pour afficher votre liste de tâches

Une API, c’est bien. Mais ce qui plaît le plus, c’est de voir le résultat dans un navigateur. Vous allez créer une page HTML très simple, capable d’interagir avec votre API Node.js. L’objectif ici n’est pas d’écrire un chef-d’œuvre graphique, mais de comprendre comment relier un backend à une interface.

Créer un fichier index.html

Dans un nouveau dossier nommé public, créez ce fichier :

<!DOCTYPE html>
<html lang="fr">
<head>
    <meta charset="UTF-8">
    <title>Liste de tâches Node.js</title>
</head>
<body>
    <h1>Ma liste de tâches</h1>

    <input id="taskInput" type="text" placeholder="Nouvelle tâche">
    <button onclick="addTask()">Ajouter</button>

    <ul id="taskList"></ul>

    <script>
        async function loadTasks() {
            const response = await fetch('/tasks');
            const tasks = await response.json();

            const list = document.getElementById('taskList');
            list.innerHTML = '';

            tasks.forEach(t => {
                const li = document.createElement('li');
                li.textContent = t.title + (t.done ? ' (terminée)' : '');
                li.onclick = () => toggleDone(t.id, !t.done);
                list.appendChild(li);
            });
        }

        async function addTask() {
            const input = document.getElementById('taskInput');

            await fetch('/tasks', {
                method: 'POST',
                headers: { 'Content-Type': 'application/json' },
                body: JSON.stringify({ title: input.value })
            });

            input.value = '';
            loadTasks();
        }

        async function toggleDone(id, done) {
            await fetch('/tasks/' + id, {
                method: 'PUT',
                headers: { 'Content-Type': 'application/json' },
                body: JSON.stringify({ done })
            });

            loadTasks();
        }

        loadTasks();
    </script>
</body>
</html>

Cette page fait trois choses essentielles. Elle récupère les tâches au chargement, permet d’en ajouter, et gère le changement d’état lorsqu’une tâche est cliquée.

Servir ce fichier via Express

Dans app.js, ajoutez en haut :

app.use(express.static('public'));

Votre frontend peut maintenant communiquer directement avec votre API.

Enregistrer vos tâches dans un fichier pour éviter de tout perdre

Jusqu’ici, votre liste de tâches fonctionne… mais uniquement tant que votre serveur reste allumé. Dès que vous le redémarrez, le tableau se réinitialise. C’est normal, car vos données vivent uniquement en mémoire. Pour rendre l’application vraiment utile, vous devez permettre à votre API de sauvegarder et de charger les tâches à partir d’un fichier.

C’est une étape essentielle pour comprendre comment un backend traite la persistance des données. Que vous utilisiez un fichier JSON, une base de données SQLite ou MongoDB, le principe reste le même : stocker l’information quelque part en dehors de la mémoire vive.

Utiliser le module File System de Node.js

Node.js intègre un module natif nommé fs. Il vous permet d’interagir avec les fichiers comme vous le feriez depuis votre explorateur. Il peut créer, lire, écrire et supprimer des fichiers. Pour votre projet, il sera parfait.

Commencez par importer fs en haut de votre app.js :

const fs = require('fs');

Créer une fonction pour charger les tâches au démarrage

Ajoutez ceci juste après votre tableau tasks :

function loadTasks() {
    try {
        const data = fs.readFileSync('tasks.json', 'utf8');
        tasks = JSON.parse(data);
    } catch (error) {
        tasks = [];
    }
}

Cette fonction fait une chose très simple : elle tente de lire un fichier nommé tasks.json. S’il existe, son contenu est injecté dans votre tableau tasks. S’il n’existe pas, elle initialise un tableau vide.

Ensuite, appelez cette fonction avant de déclarer vos routes :

Des formations informatique pour tous !

Débutant ou curieux ? Apprenez le développement web, le référencement, le webmarketing, la bureautique, à maîtriser vos appareils Apple et bien plus encore…

Formateur indépendant, professionnel du web depuis 2006, je vous accompagne pas à pas et en cours particulier, que vous soyez débutant ou que vous souhaitiez progresser. En visio, à votre rythme, et toujours avec pédagogie.

Découvrez mes formations Qui suis-je ?

loadTasks();

Vous venez d’ajouter un système de stockage persistant. C’est rudimentaire, mais déjà très utile.

Enregistrer les tâches à chaque modification

Maintenant que vous savez charger les données, vous devez aussi les enregistrer à chaque fois qu’une nouvelle tâche est ajoutée, supprimée ou modifiée.

Ajoutez une fonction dédiée :

function saveTasks() {
    fs.writeFileSync('tasks.json', JSON.stringify(tasks, null, 2));
}

La méthode writeFileSync enregistre le tableau dans un fichier JSON. Le paramètre null, 2 sert uniquement à rendre le fichier lisible, avec des sauts de ligne.

Ensuite, appelez cette fonction dans vos routes POST, PUT et DELETE :

tasks.push(newTask);
saveTasks();

tasks.splice(index, 1)[0];
saveTasks();

task.done = req.body.done ?? task.done;
saveTasks();

Votre API dispose maintenant d’un véritable petit système de stockage. Si demain vous la déployez sur un serveur ou si vous la faites évoluer vers une base de données, cette logique vous sera très utile.

Structurer votre projet Node.js comme un professionnel

Pour l’instant, votre fichier app.js devient un peu long. Ce n’est pas dramatique pour un petit projet, mais il est important de prendre de bonnes habitudes. Une bonne structure de projet vous permet d’être plus clair, plus organisé et d’éviter les bugs liés à des fichiers trop volumineux.

Pourquoi structurer un projet ?

Parce qu’à mesure que votre API grandit, vous devrez ajouter :

• des middlewares,
• des contrôleurs,
• des modèles,
• des tests,
• et peut-être même une couche de services.

Même si vous n’avez pas encore besoin de tout cela, il est très formateur de séparer vos routes et votre logique métier.

Créer un dossier routes

Commencez par créer un dossier nommé routes. À l’intérieur, créez un fichier tasks.js :

const express = require('express');
const router = express.Router();

let tasks = [];
const fs = require('fs');

function loadTasks() {
    try {
        const data = fs.readFileSync('tasks.json', 'utf8');
        tasks = JSON.parse(data);
    } catch (err) { tasks = []; }
}

function saveTasks() {
    fs.writeFileSync('tasks.json', JSON.stringify(tasks, null, 2));
}

loadTasks();

router.get('/', (req, res) => {
    res.json(tasks);
});

router.post('/', (req, res) => {
    const newTask = {
        id: Date.now(),
        title: req.body.title,
        done: false
    };
    tasks.push(newTask);
    saveTasks();
    res.status(201).json(newTask);
});

router.delete('/:id', (req, res) => {
    const id = parseInt(req.params.id);
    const index = tasks.findIndex(t => t.id === id);

    if (index !== -1) {
        const deleted = tasks.splice(index, 1)[0];
        saveTasks();
        res.json(deleted);
    } else {
        res.status(404).send('Tâche introuvable');
    }
});

router.put('/:id', (req, res) => {
    const id = parseInt(req.params.id);
    const task = tasks.find(t => t.id === id);

    if (task) {
        task.title = req.body.title ?? task.title;
        task.done = req.body.done ?? task.done;
        saveTasks();
        res.json(task);
    } else {
        res.status(404).send('Tâche introuvable');
    }
});

module.exports = router;

Ensuite, dans app.js, simplifiez vos routes à une seule ligne :

const tasksRouter = require('./routes/tasks');
app.use('/tasks', tasksRouter);

Votre projet commence à ressembler à quelque chose de beaucoup plus propre. Même si ce n’est qu’une application de liste de tâches, vous avez mis en place les bases que l’on retrouve dans des API professionnelles.

Améliorer les performances et l’expérience utilisateur

Maintenant que votre API fonctionne parfaitement, vous pouvez aller plus loin. Une application de liste de tâches peut sembler simple, mais elle offre un terrain idéal pour découvrir plusieurs notions importantes en développement backend.

Gérer les erreurs proprement

Rien n’est plus frustrant, en tant qu’utilisateur, que de voir un message d’erreur incompréhensible ou pire : rien du tout. Pour éviter cela, Express permet d’ajouter un middleware de gestion des erreurs.

Ajoutez ceci à la fin de app.js :

app.use((err, req, res, next) => {
    console.error('Erreur serveur :', err);
    res.status(500).send('Une erreur est survenue');
});

Ce système vous évite d’afficher des crashs bruts dans la console, ce qui est toujours mieux si vous envisagez un jour de déployer votre API.

Ajouter un délai d’attente sur les réponses

Parfois, introduire un petit délai peut être utile pour simuler des conditions réelles ou éviter de surcharger le serveur. Pour cela, vous pouvez créer un middleware simple :

app.use((req, res, next) => {
    setTimeout(next, 100);
});

Ce n’est qu’un exemple pédagogique, mais il montre à quel point Express simplifie la manipulation du cycle de requêtes.

Améliorer votre frontend

Votre page HTML fonctionne, mais elle peut être rendue plus agréable. Par exemple, vous pouvez afficher un style visuel différent pour les tâches terminées :

<li style="text-decoration: line-through;">Tâche terminée</li>

Ou encore ajouter une suppression sur un clic droit, ou un bouton dédié.

Ce travail frontend n’est pas obligatoire pour apprendre Node.js, mais il est satisfaisant. Voir son application prendre forme visuellement est souvent l’un des moteurs les plus puissants lorsque l’on débute.

Ajouter de nouvelles fonctionnalités à votre liste de tâches

À ce stade, vous possédez déjà une application complète. Pourtant, une liste de tâches est un terrain idéal pour expérimenter. Vous pouvez par exemple ajouter :

• la possibilité de trier les tâches par date,
• un filtre pour n’afficher que celles qui ne sont pas terminées,
• une mention de la date de création,
• des catégories,
• des priorités,
• ou même un système d’authentification simple.

Ces fonctionnalités ne sont pas obligatoires, mais elles vous permettront d’aller toujours plus loin avec Node.js, tout en améliorant votre maîtrise du JavaScript moderne.

Ajouter quelques fonctionnalités avancées pour aller encore plus loin

Même si votre application de liste de tâches fonctionne déjà très bien, vous pouvez la transformer en un petit atelier d’expérimentation. C’est l’un des avantages des projets simples : ils servent de terrain d’entraînement pour tester de nouvelles idées. Chaque ajout vous permet de mieux comprendre Node.js, ses possibilités, et la manière dont un backend communique avec un frontend.

Ajouter une date de création à chaque tâche

Pour améliorer l’expérience utilisateur, vous pouvez enregistrer la date et l’heure exactes de la création d’une tâche. Cela permet d’avoir une vision plus claire de l’évolution du travail. Cette modification est très simple à réaliser :

const newTask = {
    id: Date.now(),
    title: req.body.title,
    done: false,
    createdAt: new Date().toISOString()
};

Cette seule ligne ajoute une dimension temporelle au projet, ce qui ouvre la voie à de nombreuses extensions. Par exemple, trier les tâches par date, ou afficher combien de temps s’est écoulé depuis leur création. Cela aide aussi à réfléchir comme un développeur expérimenté : une donnée simple peut débloquer des fonctionnalités puissantes.

Ajouter une priorité aux tâches

Parfois, une liste de tâches devient vite encombrée. Vous pouvez donc introduire un niveau de priorité, comme faible, normal ou urgent. Vous pouvez l’ajouter de la même manière :

priority: req.body.priority ?? 'normal'

Bien sûr, vous devrez mettre à jour votre frontend pour permettre à l’utilisateur de sélectionner cette priorité. Ce genre de modification vous habitue à penser à la fois côté backend et côté interface, ce qui est essentiel dans le développement moderne.

Trier et filtrer les tâches

Une liste trop longue perd rapidement son intérêt. Pour simplifier la lecture, vous pouvez ajouter des routes dédiées au filtrage. Par exemple, afficher uniquement les tâches non terminées :

router.get('/undone', (req, res) => {
    const undone = tasks.filter(t => !t.done);
    res.json(undone);
});

Ou classer vos tâches par date :

router.get('/sorted/date', (req, res) => {
    const sorted = [...tasks].sort((a, b) => a.createdAt.localeCompare(b.createdAt));
    res.json(sorted);
});

Même si cela peut sembler secondaire, ce genre de fonctionnalités vous apprend quelque chose d’important : une API doit être pensée pour le long terme. Aujourd’hui, ce projet est un exercice. Mais demain, vous pourriez créer des outils pour des entreprises, des sites e-commerce, ou même votre propre plateforme personnelle.

Quelques bonnes pratiques Node.js pour progresser rapidement

Il existe quelques règles que les développeurs professionnels appliquent systématiquement lorsqu’ils travaillent sur un projet Node.js. Les appliquer tôt vous fera gagner un temps considérable plus tard.

Ne jamais bloquer le thread principal inutilement

Node.js fonctionne sur un seul thread. Cela signifie qu’une opération trop lourde peut bloquer tout votre serveur. C’est pour cette raison que les fonctions asynchrones sont si importantes. Pour charger un fichier, préférez :

fs.readFile()

au lieu de sa version synchrone readFileSync, sauf pour des cas pédagogiques comme ici. Quand votre application deviendra plus grande, il faudra privilégier le modèle asynchrone pour éviter les ralentissements.

Toujours valider les données reçues

Votre API reçoit des informations depuis l’extérieur. Même si vous travaillez seul sur votre projet, prendre l’habitude de vérifier les données entrantes est indispensable.

Par exemple :

if (typeof req.body.title !== 'string' || req.body.title.trim() === '') {
    return res.status(400).send('Titre invalide');
}

Cette vérification simple renforce votre API et évite des bugs difficiles à diagnostiquer.

Bien nommer vos fonctions et vos routes

Un bon nom doit être compréhensible immédiatement. Plus tard, lorsque vous reviendrez sur votre code après plusieurs semaines, vous serez heureux de comprendre tout de suite ce que vous avez fait.

Un développeur a toujours retrouvé une fonction nommée « trucMachinBidule » écrite deux ans plus tôt. Non seulement il ne se souviendra pas de son utilité, mais il n’arrivera même plus à comprendre pourquoi elle existe. Croyez-moi, cela fait sourire sur le moment, mais ce n’est pas agréable.

Sécuriser votre petite application

Même si votre liste de tâches n’est pas destinée à accueillir des milliers d’utilisateurs, c’est une bonne occasion pour aborder deux notions essentielles : la sécurité et la robustesse.

Empêcher les attaques basiques grâce aux en-têtes HTTP

Vous pouvez améliorer la sécurité en ajoutant le module helmet. Il configure automatiquement des en-têtes HTTP protecteurs.

Installez-le :

npm install helmet

Puis activez-le dans votre app.js :

const helmet = require('helmet');
app.use(helmet());

C’est une première protection simple mais efficace, très souvent présente sur les applications Node.js professionnelles.

Limiter la taille des requêtes

Pour éviter qu’un utilisateur (ou un robot) n’envoie une requête gigantesque à votre serveur, vous pouvez limiter la taille du body JSON :

app.use(express.json({ limit: '50kb' }));

Là encore, c’est une habitude saine à conserver.

Préparer votre projet pour une future mise en production

Même si votre liste de tâches reste un exercice, il peut être intéressant de simuler une mise en production. Cela vous aide à comprendre comment vos futurs projets web seront déployés.

Créer un script de démarrage

Dans votre package.json, ajoutez :

"scripts": {
    "start": "node app.js"
}

Cela permet de lancer votre serveur proprement avec :

npm start

Une bonne pratique pour garder un projet propre et standardisé.

Utiliser un gestionnaire de processus

Lorsque vous déployez un serveur Node.js, il ne doit jamais s’arrêter automatiquement en cas d’erreur. L’outil PM2 sert justement à ça. Pour un simple exercice, ce n’est pas indispensable, mais connaître son existence vous sera utile.

npm install pm2 -g
pm2 start app.js

PM2 relance votre application si elle s’arrête, surveille votre consommation et vous aide à gérer vos logs.

Plus qu’une liste de tâches, un vrai premier projet Node.js

Créer une liste de tâches en Node.js peut sembler trivial, mais lorsque l’on prend le temps d’avancer étape par étape, c’est en réalité un apprentissage extrêmement riche. Vous avez découvert comment faire fonctionner un serveur, comment créer une API, comment traiter des requêtes, comment stocker des données et comment relier un backend à une petite interface web. Vous avez même approché des notions professionnelles comme la structuration d’un projet, la validation des données ou la sécurité.

Si vous débutez en Node.js, ce type de projet est probablement l’un des meilleurs points de départ. Il ne demande pas de connaissances avancées, mais il vous pousse à toucher à des sujets essentiels que vous retrouverez dans tous les projets modernes. Vous avez manipulé les routes, les méthodes HTTP, Express, le stockage JSON, et même les middlewares. Autant de notions que vous reverrez dans la majorité des API que vous serez amené à développer.

Enfin, n’oubliez pas que ce petit exercice peut devenir votre laboratoire personnel. Vous pouvez continuer à le faire évoluer, ajouter de nouvelles fonctionnalités, tester d’autres outils, ou même le connecter à une vraie base de données. Chaque amélioration vous permettra de progresser un peu plus, et surtout de gagner en confiance. Le principal, c’est d’oser pousser les portes, d’expérimenter, et de comprendre ce qui se cache derrière chaque ligne de code.

Alban

Fondateur de l’agence Créa-troyes, affiliée France Num
Intervenant en Freelance.
Contactez-moi

crea-troyes.fr