Calculer son impôt sur le revenu

Le but de ce programme est de calculer la part d’impôt sur le revenu qu’on doit payer en fonction des différents seuils disponible sur le site : https://www.service-public.fr/particuliers/actualites/A13782

Bien évidement, ce n’est qu’un prétexte pour réaliser un exercice se calant sur un contexte réel.

Mais qui sait, un petit exercice peut déboucher sur un projet.

Alors le principe de l’impôt sur le revenu, se base sur ce qu’on nomme un impôts progressif. C’est un principe différents de la TVA qui elle repose sur le principe d’un impôt proportionnel.

Dans un impôt proportionnel on paye une somme proportionnel à ce qu’on gagne.

Or dans un impôt progressif, il y a plusieurs seuils, et le taux change pour chaque tranche.

Si vous avez un peu de mémoire, vous devez vous rappeler qu’en 2012 François Hollande avait proposé une nouvelle tranche avec un taux de 75% pour la fraction de revenu supérieur à 1 000 000 €. Et finalement le conseil constitutionnel avait refusé, car le taux était trop élevé et donc considéré comme spoliatoire.

Donc le but de notre script c’est de renseigner notre revenu imposable, et que le programme nous renvoie la somme à payer pour les impôts.

Pour cela j’ai choisi de réaliser le programme en Node JS.

Voici ce que le script me donne :

Et maintenant voici l’intégralité du code :

let tranches = [
  {
    starthold: 0,
    taux: 0.0,
    somme: 0,
  },
  {
    starthold: 10065,
    taux: 0.11,
    somme: 0,
  },
  {
    starthold: 25660,
    taux: 0.3,
    somme: 0,
  },
  {
    starthold: 73370,
    taux: 0.41,
    somme: 0,
  },
  {
    starthold: 157807,
    taux: 0.45,
    somme: 0,
  },
]
const tailleTranches = tranches.length
const revenu = parseInt(process.argv[2])
let impotAPayer = 0

function repartition(revenu, tranches) {
  for (let i = tailleTranches - 1; i >= 0; i--) {
    if (tranches[i].starthold <= revenu) {
      tranches[i].somme = revenu - tranches[i].starthold
      revenu = tranches[i].starthold
    }
  }
  return tranches
}

console.log()
console.log('#######################################')
console.log('#######################################')
console.log('###########  CALCUL IMPÔTS  ###########')
console.log('#######################################')
console.log('#######################################')
console.log()
console.log('REVENU : ' + revenu + ' €')
tranches = repartition(revenu, tranches)
console.log('Répartition : ')
console.log(tranches)
console.log('------------------------------------')
console.log()
for (let i = tailleTranches - 1; i >= 0; i--) {
  impotAPayer += tranches[i].somme * tranches[i].taux
}
console.log('Impôt à payer : ')
console.log('--------------------')
console.log('--  ', impotAPayer, ' €')
console.log('--------------------')

Ne vous inquiétez pas, je vais détailler les points ci-dessous.

Donc tout d’abord on crée un tableau d’objets, dont chaque objet défini une tranche. Et voici les information qui définissent une tranche :

  • Son seuil de départ
  • Son taux d’imposition
  • La répartition du revenu au sein de cette tranche
let tranches = [
  {
    starthold: 0,
    taux: 0.0,
    somme: 0,
  },
  {
    starthold: 10065,
    taux: 0.11,
    somme: 0,
  },
  {
    starthold: 25660,
    taux: 0.3,
    somme: 0,
  },
  {
    starthold: 73370,
    taux: 0.41,
    somme: 0,
  },
  {
    starthold: 157807,
    taux: 0.45,
    somme: 0,
  },
]

Ensuite on initialise nos variables. On récupère la taille de notre tableau de tranches, on récupère le revenu indiqué en ligne de commande (en le transformant en un nombre entier) et on déclare la variable recevant la part d’impôt à payer.

const tailleTranches = tranches.length
const revenu = parseInt(process.argv[2])
let impotAPayer = 0

Ensuite la première étape avant de calculer l’impôt, c’est de répartir correctement le revenu sur les différentes tranches. Pour réaliser cela on réalise une fonction repartition() qui prend en paramètre le revenu, ainsi que notre tableau de tranches.

Etant donné que la dernière tranche n’a pas de limite haute, j’ai décidé de commencer par le haut.

Si le revenu est supérieur à la limite haute, alors on soustrait la limite basse de la tranche au revenu pour déterminer la somme associé à la tranche. Puis on affecte la valeur de la limite basse au revenu.

C’est clairement le point sensible de cette application, donc si vous ne comprenez pas ma phrase, c’est normal. Pour facilitez la compréhension j’ai fait un schéma :

function repartition(revenu, tranches) {
  for (let i = tailleTranches - 1; i >= 0; i--) {
    if (tranches[i].starthold <= revenu) {
      tranches[i].somme = revenu - tranches[i].starthold
      revenu = tranches[i].starthold
    }
  }
  return tranches
}

Pour la suite du code, je vais enlever les console.log(), car ils ont uniquement pour but d’afficher les informations sur la console. On gagnera ainsi en lisibilité (de toute façon l’intégralité du code est au dessus).

Donc pour mettre à jour notre tableau de tranches, on utilise notre fonction repartition().

Ensuite on itère sur chacune des tranches pour pouvoir calculer en fonction de la somme affecter à chaque tranche, la part d’impôt à payer.

tranches = repartition(revenu, tranches)
for (let i = tailleTranches - 1; i >= 0; i--) {
  impotAPayer += tranches[i].somme * tranches[i].taux
}
Pour marque-pages : Permaliens.

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *