Suppression des décimales du retour de fonction JavaScript : un guide simple

Gestion des problèmes décimaux dans les fonctions JavaScript

Lors de l'écriture de fonctions JavaScript, il est courant de rencontrer des problèmes liés aux nombres décimaux, notamment lors de l'exécution d'opérations de division. Pour les développeurs qui ont besoin d’un nombre propre et entier en sortie, il est essentiel de comprendre comment gérer ces résultats décimaux.

Dans ce guide, nous explorerons comment modifier une fonction JavaScript pour garantir que la valeur de retour est un entier, que le calcul initial implique ou non des décimales. Il s’agit d’un défi auquel de nombreux débutants sont confrontés lorsqu’ils travaillent avec des fonctions impliquant des calculs, comme la détermination de ratios ou de moyennes.

Le problème vient souvent de la division de nombres qui ne produit pas un résultat entier. Par exemple, le calcul de la moyenne des élèves par éducateur peut renvoyer une valeur décimale, ce qui peut ne pas être souhaité dans certains contextes. La suppression ou l'arrondi de ces décimales est une tâche courante visant à améliorer la lisibilité et la convivialité de la sortie.

Nous verrons comment utiliser les fonctions mathématiques intégrées de JavaScript, telles que Math.round(), Math.étage(), et Math.ceil(), pour supprimer les décimales et renvoyer un nombre entier. À la fin, vous comprendrez comment formater le retour de votre fonction pour répondre à vos besoins spécifiques.

Comprendre les méthodes JavaScript pour supprimer les décimales

Lorsqu'il s'agit de fonctions JavaScript qui renvoient des décimales, comme dans le étudiantsParAdmin fonction, il est essentiel de comprendre comment modifier les résultats pour obtenir des nombres entiers. Dans cette fonction, le nombre moyen d'élèves par éducateur est calculé en divisant le nombre d'élèves par la somme des enseignants et des aides. Cependant, comme la division aboutit souvent à des valeurs décimales, diverses méthodes mathématiques sont nécessaires pour traiter ces résultats. Le défi consiste à arrondir ou à tronquer la partie décimale pour l'adapter au contexte où seul un nombre entier est utile, par exemple pour indiquer le nombre d'élèves affectés à chaque enseignant.

La première approche utilisée dans l'exemple est Math.round(). Cette méthode arrondit le nombre décimal au nombre entier le plus proche. Par exemple, si la moyenne est de 13,666, Math.tour renverra 14 car la décimale est supérieure à 0,5. Cette méthode est utile dans les cas où vous souhaitez conserver la précision tout en simplifiant le nombre. Une autre approche est Math.étage(), qui arrondit toujours le nombre à l'inférieur. Il est appliqué lorsque vous souhaitez supprimer entièrement la partie décimale, par exemple en renvoyant 13 dans le même exemple, quelle que soit la valeur décimale.

D'autre part, Math.ceil() sert le but inverse de Math.étage(), en arrondissant toujours le nombre au nombre entier le plus proche. Cette méthode est idéale lorsque vous souhaitez vous assurer que la valeur n’est jamais inférieure à la partie entière. Par exemple, si la moyenne est de 13,1, Math.ceil() renverra 14, même si la partie décimale est assez petite. Ces méthodes permettent une flexibilité en fonction des besoins spécifiques de votre calcul. Que l’objectif soit d’arrondir au chiffre le plus proche, à l’inférieur ou au supérieur, chaque fonction répond à un objectif distinct.

De plus, l'utilisation de assert.strictEqual() dans les tests unitaires garantit que les fonctions se comportent comme prévu. Cette commande est importante pour vérifier si le résultat de votre fonction correspond au résultat attendu dans divers scénarios de test. Il agit comme une protection, permettant aux développeurs de vérifier rapidement si leurs modifications interrompent la fonctionnalité ou non. Combiné avec exiger() pour l'importation des modules nécessaires, ces tests ajoutent une couche de validation supplémentaire, garantissant la fiabilité du code dans les environnements de production. En incorporant ces techniques, le code est non seulement précis, mais également minutieusement testé et prêt pour différents scénarios d'utilisation.

