Éviter les problèmes avec le JavaScript est bizarre décimal calculs

1.2 + 1.1 peut être ok, mais 0.2 + 0.1 peuvent ne pas être ok.

C'est un problème dans pratiquement toutes les langues qui est en usage aujourd'hui. Le problème est que le 1/10 ne peut pas être correctement représentée comme une fraction binaire comme 1/3 ne peut pas être représenté comme une fraction décimale.

Les solutions de contournement consiste en l'arrondissant à seulement le nombre de décimales que vous avez besoin et de travailler avec des chaînes, qui sont exactes:

(0.2 + 0.1).toFixed(4) === 0.3.toFixed(4) //true

ou vous pouvez convertir des nombres d'après:

+(0.2 + 0.1).toFixed(4) === 0.3 //true

ou de l'utilisation des Mathématiques.tour:

Math.round(0.2 * X + 0.1 * X) / X === 0.3 //true

où X est une partie de la puissance de 10 par exemple 100 ou 10000 - en fonction de la précision que vous avez besoin.

Ou vous pouvez utiliser cents au lieu de dollars lors du comptage de l'argent:

cents = 1499; //$14.99

De cette façon que vous ne travaillez qu'avec des entiers et que vous n'avez pas à vous soucier de décimal et binaire fractions à tous.

2017 mise à Jour

La situation de représenter les nombres en JavaScript peut-être un peu plus compliqué que d'habitude. Il l'habitude d'être le cas que nous avons eu seulement un type numérique en JavaScript:

• Virgule flottante de 64 bits (la La norme IEEE 754 double précision en virgule flottante nombre - voir: ECMA-262 Edition 5.1, Section 8.5 et ECMA-262 Edition 6.0, Section 6.1.6)

Ce n'est plus le cas - non seulement il y a actuellement plus de types numériques en JavaScript aujourd'hui, d'autres sont sur le chemin, y compris une proposition visant à ajouter une précision arbitraire entiers à ECMAScript, et, espérons-le, en précision arbitraire décimales suivra - voir cette réponse pour plus de détails:

• Différence entre les chars et les ints en Javascript?

Voir aussi

Une autre réponse pertinente avec quelques exemples de la façon de traiter les calculs:

• Nœud de donner étrange de sortie en fonction de la somme de particulier à flotteur chiffres

Compréhension des erreurs d'arrondi dans l'arithmétique à virgule flottante n'est pas pour les timides! Fondamentalement, les calculs sont effectués comme si il y avait de l'infini bits de précision disponible. Le résultat est arrondi selon des règles fixées dans les spécifications IEEE.

Des arrondis peut jeter quelques funky réponses:

Math.floor(Math.log(1000000000) / Math.LN10) == 8 //true

Ce un tout un ordre de grandeur out. C'est une erreur d'arrondi!

Pour toute architecture à virgule flottante, il y a un certain nombre qui représente le plus petit intervalle entre les distinguer des nombres. Elle est appelée EPSILON.

Il sera une partie de l'EcmaScript standard dans un avenir proche. En attendant, vous pouvez la calculer comme suit:

function epsilon() {
    if ("EPSILON" in Number) {
        return Number.EPSILON;
    }
    var eps = 1.0; 
    //Halve epsilon until we can no longer distinguish
    //1 + (eps /2) from 1
    do {
        eps /= 2.0;
    }
    while (1.0 + (eps / 2.0) != 1.0);
    return eps;
}

Vous pouvez alors l'utiliser, à quelque chose comme ceci:

function numericallyEquivalent(n, m) {
    var delta = Math.abs(n - m);
    return (delta < epsilon());
}

Ou, depuis des erreurs d'arrondi peuvent s'accumuler de façon alarmante, vous souhaiterez peut-être utiliser delta /2 ou delta * delta plutôt que delta.

Il y a les bibliothèques qui cherchent à résoudre ce problème mais si vous ne voulez pas inclure l'un de ceux (ou ne peuvent pas pour une raison quelconque, comme de travailler à l'intérieur d'un GTM variable), alors vous pouvez utiliser cette petite fonction que j'ai écrit:

Utilisation:

var a = 194.1193;
var b = 159;
a - b; //returns 35.11930000000001
doDecimalSafeMath(a, '-', b); //returns 35.1193

Voici la fonction:

function doDecimalSafeMath(a, operation, b, precision) {
function decimalLength(numStr) {
var pieces = numStr.toString().split(".");
if(!pieces[1]) return 0;
return pieces[1].length;
}
//Figure out what we need to multiply by to make everything a whole number
precision = precision || Math.pow(10, Math.max(decimalLength(a), decimalLength(b)));
a = a*precision;
b = b*precision;
//Figure out which operation to perform.
var operator;
switch(operation.toLowerCase()) {
case '-':
operator = function(a,b) { return a - b; }
break;
case '+':
operator = function(a,b) { return a + b; }
break;
case '*':
case 'x':
precision = precision*precision;
operator = function(a,b) { return a * b; }
break;
case '÷':
case '/':
precision = 1;
operator = function(a,b) { return a / b; }
break;
//Let us pass in a function to perform other operations.
default:
operator = operation;
}
var result = operator(a,b);
//Remove our multiplier to put the decimal back.
return result/precision;
}