Javascript

Javascript arrondi à 2 décimales – Guide détaillé

L’arrondi à deux décimales est une opération courante lors du traitement des nombres en JavaScript. Que ce soit pour calculer des montants financiers, afficher des valeurs monétaires ou effectuer des opérations mathématiques précises, savoir comment arrondir correctement les nombres est essentiel pour de nombreuses applications web et mobiles.

Dans ce guide détaillé, nous allons explorer différentes méthodes pour arrondir des nombres à deux décimales en JavaScript. Nous couvrirons les différentes approches, leurs avantages et leurs cas d’utilisation spécifiques, ainsi que les considérations techniques importantes à prendre en compte lors de l’arrondi de nombres dans un environnement JavaScript.

Définitions

Avant de plonger dans les détails des méthodes d’arrondi, voici quelques définitions utiles pour comprendre les concepts abordés dans ce guide :

Nombre à deux décimales : Un nombre décimal qui a précisément deux chiffres après la virgule, par exemple, 3.14 ou 10.99.
Méthode Math.round() : Une fonction native de JavaScript qui arrondit un nombre à l’entier le plus proche.
Méthode toFixed() : Une méthode de l’objet Number en JavaScript qui renvoie une chaîne représentant le nombre avec un nombre spécifié de chiffres après la virgule décimale.
Méthode parseFloat() : Une fonction native de JavaScript qui analyse une chaîne de caractères et renvoie un nombre à virgule flottante.
Nombre flottant : Un type de données numériques en informatique représentant un nombre approximatif, souvent utilisé pour les nombres à virgule.

Maintenant que nous avons défini ces termes, explorons en détail les différentes méthodes pour arrondir à deux décimales en JavaScript.

Exemple 1 : Calcul de la moyenne

Supposons que vous ayez un tableau de notes et que vous vouliez calculer la moyenne avec deux décimales.

function calculerMoyenne(notes) {
    let somme = 0;
    for (let note of notes) {
        somme += note;
    }
    let moyenne = somme / notes.length;
    return moyenne.toFixed(2);
}

// Exemple d'utilisation
let notes = [14.5, 16.75, 12.25, 15, 18.5];
let moyenne = calculerMoyenne(notes);
console.log("La moyenne est de : " + moyenne); // Affiche "La moyenne est de : 15.20"

Exemple 2 : Calcul de prix total

Supposons que vous ayez un panier d’achats avec des prix unitaires et que vous vouliez calculer le prix total avec deux décimales.

function calculerPrixTotal(panier) {
    let total = 0;
    for (let produit of panier) {
        total += produit.prix * produit.quantite;
    }
    return total.toFixed(2);
}

// Exemple d'utilisation
let panier = [
    { nom: "Livre", prix: 12.99, quantite: 2 },
    { nom: "DVD", prix: 9.99, quantite: 1 },
    { nom: "Cahier", prix: 2.5, quantite: 5 }
];
let prixTotal = calculerPrixTotal(panier);
console.log("Le prix total est de : $" + prixTotal); // Affiche "Le prix total est de : $52.97"

Exemple 3 : Conversion de devises

Supposons que vous ayez un montant en une devise et que vous vouliez le convertir en une autre devise en arrondissant à deux décimales.

function convertirDevise(montant, tauxDeChange) {
    let montantConverti = montant * tauxDeChange;
    return montantConverti.toFixed(2);
}

// Exemple d'utilisation
let montantEnUSD = 50;
let tauxDeChangeEUR = 0.82;
let montantEnEUR = convertirDevise(montantEnUSD, tauxDeChangeEUR);
console.log("Le montant en euros est de : €" + montantEnEUR); // Affiche "Le montant en euros est de : €41.00"

Ces exemples montrent comment utiliser l’arrondi à deux décimales dans des situations pratiques telles que le calcul de la moyenne, le calcul du prix total d’un panier d’achats et la conversion de devises.

Voici quelques cas particuliers à considérer d’un point de vue technique lors de l’arrondi à deux décimales en JavaScript :

Cas particulier 1 : Problèmes d’arrondi avec les nombres flottants

