Calculateur de compte épargne 💸

Par Nael Shiab

Dernière mise à jour le 13 novembre 2026

Bienvenue dans votre premier projet ! Notez que je m’attends à ce que vous ayez terminé les leçons de la section Fondamentaux de TypeScript. Si ce n’est pas le cas, commencez ici.

Dans ce projet, nous allons coder un calculateur de compte épargne. Cela vous permettra de pratiquer les bases que nous avons vues dans les leçons précédentes et de renforcer ces concepts avec un exemple concret.

Voici ce que vous verrez dans votre terminal à la fin de ce projet. Votre calculateur générera des taux d’intérêt annuels aléatoires, alors parfois vous gagnerez 📈, et parfois vous perdrez 📉 !

Quelle est la question ?

En journalisme (et dans de nombreux autres domaines), il est important d’identifier clairement la question à laquelle on veut répondre dès le début.

Voici la question à laquelle nous voulons répondre aujourd’hui :

• Combien pourrais-je gagner en plaçant mon argent sur un compte d’épargne ?

Dans mes projets, j’aime identifier un indicateur dès le début qui répondra à la question. Ici, l’indicateur serait la différence entre le montant initial et le solde final du compte.

En général, il y a également des variables ou des paramètres que l’on peut identifier dès le départ d’un projet. Voici quelques facteurs pouvant influencer les résultats :

• Le montant initial d’argent.
• Le taux d’intérêt du compte.
• La fluctuation du taux d’intérêt.
• Le nombre d’années pendant lesquelles l’argent restera dans le compte.

De plus, pour simplifier notre travail, décidons de travailler avec des taux annuels. Nous mettrons donc à jour le solde du compte une fois par an.

Avec cela en tête, nous pouvons commencer à coder notre calculateur !

Configuration

Créez un nouveau dossier vide sur votre ordinateur, ouvrez-le avec VS Code et créez-y un fichier nommé main.ts.

Tapez ce code dans main.ts et enregistrez le fichier :

console.log("Hello!");

Ouvrez le terminal (Command + J sur Mac ou Control + J sur Windows) et exécutez cette commande :

node --watch main.ts

Cette commande exécute notre code et le relance automatiquement chaque fois que nous enregistrons une modification, pour voir les résultats au fur et à mesure que nous travaillons.

Nombre d’années

Si l’argent reste dans le compte épargne pendant 10 ans, cela signifie que nous devons mettre à jour le solde 10 fois, une fois par an.

Cela semble être une tâche parfaite pour une boucle !

Commençons par itérer sur les années. Nous pouvons créer une variable years pour qu’il soit facile de modifier le nombre d’années souhaité et de relancer le script.

const years = 10;
 
for (let year = 0; year < years; year++) {
  console.log({ year });
}

Au lieu d’avoir des nombres de 0 à 9, il serait préférable d’avoir des années.

Ajoutons une variable startingYear et mettons à jour notre code.

Voici ce qui se passe maintenant avec notre boucle à la ligne 4 :

• let year = startingYear signifie que notre boucle commencera avec l’année 2025.
• year < startingYear + years signifie que notre boucle s’exécutera tant que year sera inférieur à 2025 + 10.
• year++ signifie que year augmentera de 1 à chaque itération.

const startingYear = 2025;
const years = 10;
 
for (let year = startingYear; year < startingYear + years; year++) {
  console.log({ year });
}

Pendant que nous y sommes, nous pourrions stocker chaque objet pour chaque année dans une liste nommée results et tout afficher sous forme de tableau.

const startingYear = 2025;
const years = 10;
 
const results = [];
 
for (let year = startingYear; year < startingYear + years; year++) {
  results.push({ year });
}
 
console.table(results);

Taux d’intérêt et solde

Passons maintenant à l’argent !

Nous pourrions créer trois nouvelles variables :

• initialAmount pour stocker l’argent que nous mettons dans le compte épargne au départ. J’ai mis 5 000 $.
• interestRate pour stocker le taux d’intérêt annuel. Je l’ai fixé à 2 %.
• balance, qui représente le solde du compte épargne. Cette variable devrait être créée avec let, car nous allons la mettre à jour chaque année dans notre boucle. Au départ, balance est égal à initialAmount.

const initialAmount = 5000;
const interestRate = 2;
const startingYear = 2025;
const years = 10;
 
let balance = initialAmount;
 
const results = [];
 
for (let year = startingYear; year < startingYear + years; year++) {
  results.push({ year });
}
 
console.table(results);

Dans notre boucle, nous pouvons maintenant créer la variable gainsOrLosses pour stocker les gains ou pertes pour chaque année, puis mettre à jour balance en conséquence.

Nous pouvons également ajouter gainsOrLosses et balance à notre liste results.

