La précision est cruciale en JavaScript, et la ma?trise de JavaScript Round to 2 Decimal Places est essentielle pour des calculs précis et un formatage propre. Dans ce blog, nous explorerons des méthodes telles que Math.round et Math.floor en JavaScript. En prime, nous discuterons également de la fa?on d'arrondir les nombres à la nième décimale pour les scénarios avancés?!

L'importance d'arrondir les nombres en JavaScript

Pourquoi l’arrondi est-il important ?

L'arrondi des nombres est un aspect crucial du travail avec les nombres en programmation. Dans JavaScript Round to 2 Decimal Places, il simplifie les calculs, améliore la lisibilité et garantit la précision dans les applications du monde réel. Par exemple, les transactions financières, les pourcentages et les mesures nécessitent souvent des valeurs arrondies pour éviter des chiffres trop précis qui peuvent prêter à confusion ou à des erreurs d'interprétation.

Pourquoi se concentrer sur deux décimales??

Lorsque nous parlons de JavaScript arrondi à 2 décimales, c'est parce que deux décimales sont la norme dans des scénarios tels que les calculs de devises. Une précision au-delà de deux décimales n’est pas nécessaire et pourrait introduire des erreurs d’arrondi ou des incohérences. Par exemple, les prix sont généralement affichés à 10,99?$ au lieu de 10,9876?$. En nous concentrant sur l'arrondi à deux décimales en JavaScript, nous garantissons l'exactitude, la praticité et la convivialité des résultats.

Différentes fa?ons d'arrondir un nombre à 2 décimales en JavaScript

Les méthodes de base

Lors de l'arrondi des nombres en JavaScript, les approches les plus simples impliquent l'utilisation des méthodes intégrées Math.round et Math.floor. Ces méthodes sont faciles à mettre en ?uvre et fonctionnent bien dans la plupart des cas, mais comportent certains cas extrêmes et pièges à prendre en compte.

Utiliser Math.round

Math.round est la méthode la plus simple pour arrondir un nombre à l'entier le plus proche. Pour arrondir à 2 décimales, vous pouvez redimensionner le nombre, effectuer l'arrondi et le réduire.

const roundToTwo = (num) => Math.round(num * 100) / 100;

console.log(roundToTwo(12.345)); // Output: 12.35
console.log(roundToTwo(12.344)); // Output: 12.34

Cas de bord?:

Lorsque le nombre est exactement à mi-chemin entre deux valeurs, Math.round arrondit toujours vers le nombre pair le plus proche. Cela peut conduire à des résultats inattendus dans certaines situations.

console.log(roundToTwo(12.345)); // Output: 12.35
console.log(roundToTwo(12.335)); // Output: 12.33

Utiliser Math.floor

Math.floor arrondit toujours à l'entier le plus proche. Pour arrondir à 2 décimales, nous appliquons la même astuce de mise à l'échelle.

const floorToTwo = (num) => Math.floor(num * 100) / 100;

console.log(floorToTwo(12.345)); // Output: 12.34
console.log(floorToTwo(12.349)); // Output: 12.34

Piège:

Math.floor n'est pas idéal lorsque vous avez besoin d'un comportement d'arrondi standard. Cela peut entra?ner des inexactitudes pour les chiffres qui devraient être arrondis.

const roundToTwo = (num) => Math.round(num * 100) / 100;

console.log(roundToTwo(12.345)); // Output: 12.35
console.log(roundToTwo(12.344)); // Output: 12.34

Points clés à retenir?:

• Math.round est idéal pour l'arrondi standard, mais peut se comporter de manière inattendue avec des nombres exactement à mi-chemin entre deux valeurs.
• Math.floor est idéal lorsque vous souhaitez toujours arrondir à l'inférieur mais que vous ne répondez pas aux exigences d'arrondi standard.
• Les deux méthodes nécessitent une mise à l'échelle, ce qui peut parfois introduire des problèmes de précision en virgule flottante.

Exemple de problème de précision en virgule flottante

console.log(roundToTwo(12.345)); // Output: 12.35
console.log(roundToTwo(12.335)); // Output: 12.33

Cela se produit parce que 1,005 * 100 devient 100,499999999999999 en raison de l'arithmétique à virgule flottante, ce qui entra?ne un arrondi incorrect de Math.round. Nous aborderons ces problèmes dans les sections suivantes avec des méthodes avancées?!

Les méthodes avancées

En plus des méthodes classiques comme Math.round et Math.floor, JavaScript propose des techniques avancées pour un arrondi précis. Ces méthodes s'attaquent aux pièges courants de l'arrondi à 2 décimales JavaScript et fournissent des solutions robustes, notamment des ajustements pour l'arithmétique à virgule flottante, des approches orientées objet et une flexibilité définie par l'utilisateur.

Utilisation de Number.EPSILON pour la précision en virgule flottante

L'arithmétique à virgule flottante de JavaScript peut provoquer des résultats inattendus, en particulier dans JavaScript arrondi à 2 décimales. L'ajout de Number.EPSILON, la plus petite valeur possible pouvant être ajoutée à 1 pour donner un résultat supérieur à 1, permet d'atténuer ces erreurs.