En JavaScript, les nombres flottants sont stockés en utilisant le format IEEE 754, ce qui peut entraîner des problèmes d’arrondi imprévus. Par exemple :

let nombre = 0.1 + 0.2; // 0.1 + 0.2 = 0.30000000000000004
console.log(nombre.toFixed(2)); // Affiche "0.30"

Bien que l’expression 0.1 + 0.2 semble être égale à 0.3, elle donne réellement un résultat légèrement différent en raison de la façon dont les nombres flottants sont représentés en interne. Cela peut conduire à des résultats inattendus lors de l’arrondi.

Cas particulier 2 : Traitement des valeurs NaN et Infinity

Lorsque vous travaillez avec des valeurs NaN (Not a Number) ou Infinity, vous devez prendre en compte leur traitement lors de l’arrondi. Par exemple :

let valeurNaN = NaN;
console.log(valeurNaN.toFixed(2)); // Affiche "NaN"

let valeurInfinity = Infinity;
console.log(valeurInfinity.toFixed(2)); // Affiche "Infinity"

Dans ces cas, la méthode toFixed() renvoie directement « NaN » ou « Infinity » sans effectuer d’arrondi.

Cas particulier 3 : Valeurs négatives

Lorsque vous arrondissez des nombres négatifs, assurez-vous de prendre en compte le comportement souhaité, notamment en ce qui concerne l’arrondi vers le haut ou vers le bas. Par exemple :

let nombreNegatif = -5.6789;
console.log(Math.round(nombreNegatif * 100) / 100); // Affiche -5.68
console.log(nombreNegatif.toFixed(2)); // Affiche "-5.68"

Dans cet exemple, le nombre -5.6789 est arrondi à -5.68. Cela peut être conforme à vos attentes ou nécessiter un ajustement en fonction de votre logique métier.

En tenant compte de ces cas particuliers, vous pouvez écrire un code robuste pour l’arrondi à deux décimales en JavaScript.

Nous attirons ci-après l’attention sur quelques erreurs courantes à éviter lors de l’arrondi à deux décimales en JavaScript, illustrées par des exemples de bon et de mauvais code :

Erreur à éviter 1 : Ne pas prendre en compte les nombres flottants

Mauvais code :

let nombre = 0.1 + 0.2; // Résultat attendu : 0.3
console.log(nombre.toFixed(2)); // Affiche "0.30"

Explication : En raison de la façon dont les nombres flottants sont représentés en JavaScript, l’expression 0.1 + 0.2 ne donne pas exactement 0.3 mais plutôt une valeur légèrement différente. L’arrondi du résultat peut donner une valeur imprévue.

Bon code :

let nombre = 0.1 + 0.2; // Résultat attendu : 0.3
console.log(parseFloat(nombre.toFixed(2))); // Affiche 0.3

Explication : En utilisant parseFloat() après toFixed(), on s’assure que le résultat est correctement arrondi à deux décimales, évitant ainsi les problèmes liés aux nombres flottants.

Erreur à éviter 2 : Ignorer les valeurs NaN et Infinity

Mauvais code :

let valeurNaN = NaN;
console.log(valeurNaN.toFixed(2)); // Affiche "NaN"

let valeurInfinity = Infinity;
console.log(valeurInfinity.toFixed(2)); // Affiche "Infinity"

Explication : La méthode toFixed() ne peut pas être appliquée directement sur des valeurs NaN ou Infinity. Ignorer ces valeurs peut entraîner des résultats inattendus dans votre application.

Bon code :

let valeurNaN = NaN;
if (!isNaN(valeurNaN)) {
    console.log(parseFloat(valeurNaN.toFixed(2)));
} else {
    console.log("La valeur est NaN");
}

let valeurInfinity = Infinity;
if (isFinite(valeurInfinity)) {
    console.log(parseFloat(valeurInfinity.toFixed(2)));
} else {
    console.log("La valeur est Infinity");
}

Explication : En vérifiant d’abord si la valeur est un nombre fini (fini) à l’aide de isNaN() pour NaN et isFinite() pour Infinity, on évite les erreurs lors de l’arrondi de ces valeurs.

En évitant ces erreurs courantes, vous pouvez garantir un arrondi précis à deux décimales en JavaScript.