const initialAmount = 5000;
const interestRate = 2;
const startingYear = 2025;
const years = 10;
 
let balance = initialAmount;
 
const results = [];
 
for (let year = startingYear; year < startingYear + years; year++) {
  const gainsOrLosses = balance * (interestRate / 100);
 
  // C'est une façon plus courte d'écrire :
  // balance = balance + gainsOrLosses
  balance += gainsOrLosses;
 
  results.push({ year, gainsOrLosses, balance });
}
 
console.table(results);

Ça fonctionne ! Vous avez déjà un calculateur de compte épargne de base ! Voyez-vous les intérêts composés faire fructifier votre argent ? 💵

Améliorons-le maintenant.

Arrondir les valeurs

Par défaut, nos ordinateurs n’arrondissent pas les valeurs. Nous devons leur indiquer de le faire.

Pour cela, nous pouvons utiliser l’objet global Math. Il est toujours disponible lorsque vous codez et contient de nombreuses méthodes et constantes pratiques. Dans notre cas, nous utiliserons Math.round(), qui arrondit un number à l’entier le plus proche.

Ici, nous avons juste besoin d’arrondir gainsOrLosses.

const initialAmount = 5000;
const interestRate = 2;
const startingYear = 2025;
const years = 10;
 
let balance = initialAmount;
 
const results = [];
 
for (let year = startingYear; year < startingYear + years; year++) {
  const gainsOrLosses = Math.round(balance * (interestRate / 100));
 
  balance += gainsOrLosses;
 
  results.push({ year, gainsOrLosses, balance });
}
 
console.table(results);

Randomiser les taux d’intérêt

Cela fonctionne plutôt bien, mais dans la vie, les taux d’intérêt fluctuent au fil du temps.

Bien sûr, nous ne pouvons pas prédire l’avenir, mais nous pouvons randomiser le taux d’intérêt pour rendre les choses un peu plus intéressantes.

Pour cela, nous pouvons utiliser Math.random(), qui renvoie un nombre entre 0 inclus et 1 exclu.

Voyons cela en action en l’appelant dans notre boucle. Nous pouvons commenter console.table(results) pour l’instant.

const initialAmount = 5000;
const interestRate = 2;
const startingYear = 2025;
const years = 10;
 
let balance = initialAmount;
 
const results = [];
 
for (let year = startingYear; year < startingYear + years; year++) {
  console.log(Math.random());
 
  const gainsOrLosses = Math.round(balance * (interestRate / 100));
 
  balance += gainsOrLosses;
 
  results.push({ year, gainsOrLosses, balance });
}
 
// console.table(results);

À moins d’être extraordinairement chanceux, vous n’aurez pas les mêmes nombres que moi d’affichés dans le terminal. La seule certitude est que nous aurons tous les deux des nombres compris entre 0 et 1.

Pour randomiser notre taux d’intérêt (qui est actuellement 2), nous aimerions avoir quelque chose d’inférieur ou supérieur à 2, de manière aléatoire. Cette fluctuation pourrait être positive ou négative.

Pour obtenir un nombre aléatoire positif ou négatif, nous pouvons simplement soustraire 0.5 à nos nombres aléatoires.

const initialAmount = 5000;
const interestRate = 2;
const startingYear = 2025;
const years = 10;
 
let balance = initialAmount;
 
const results = [];
 
for (let year = startingYear; year < startingYear + years; year++) {
  console.log(Math.random() - 0.5);
 
  const gainsOrLosses = Math.round(balance * (interestRate / 100));
 
  balance += gainsOrLosses;
 
  results.push({ year, gainsOrLosses, balance });
}
 
// console.table(results);

Maintenant que nous avons des nombres aléatoires compris entre -0.5 et 0.5, nous devons décider de l’amplitude de ces fluctuations.

Nous pouvons créer une nouvelle variable interestRateRange. Je l’ai fixée à 20.

Si nous multiplions nos nombres aléatoires par cette amplitude, nous obtenons maintenant des valeurs aléatoires comprises entre -10 et 10. Cela ressemble à une excellente fluctuation de taux d’intérêt !

const initialAmount = 5000;
const interestRate = 2;
const interestRateRange = 20;
const startingYear = 2025;
const years = 10;
 
let balance = initialAmount;
 
const results = [];
 
for (let year = startingYear; year < startingYear + years; year++) {
  const randomNumber = Math.random() - 0.5;
  const randomFluctuation = randomNumber * interestRateRange;
  console.log(randomFluctuation);
 
  const gainsOrLosses = Math.round(balance * (interestRate / 100));
 
  balance += gainsOrLosses;
 
  results.push({ year, gainsOrLosses, balance });
}
 
// console.table(results);

Nous pouvons maintenant ajouter cette fluctuation à notre interestRate. Comme interestRate est défini à 2 % dans mon code, cela me donne un taux d’intérêt de 2 % ± 10 % pour une année donnée. Cela signifie que le taux d’intérêt tombera aléatoirement entre -8 % (une très mauvaise année) et 12 % (une performance incroyable) !

Mettons à jour notre code et affichons de nouveau notre tableau. Par souci de simplicité, nous pouvons également arrondir notre randomInterestRate. Maintenant, à chaque fois que vous sauvegardez (CMD + S sur Mac ou CTRL + S sur PC), vous verrez des résultats différents !

const initialAmount = 5000;
const interestRate = 2;
const interestRateRange = 20;
const startingYear = 2025;
const years = 10;
 
let balance = initialAmount;
 
const results = [];
 
for (let year = startingYear; year < startingYear + years; year++) {
  const randomNumber = Math.random() - 0.5;
  const randomFluctuation = randomNumber * interestRateRange;
  const randomInterestRate = Math.round(interestRate + randomFluctuation);
 
  const gainsOrLosses = Math.round(balance * (randomInterestRate / 100));
 
  balance += gainsOrLosses;
 
  results.push({
    year,
    interestRate: randomInterestRate,
    gainsOrLosses,
    balance,
  });
}
 
console.table(results);

Répondre à la question

Nous avons maintenant tout ce qu’il nous faut pour répondre à notre question.

Tout d’abord, récupérons le dernier objet dans notre liste results. Cet objet contient le solde final.

En l’utilisant, nous pouvons calculer les pertes ou gains finaux et afficher la réponse appropriée.

const initialAmount = 5000;
const interestRate = 2;
const interestRateRange = 20;
const startingYear = 2025;
const years = 10;
 
let balance = initialAmount;
 
const results = [];
 
for (let year = startingYear; year < startingYear + years; year++) {
  const randomNumber = Math.random() - 0.5;
  const randomFluctuation = randomNumber * interestRateRange;
  const randomInterestRate = Math.round(interestRate + randomFluctuation);
 
  const gainsOrLosses = Math.round(balance * (randomInterestRate / 100));
 
  balance += gainsOrLosses;
 
  results.push({
    year,
    interestRate: randomInterestRate,
    gainsOrLosses,
    balance,
  });
}
 
// Comme les index commencent à 0,
// l'index du dernier élément
// est le nombre d'éléments moins 1.
const lastResult = results[results.length - 1];
const finalGainsOrLosses = lastResult.balance - initialAmount;
 
if (finalGainsOrLosses > 0) {
  console.log("\nCongratulations! You've made money!\n");
} else if (finalGainsOrLosses < 0) {
  console.log("\nSorry! You've lost money!\n");
} else {
  console.log("\nYou've neither lost nor gained money!\n");
}
 
console.table(results);

Ce serait une bonne chose d’ajouter plus de détails, comme les gains ou pertes réalisés, à la fois en chiffres absolus et en pourcentage.

const initialAmount = 5000;
const interestRate = 2;
const interestRateRange = 20;
const startingYear = 2025;
const years = 10;
 
let balance = initialAmount;
 
const results = [];
 
for (let year = startingYear; year < startingYear + years; year++) {
  const randomNumber = Math.random() - 0.5;
  const randomFluctuation = randomNumber * interestRateRange;
  const randomInterestRate = Math.round(interestRate + randomFluctuation);
 
  const gainsOrLosses = Math.round(balance * (randomInterestRate / 100));
 
  balance += gainsOrLosses;
 
  results.push({
    year,
    interestRate: randomInterestRate,
    gainsOrLosses,
    balance,
  });
}
 
const lastResult = results[results.length - 1];
const finalGainsOrLosses = lastResult.balance - initialAmount;
const perc = Math.round(
  (finalGainsOrLosses / initialAmount) * 100,
);
 
if (finalGainsOrLosses > 0) {
  console.log(`
Congratulations! You've made money!
Initial amount: $${initialAmount}
Final amount: $${lastResult.balance}
Gains: $${finalGainsOrLosses} (+${perc}%)
`);
} else if (finalGainsOrLosses < 0) {
  console.log(`
Sorry! You've lost money!
Initial amount: $${initialAmount}
Final amount: $${lastResult.balance}
Losses: $${finalGainsOrLosses} (${perc}%)
`);
} else {
  console.log("\nYou've neither lost nor gained money!\n");
}
 
console.table(results);

Félicitations !

Wow ! Vous venez de coder votre premier projet concret avec TypeScript. Vous pouvez être fier de vous.

Ajustez les valeurs. Changez les paramètres. Amusez-vous !

Ce n’est que le début. Maintenant que vous connaissez les bases, qui sait jusqu’où tout cela vous mènera ? 🚀