// Solution 1: Using Math.round() to round to the nearest integer
function studentsPerAdmin(students, teachers, helpers) {
  const average = students / (teachers + helpers);
  const roundedAverage = Math.round(average);
  if (roundedAverage > 10) {
    console.log(`There are on average ${roundedAverage} students for each educator.`);
  } else {
    console.log('Unfortunately this class will be cancelled due to not having enough students enrolled.');
  }
  return roundedAverage;
}
studentsPerAdmin(41, 1, 2); // Result: 14 students for each educator

// Solution 2: Using Math.floor() to always round down
function studentsPerAdmin(students, teachers, helpers) {
  const average = students / (teachers + helpers);
  const flooredAverage = Math.floor(average);
  if (flooredAverage > 10) {
    console.log(`There are on average ${flooredAverage} students for each educator.`);
  } else {
    console.log('Unfortunately this class will be cancelled due to not having enough students enrolled.');
  }
  return flooredAverage;
}
studentsPerAdmin(41, 1, 2); // Result: 13 students for each educator

// Solution 3: Using Math.ceil() to always round up
function studentsPerAdmin(students, teachers, helpers) {
  const average = students / (teachers + helpers);
  const ceiledAverage = Math.ceil(average);
  if (ceiledAverage > 10) {
    console.log(`There are on average ${ceiledAverage} students for each educator.`);
  } else {
    console.log('Unfortunately this class will be cancelled due to not having enough students enrolled.');
  }
  return ceiledAverage;
}
studentsPerAdmin(41, 1, 2); // Result: 14 students for each educator

// Unit Test for verifying all solutions
const assert = require('assert');
assert.strictEqual(studentsPerAdmin(41, 1, 2), 14);  // Using Math.round()
assert.strictEqual(studentsPerAdmin(30, 1, 2), 10);  // Using Math.floor()
assert.strictEqual(studentsPerAdmin(35, 1, 2), 12);  // Using Math.ceil()
console.log('All tests passed!');

Gestion des décimales dans des scénarios JavaScript complexes

Bien que l’arrondi des décimales soit un besoin courant en JavaScript, il existe d’autres scénarios dans lesquels la gestion des décimales nécessite plus de contrôle. L'une des techniques les plus importantes consiste à travailler avec àFixe(). Cette méthode vous permet de spécifier le nombre de décimales souhaitées, en arrondissant le nombre à la valeur la plus proche tout en garantissant un format d'affichage cohérent. Par exemple, number.toFixed(2) renverra toujours un nombre avec deux décimales, ce qui le rend idéal pour les situations où la précision est importante, comme les calculs monétaires ou les mesures scientifiques.

Un autre concept important concerne la façon dont JavaScript gère l’arithmétique à virgule flottante. En raison de la manière dont les nombres sont stockés en mémoire, les opérations sur les décimales peuvent parfois conduire à des résultats inattendus, notamment lors de la comparaison de deux nombres à virgule flottante. Par exemple, 0.1 + 0.2 n'est pas exactement égal 0.3 en JavaScript, ce qui peut poser des problèmes dans certains calculs. Comprendre ces nuances peut vous aider à éviter les erreurs dans votre code, en particulier lors de calculs financiers ou statistiques.

De plus, si vous devez supprimer entièrement les décimales sans arrondir, vous pouvez utiliser des opérateurs au niveau du bit comme ~~ (double tilde), qui tronque efficacement la partie décimale d'un nombre. Cette approche fonctionne car les opérateurs au niveau du bit convertissent le nombre en entier au cours du processus. Par exemple, ~~13.666 aboutit à ~~13.99. Cette méthode est moins couramment utilisée mais constitue un moyen rapide d'atteindre l'objectif de tronquer les décimales lorsque les performances sont cruciales.