Wie kann man die wissenschaftliche Notation für große Zahlen in JavaScript vermeiden?

Question

JavaScript konvertiert ganze Zahlen mit mehr als 21 Ziffern in wissenschaftliche Notation, wenn sie in einem String-Kontext verwendet werden. Ich gebe eine ganze Zahl als Teil einer URL aus. Wie kann ich diese Umwandlung verhindern?

Answer 1

Eine weitere mögliche Lösung:

function toFix(i){
 var str='';
 do{
   let a = i%10;
   i=Math.trunc(i/10);
   str = a+str;
 }while(i>0)
 return str;
}

Answer 2

Hier ist meine kurze Variante von Number.prototype.toFixed Methode, die mit jeder Zahl funktioniert:

Number.prototype.toFixedSpecial = function(n) {
  var str = this.toFixed(n);
  if (str.indexOf('e+') === -1)
    return str;

  // if number is in scientific notation, pick (b)ase and (p)ower
  str = str.replace('.', '').split('e+').reduce(function(b, p) {
    return b + Array(p - b.length + 2).join(0);
  });

  if (n > 0)
    str += '.' + Array(n + 1).join(0);

  return str;
};

console.log( 1e21.toFixedSpecial(2) );       // "1000000000000000000000.00"
console.log( 2.1e24.toFixedSpecial(0) );     // "2100000000000000000000000"
console.log( 1234567..toFixedSpecial(1) );   // "1234567.0"
console.log( 1234567.89.toFixedSpecial(3) ); // "1234567.890"

Answer 3

Die folgende Lösung umgeht die automatische exponentielle Formatierung für sehr große und sehr kleine Zahlen. Dies ist outis' Lösung mit einem Bugfix: Es funktionierte nicht bei sehr kleinen negativen Zahlen.

function numberToString(num)
{
    let numStr = String(num);

    if (Math.abs(num) < 1.0)
    {
        let e = parseInt(num.toString().split('e-')[1]);
        if (e)
        {
            let negative = num < 0;
            if (negative) num *= -1
            num *= Math.pow(10, e - 1);
            numStr = '0.' + (new Array(e)).join('0') + num.toString().substring(2);
            if (negative) numStr = "-" + numStr;
        }
    }
    else
    {
        let e = parseInt(num.toString().split('+')[1]);
        if (e > 20)
        {
            e -= 20;
            num /= Math.pow(10, e);
            numStr = num.toString() + (new Array(e + 1)).join('0');
        }
    }

    return numStr;
}

// testing ...
console.log(numberToString(+0.0000000000000000001));
console.log(numberToString(-0.0000000000000000001));
console.log(numberToString(+314564649798762418795));
console.log(numberToString(-314564649798762418795));

Answer 4

Sie können verwenden von-exponential Modul. Es ist leicht und vollständig getestet.

import fromExponential from 'from-exponential';

fromExponential(1.123e-10); // => '0.0000000001123'

Answer 5

Die Antworten der anderen geben Ihnen nicht die genaue Zahl!
Diese Funktion berechnet die gewünschte Zahl genau und gibt sie in der Zeichenkette zurück, um zu verhindern, dass sie durch Javascript verändert wird!
Wenn Sie ein numerisches Ergebnis benötigen, multiplizieren Sie einfach das Ergebnis der Funktion in Nummer eins!

function toNonExponential(value) {
    // if value is not a number try to convert it to number
    if (typeof value !== "number") {
        value = parseFloat(value);

        // after convert, if value is not a number return empty string
        if (isNaN(value)) {
            return "";
        }
    }

    var sign;
    var e;

    // if value is negative, save "-" in sign variable and calculate the absolute value
    if (value < 0) {
        sign = "-";
        value = Math.abs(value);
    }
    else {
        sign = "";
    }

    // if value is between 0 and 1
    if (value < 1.0) {
        // get e value
        e = parseInt(value.toString().split('e-')[1]);

        // if value is exponential convert it to non exponential
        if (e) {
            value *= Math.pow(10, e - 1);
            value = '0.' + (new Array(e)).join('0') + value.toString().substring(2);
        }
    }
    else {
        // get e value
        e = parseInt(value.toString().split('e+')[1]);

        // if value is exponential convert it to non exponential
        if (e) {
            value /= Math.pow(10, e);
            value += (new Array(e + 1)).join('0');
        }
    }

    // if value has negative sign, add to it
    return sign + value;
}