Przeciwny do Number.toExponential w JS

Question

Potrzebuję uzyskać wartość bardzo dużej liczby w JavaScript w formie nie-wykładniczej. Number.toFixed po prostu zwraca go w formie wykładniczej jako ciąg, który jest gorszy niż to, co miałem.

To co Number.toFixed powraca:

>>> x = 1e+31 
1e+31 
>>> x.toFixed() 
"1e+31" 

Number.toPrecision też nie działa:

>>> x = 1e+31 
1e+31 
>>> x.toPrecision(21) 
"9.99999999999999963590e+30" 

Chciałbym to:

>>> x = 1e+31 
1e+31 
>>> x.toNotExponential() 
"10000000000000000000000000000000" 

Mógłbym napisać własny parser ale Wolałbym użyć natywnej metody JS, jeśli taka istnieje.

Answer 1

Odpowiedź brzmi nie ma takiej funkcji wbudowanej. Szukałem wysokiego i niskiego. Oto RegExp używam podzielić liczbę na znak, współczynnik (cyfry przed przecinkiem), część ułamkową (cyfry po punkcie dziesiętnym) oraz wykładnik:

/^([+-])?(\d+)\.?(\d*)[eE]([+-]?\d+)$/ 

„Rzuć własne” jest odpowiedź, którą już zrobione.

Answer 2

Można użyć toPrecision z parametrem określającym ile cyfr chcesz wyświetlić:

x.toPrecision(31) 

Jednak wśród przeglądarek testowałem, powyższy kod działa tylko w Firefoksie. Zgodnie ze specyfikacją ECMAScript, ważny zakres dla toPrecision wynosi od 1 do 21, a zarówno IE, jak i Chrome wyrzucają odpowiednio RangeError. Wynika to z faktu, że reprezentacja zmiennoprzecinkowa używana w JavaScript nie jest w stanie faktycznie reprezentować liczb do 31 cyfr precyzji.

Answer 3

Możliwe jest rozszerzenie eksponencjalnej struktury JavaScript za pomocą funkcji ciągów. Prawdą jest, co wymyśliłem jest nieco tajemniczy, ale działa, gdy wykładnik po e jest pozytywna:

var originalNumber = 1e+31; 
var splitNumber = originalNumber.toString().split('e'); 

var result; 
if(splitNumber[1]) { 
    var regexMatch = splitNumber[0].match(/^([^.]+)\.?(.*)$/); 
    result = 
     /* integer part */ regexMatch[1] + 
     /* fractional part */ regexMatch[2] + 
     /* trailing zeros */ Array(splitNumber[1] - regexMatch[2].length + 1).join('0'); 
} else result = splitNumber[0]; 

Answer 4

„10000000000000000000000000000000”?

Trudno uwierzyć, że ktoś będzie raczej patrzeć na to niż 1,0E + 31

lub w html: 10 . Ale tutaj jest jeden sposób, wiele z nich jest za ujemne wykładniki (frakcji):

function longnumberstring(n){ 
    var str, str2= '', data= n.toExponential().replace('.','').split(/e/i); 
    str= data[0], mag= Number(data[1]); 
    if(mag>=0 && str.length> mag){ 
     mag+=1; 
     return str.substring(0, mag)+'.'+str.substring(mag);    
    } 
    if(mag<0){ 
     while(++mag) str2+= '0'; 
     return '0.'+str2+str; 
    } 
    mag= (mag-str.length)+1; 
    while(mag> str2.length){ 
     str2+= '0'; 
    } 
    return str+str2; 
} 



input: 1e+30 
longnumberstring: 1000000000000000000000000000000 
to Number: 1e+30 
input: 1.456789123456e-30 
longnumberstring: 0.000000000000000000000000000001456789123456 
to Number: 1.456789123456e-30 
input: 1.456789123456e+30 
longnumberstring: 1456789123456000000000000000000 
to Number: 1.456789123456e+30 
input: 1e+80 longnumberstring: 100000000000000000000000000000000000000000000000000000000000000000000000000000000 
to Number: 1e+80 

Answer 5

Użyj Number (string)

Przykład: var a=Number("1.1e+2"); daje = 110