Los números en JavaScript se representan según el estándar IEEE 754, utilizando un tipo de punto flotante de doble precisión de 64 bits. Entre ellos, el bit de signo S, el bit de exponente E y el bit de mantisa M ocupan 1, 11 y 52 bits respectivamente, y enla especificación ES5se indica que el rango de valores del bit de exponente E es[-1074, 971]。
Resumen de problemas de precisión
Es evidentemente imposible querer representar números infinitos con bits finitos, por lo que aparecen una serie de problemas de precisión:
- Problemas de precisión en números de punto flotante, por ejemplo
0.1 + 0.2 !== 0.3 - Problemas de precisión en números grandes, por ejemplo
9999 9999 9999 9999 == 1000 0000 0000 0000 1 - El resultado del redondeo de toFixed no es preciso, por ejemplo
1.335.toFixed(2) == 1.33
La precisión de los números de punto flotante y toFixed en realidad pertenecen al mismo tipo de problema, ambos se deben a que los números de punto flotante no pueden representarse con precisión, como se muestra a continuación:
(1.335).toPrecision(20); // "1.3349999999999999645"
En cuanto al problema de precisión de los números grandes, podemos ver primero el siguiente fragmento de código:
// 能精确表示的整数范围上限,S为1个0,E为11个0,S为52个1 Math.pow(2, 53) - 1 === Number.MAX_SAFE_INTEGER // true // 能精确表示的整数范围下限,S为1个1,E为11个0,S为52个1 -(Math.pow(2, 53) - 1) === Number.MIN_SAFE_INTEGER // true // 能表示的最大数字,S为1个0,E为971,S为52个1 (Math.pow(2, 53) - 1) * Math.pow(2, 971) === Number.MAX_VALUE // true // 能表示的最接近于0的正数,S为1个0,E为-1074,S为0 Math.pow(2, -1074) === Number.MIN_VALUE // true
A través de lo anterior se puede entender que,[MIN_SAFE_INTEGER, MAX_SAFE_INTEGER]los enteros dentro de este rango pueden representarse con precisión, pero los enteros que superan este rango no necesariamente pueden representarse con precisión. De esta manera se genera el llamado problema de pérdida de precisión en números grandes.
Ideas de solución
Lo primero que se considera es cómo resolver el problema de precisión en las operaciones con números de punto flotante. Hay 3 ideas:
- Considerando que la desviación de cada operación de punto flotante es muy pequeña (aunque en realidad no es así), se puede redondear el resultado con una precisión especificada, por ejemplo, se puede
parseFloat(result.toFixed(12)); - Convertir los números de punto flotante en enteros para operar, y luego dividir el resultado. Por ejemplo, 0.1 + 0.2 se puede convertir en
(1*2)/3。 - Convertir los números de punto flotante en cadenas de caracteres para simular el proceso de cálculo real.
Veamos primero la primera opción. En la mayoría de los casos, puede obtener el resultado correcto, pero en algunos casos extremos, usar toFixed con 12 decimales no es suficiente, por ejemplo:
210000 * 10000 * 1000 * 8.2 // 17219999999999.998 parseFloat(17219999999999.998.toFixed(12)); // 17219999999999.998,而正确结果为 17220000000000
En el caso anterior, si se desea que el resultado sea correcto, se necesitatoFixed(2), lo cual es claramente inaceptable.
Veamos la segunda opción, por ejemplonumber-precisionEsta librería es la que utiliza este enfoque, pero esto también tiene problemas, por ejemplo:
// 这两个浮点数,转化为整数之后,相乘的结果已经超过了 MAX_SAFE_INTEGER 123456.789 * 123456.789 // 转化为 (123456789 * 123456789)/1000000,结果是 15241578750.19052
Por lo tanto, finalmente se considera usar la tercera opción. Actualmente ya existen muchas librerías bastante maduras, comobignumber.js,decimal.js, ybig.jsetc. Podemos elegir la herramienta correspondiente según nuestras necesidades. Además, estas librerías no solo resuelven el problema de precisión en las operaciones de punto flotante, sino que también soportan operaciones con números grandes y corrigen el problema de que el toFixed nativo no sea preciso.
Digresión
Hay otro problema relacionado con el cálculo en JavaScript, que esMath.round(x), aunque no causa problemas de precisión, tiene una pequeña trampa que es fácil de pasar por alto. A continuación se muestra su estrategia de redondeo:
- Si la parte fraccionaria es mayor que 0.5, se redondea al siguiente entero con mayor valor absoluto.
- Si la parte fraccionaria es menor que 0.5, se redondea al siguiente entero con menor valor absoluto.
- Si la parte fraccionaria es igual a 0.5, entoncesse redondea al siguiente entero en la dirección del infinito positivo.。
Por lo tanto, para Math.round(-1.5), el resultado es -1, lo que puede no ser el resultado que deseamos.
Por supuesto, las librerías mencionadas anteriormente, como big.js, proporcionan su propia función round y permiten especificar reglas de redondeo para evitar este problema.
Dirección original: https://xwjgo.github.io/2018/03/17/js%E4%B8%AD%E7%B2%BE%E5%BA%A6%E9%97%AE%E9%A2%98%E5%8F%8A%E8%A7%A3%E5%86%B3%E6%96%B9%E6%A1%88/