const floorToTwo = (num) => Math.floor(num * 100) / 100;

console.log(floorToTwo(12.345)); // Output: 12.34
console.log(floorToTwo(12.349)); // Output: 12.34

Pourquoi ?a marche mieux?:

Number.EPSILON tient compte des infimes inexactitudes dans les calculs à virgule flottante, améliorant ainsi la précision dans JavaScript arrondi à 2 décimales pour les nombres délicats comme 1,005 ou 1,255.

Utilisation du constructeur Intl.NumberFormat

L'API Intl.NumberFormat est un constructeur polyvalent permettant de formater les nombres selon les conventions spécifiques aux paramètres régionaux. Il est particulièrement utile pour JavaScript arrondi à 2 décimales, offrant des options personnalisables pour les chiffres décimaux et fractionnaires.

console.log(floorToTwo(12.349)); // Output: 12.34 (Expected: 12.35)

Pourquoi ?a marche mieux?:

• Fournit précision et localisation pour JavaScript arrondi à 2 décimales.
• Prend en charge la personnalisation via des propriétés telles que maximumFractionDigits.

Fonctions définies par l'utilisateur

Les fonctions personnalisées sont un excellent moyen de gérer des scénarios spécifiques pour JavaScript arrondi à 2 décimales. Par exemple, l'utilisation de la notation exponentielle permet un contr?le précis des décimales.

console.log(roundToTwo(1.005)); // Output: 1 (Expected: 1.01)

Pourquoi ?a marche mieux?:

Les fonctions personnalisées peuvent gérer les cas extrêmes et garantir la précision de l'arrondi JavaScript à 2 décimales, même dans des scénarios complexes.

Points clés à retenir?:

• Number.EPSILON résout les erreurs à virgule flottante pour un arrondi de précision.
• Intl.NumberFormat permet la localisation et l'arrondi flexible des nombres.
• Les fonctions personnalisées offrent des solutions personnalisées pour l'arrondi JavaScript à 2 décimales.
• Les bibliothèques avancées comme Decimal.js garantissent une grande précision pour les applications exigeant une précision extrême.

Bonus?: arrondir à la nième décimale en JavaScript

En plus d'arrondir les nombres à 2 décimales, il existe des situations dans lesquelles vous devrez peut-être arrondir à un nombre arbitraire de décimales (énième décimale). Cela nécessite une approche robuste et flexible qui minimise les erreurs de précision en virgule flottante.

Une fonction personnalisée pour arrondir à N décimales

La fonction suivante met à l'échelle le nombre, l'arrondit, puis le réduit. Il intègre également Number.EPSILON pour gérer les inexactitudes en virgule flottante.

const roundToTwo = (num) => Math.round(num * 100) / 100;

console.log(roundToTwo(12.345)); // Output: 12.35
console.log(roundToTwo(12.344)); // Output: 12.34

Comment ?a marche?:

1. Mise à l'échelle du nombre?: Le nombre est multiplié par 10^n pour décaler la virgule décimale de n places vers la droite.
2. Arrondi?: Le nombre mis à l'échelle est arrondi à l'aide de Math.round, avec Number.EPSILON ajouté pour éviter les problèmes de virgule flottante.
3. Réduction?: La valeur arrondie est divisée par 10^n pour ramener la virgule décimale à sa position d'origine.

Avantages clés?:

• Précision?: Gère correctement les cas extrêmes comme 1,005 ou 12,99999.
• Flexibilité?: Peut arrondir à n'importe quel nombre de décimales en spécifiant simplement n.
• Sans erreur?: Incorpore Number.EPSILON pour minimiser les erreurs d'arrondi causées par l'arithmétique à virgule flottante.

Traitement des cas extrêmes?:

console.log(roundToTwo(12.345)); // Output: 12.35
console.log(roundToTwo(12.335)); // Output: 12.33

Comparaison avec toFixed?:

Bien que la méthode toFixed puisse être utilisée, elle renvoie une cha?ne au lieu d'un nombre et ne corrige pas directement les inexactitudes des virgules flottantes.

const floorToTwo = (num) => Math.floor(num * 100) / 100;

console.log(floorToTwo(12.345)); // Output: 12.34
console.log(floorToTwo(12.349)); // Output: 12.34

En utilisant la fonction personnalisée, nous simplifions le processus et évitons les conversions inutiles.

Conclusion

L'arrondi des nombres en JavaScript est une tache essentielle pour garantir l'exactitude des calculs et de la présentation des données. Nous avons exploré des méthodes classiques telles que Math.round et Math.floor, des techniques avancées utilisant Number.EPSILON, Intl.NumberFormat et même des fonctions personnalisées robustes pour gérer efficacement les problèmes de précision en virgule flottante. Pour des scénarios plus complexes, comme l'arrondi à la nième décimale, nous avons démontré une approche flexible et sans erreur qui garantit des résultats fiables.

Pour des informations plus détaillées sur les méthodes d'arrondi JavaScript, visitez la documentation officielle de JavaScript Math.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!