operación de datos de punto flotante js

1. Descripción general

Tener tiempo para volver a escribir ...

Segundo, usa

Los siguientes tres métodos pueden resolver el problema de la pérdida de precisión causada por la operación de punto flotante del extremo frontal

1. toFixed ()

El método toFixed () usa el redondeo para retener el número especificado de lugares decimales.

let a = 0.1 
let b = 0.2 
let c = a + b 
console.log (c) // 0.30000000000000004 

c = parseFloat (0.1 + 0.2) .toFixed (1 ) 
console.log (c) // 0.3

2. Convierta números de punto flotante a operaciones enteras

La idea básica es calcular mediante la conversión de un número de punto flotante a un número entero, y luego ajustar el punto decimal del número entero para devolver el resultado correcto de punto flotante.

// función Además 
función accAdd (arg1, arg2) {
     var R1, R2, m;
     el try {
         // obtener el número de dígitos decimales 
        R1 = arg1.toString split () [. 1. ( "") ] .length; 
    } catch (e) { 
        r1 = 0 ; 
    } 
    try { 
        r2 = arg2.toString (). split (".") [1 ] .length; 
    } catch (e) { 
        r2 = 0 ; 
    } 
    // toma el mayor número de bits 10 ^ enésima potencia 
    m = Math.pow (10 , Math.max (r1, r2));
     return (arg1 * m + arg2 * m) /m; 
} // Agregue un método de agregar al tipo de Número. Use .add directamente para completar el cálculo. 
Number.prototype.add = function (arg) {
     return accAdd ( this , arg); 
}; 

// Función de resta 
Subtr (arg1, arg2) {
     var r1, r2, m, n;
     try { 
        r1 = arg1.toString ( ) .split (".") [1 ] .length; 
    } catch (e) { 
        r1 = 0 ; 
    } try { 
        r2 = arg2.toString (). split (".") [1 ] .length; 
    } catch 
        r2

     ( e) {= 0 ; 
    } 

    m = Math.pow (10, Math.max (r1, r2)); // La longitud de la precisión del control dinámico 
    // El número de bits reservados en el resultado del cálculo 
    n = (r1> = r2)? R1: r2;
     return parseFloat (((arg1 * m-arg2 * m) / m) .toFixed (n)); 
} 

Number.prototype.sub = function (arg) {
     return Subtr ( this , arg); 
}; 

// Función de 
función de multiplicación accMul (arg1, arg2) {
     var m = 0 , 
        s1 = arg1.toString (), 
        s2 =arg2.toString ();
    prueba { 
        m + = s1.split (".") [1 ] .length; 
    } catch (e) { 
    } 
    try { 
        m + = s2.split (".") [1 ] .length; 
    } catch (e) { 
    } 
    return Number (s1.replace (".", "")) * Number (s2.replace (".", "")) / Math.pow (10 , m); 
} 

Number.prototype.mul = function (arg) {
     return accMul (arg, this ); 
}; 

// 除法 函数
función accDiv (arg1,
    , 
        t2 = 0 , 
        r1, r2; 
    pruebe { 
        t1 = arg1.toString (). split (".") [1 ] .length; 
    } catch (e) { 
    } 
    try { 
        t2 = arg2.toString (). split (".") [1 ] .length; 
    } catch (e) { 
    } 

    con (Math) { 
        r1 = Number (arg1.toString (). replace (".", "" )); 
        r2 = Número (arg2.toString (). replace (".", "" ));
        retorno (r1 / r2) * pow (10, t2 - t1); 
    } 
} 

Número.prototipo. función (arg) {
     return accDiv ( this , arg); 
};

 console.log 
( 0.1.add (0.2) .add (0.3)); // Equivalente a 0.1 + 0.2 + 0.3, salida 0.6 
console.log ( 0.1 + 0.2 + 0.3); // salida 0.6000000000000001 console.log 

( 0.6.sub (0.2) .sub (0.3)); // equivalente a 0.6-0.2-0.3 salida 0.1 console.log 
( 0.6-0.2-0.3 ) ; // salida: 0.09999999999999998 console.log 

( 0.1.mul (0.2) .mul (0.3)); // equivalente a 0.1 * 0.2 * 0.3 salida 0.006 
console.log (0.1 * 0.2 * 0.3); // salida: 0.006000000000000001 console.log 

( 0.6.div (0.2) .div (0.1)); //Equivalente a 0.6 / 0.2 / 0.1 salida 30 
console.log (0.6 / 0.2 / 0.1); // salida: 29.999999999999993

Ver código

3. Introducir la biblioteca de terceros decimal.js 

Como hay uno listo para usar, se puede usar directamente, entonces, ¿por qué molestarse? Recomendar

let z = Decimal.add (0.1, 0.2 ) 
console.log (z.toString ())

 

 

Referencia:

Problema de pérdida de precisión de punto flotante Js y cómo resolver el cálculo de punto flotante inexacto en js

js resuelve la notación científica y js resuelve la aritmética de punto flotante