JavaScript преобразует большую INT в научную нотацию, когда число становится большим. Как я могу предотвратить это?
Как избежать научной нотации для больших чисел в JavaScript?
Ответ 1
Есть Number.toFixed, но он использует научную запись, если число> = 1e21 и имеет максимальную точность 20. Кроме этого, вы можете бросить свои собственные, но это будет грязно.
function toFixed(x) {
if (Math.abs(x) < 1.0) {
var e = parseInt(x.toString().split('e-')[1]);
if (e) {
x *= Math.pow(10,e-1);
x = '0.' + (new Array(e)).join('0') + x.toString().substring(2);
}
} else {
var e = parseInt(x.toString().split('+')[1]);
if (e > 20) {
e -= 20;
x /= Math.pow(10,e);
x += (new Array(e+1)).join('0');
}
}
return x;
}
Выше используется cheap- 'n' -easy строковое повторение ((new Array(n+1)).join(str)). Вы можете определить String.prototype.repeat с помощью русского крестьянского умножения и использовать его вместо этого.
Этот ответ должен применяться только к контексту вопроса: отображение большого числа без использования научных обозначений. Для всего остального вы должны использовать библиотеку BigInt, такую как BigNumber, Leemon BigInt или BigInteger. В дальнейшем предлагаемый BigInt (примечание: не Leemon) должен поддерживаться изначально (Chrome имеет поддержку, и он работает над Firefox).
Ответ 2
Я знаю, что это старый вопрос, но в последнее время показывает активный. MDN toLocaleString
const myNumb = 1000000000000000000000;
console.log( myNumb ); // 1e+21
console.log( myNumb.toLocaleString() ); // "1,000,000,000,000,000,000,000"
console.log( myNumb.toLocaleString('fullwide', {useGrouping:false}) ); // "1000000000000000000000"
Вы можете использовать параметры для форматирования вывода.
Замечания:
Number.toLocaleString() округляет после 16 десятичных знаков, так что...
const myNumb = 586084736227728377283728272309128120398;
console.log( myNumb.toLocaleString('fullwide', { useGrouping: false }) );
... возвращается...
586084736227728400000000000000000000000
Это, возможно, нежелательно, если точность важна в намеченном результате.
Ответ 3
Для небольшого числа, и вы знаете, сколько десятичных чисел вы хотите, вы можете использовать toFixed, а затем использовать regexp для удаления конечных нулей.
Number(1e-7).toFixed(8).replace(/\.?0+$/,"") //0.000
Ответ 4
еще одно возможное решение:
function toFix(i){
var str='';
do{
let a = i%10;
i=Math.trunc(i/10);
str = a+str;
}while(i>0)
return str;
}
Ответ 5
Вот мой короткий вариант метода Number.prototype.toFixed, который работает с любым числом:
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(p, b) {
return p + Array(b - p.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"Ответ 6
Следующее решение обходит автоматическое форматированное форматирование для очень больших и очень маленьких чисел. Это решение outis с исправлением: он не работал для очень маленьких отрицательных чисел.
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));Ответ 7
Это то, что я использовал для того, чтобы принимать значение из ввода, расширяя числа меньше 17digits и преобразовывая экспоненциальные числа в x10 y
// e.g.
// niceNumber("1.24e+4") becomes
// 1.24x10 to the power of 4 [displayed in Superscript]
function niceNumber(num) {
try{
var sOut = num.toString();
if ( sOut.length >=17 || sOut.indexOf("e") > 0){
sOut=parseFloat(num).toPrecision(5)+"";
sOut = sOut.replace("e","x10<sup>")+"</sup>";
}
return sOut;
}
catch ( e) {
return num;
}
}
Ответ 8
Ответы других не дают вам точного числа!
Эта функция точно вычисляет желаемое число и возвращает его в строке, чтобы предотвратить его изменение с помощью javascript!
Если вам нужен числовой результат, просто умножьте результат функции на номер один!
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;
}
Ответ 9
Вы можете перебрать число и добиться округления
//возможность замены char при заданном индексе
String.prototype.replaceAt=function(index, character) {
return this.substr(0, index) + character + this.substr(index+character.length);
}
//зацикливание числа начинается
var str = "123456789123456799.55";
var arr = str.split('.');
str = arr[0];
i = (str.length-1);
if(arr[1].length && Math.round(arr[1]/100)){
while(i>0){
var intVal = parseInt(str.charAt(i));
if(intVal == 9){
str = str.replaceAt(i,'0');
console.log(1,str)
}else{
str = str.replaceAt(i,(intVal+1).toString());
console.log(2,i,(intVal+1).toString(),str)
break;
}
i--;
}
}
Ответ 10
Я пробовал работать с строковой формой, а не с номером, и это, похоже, сработало. Я тестировал это только в Chrome, но он должен быть универсальным:
function removeExponent(s) {
var ie = s.indexOf('e');
if (ie != -1) {
if (s.charAt(ie + 1) == '-') {
// negative exponent, prepend with .0s
var n = s.substr(ie + 2).match(/[0-9]+/);
s = s.substr(2, ie - 2); // remove the leading '0.' and exponent chars
for (var i = 0; i < n; i++) {
s = '0' + s;
}
s = '.' + s;
} else {
// positive exponent, postpend with 0s
var n = s.substr(ie + 1).match(/[0-9]+/);
s = s.substr(0, ie); // strip off exponent chars
for (var i = 0; i < n; i++) {
s += '0';
}
}
}
return s;
}
Ответ 11
Я думаю, что может быть несколько похожих ответов, но здесь я придумал
// If you're gonna tell me not to use 'with' I understand, just,
// it has no other purpose, ;( andthe code actually looks neater
// 'with' it but I will edit the answer if anyone insists
var commas = false;
function digit(number1, index1, base1) {
with (Math) {
return floor(number1/pow(base1, index1))%base1;
}
}
function digits(number1, base1) {
with (Math) {
o = "";
l = floor(log10(number1)/log10(base1));
for (var index1 = 0; index1 < l+1; index1++) {
o = digit(number1, index1, base1) + o;
if (commas && i%3==2 && i<l) {
o = "," + o;
}
}
return o;
}
}
// Test - this is the limit of accurate digits I think
console.log(1234567890123450);
Примечание: это так же точно, как математические функции javascript и имеет проблемы при использовании log вместо log10 в строке перед циклом for; он будет записывать 1000 в base-10 как 000, поэтому я изменил его на log10, потому что люди в любом случае будут использовать base-10.
Возможно, это не очень точное решение, но я с гордостью могу сказать, что оно может успешно переводить числа между базами и поставляется с опцией для запятых!
Ответ 12
Используйте .toPrecision, .toFixed и т.д. Вы можете подсчитать количество цифр в своем номере, переведя его в строку с помощью .toString, затем посмотрев на ее .length.
Ответ 13
Я знаю это много лет спустя, но недавно я работал над подобной проблемой, и я хотел опубликовать свое решение. Принимаемый в настоящее время ответ набирает часть экспоненты с 0, а мои попытки найти точный ответ, хотя в целом он не совсем точен для очень больших чисел из-за предела JS в точности с плавающей точкой.
Это работает для Math.pow(2, 100), возвращая правильное значение 1267650600228229401496703205376.
function toFixed(x) {
var result = '';
var xStr = x.toString(10);
var digitCount = xStr.indexOf('e') === -1 ? xStr.length : (parseInt(xStr.substr(xStr.indexOf('e') + 1)) + 1);
for (var i = 1; i <= digitCount; i++) {
var mod = (x % Math.pow(10, i)).toString(10);
var exponent = (mod.indexOf('e') === -1) ? 0 : parseInt(mod.substr(mod.indexOf('e')+1));
if ((exponent === 0 && mod.length !== i) || (exponent > 0 && exponent !== i-1)) {
result = '0' + result;
}
else {
result = mod.charAt(0) + result;
}
}
return result;
}
console.log(toFixed(Math.pow(2,100))); // 1267650600228229401496703205376Ответ 14
Ваш вопрос:
number :0x68656c6c6f206f72656f
display:4.9299704811152646e+23
Вы можете использовать это: https://github.com/MikeMcl/bignumber.js
Библиотека JavaScript для десятичной и недесятичной арифметики произвольной точности.
как это:
let ten =new BigNumber('0x68656c6c6f206f72656f',16);
console.log(ten.toString(10));
display:492997048111526447310191
Ответ 15
Если вы просто делаете это для отображения, вы можете построить массив из цифр до округления.
var num = Math.pow(2, 100);
var reconstruct = [];
while(num > 0) {
reconstruct.unshift(num % 10);
num = Math.floor(num / 10);
}
console.log(reconstruct.join(''));
Ответ 16
В настоящее время нет естественной функции для растворения научной нотации. Однако для этого вы должны написать свои собственные функции.
Вот мой:
function dissolveExponentialNotation(number)
{
if(!Number.isFinite(number)) { return undefined; }
let text = number.toString();
let items = text.split('e');
if(items.length == 1) { return text; }
let significandText = items[0];
let exponent = parseInt(items[1]);
let characters = Array.from(significandText);
let minus = characters[0] == '-';
if(minus) { characters.splice(0, 1); }
let indexDot = characters.reduce((accumulator, character, index) =>
{
if(!accumulator.found) { if(character == '.') { accumulator.found = true; } else { accumulator.index++; } }
return accumulator;
}, { index: 0, found: false }).index;
characters.splice(indexDot, 1);
indexDot += exponent;
if(indexDot >= 0 && indexDot < characters.length - 1)
{
characters.splice(indexDot, 0, '.');
}
else if(indexDot < 0)
{
characters.unshift("0.", "0".repeat(-indexDot));
}
else
{
characters.push("0".repeat(indexDot - characters.length));
}
return (minus ? "-" : "") + characters.join("");
}
Ответ 17
Вы можете использовать от-экспоненциальный модуль. Он легкий и полностью протестирован.
import fromExponential from 'from-exponential';
fromExponential(1.123e-10); // => '0.0000000001123'
Ответ 18
Вы также можете использовать YourJS.fullNumber. Например YourJS.fullNumber(Number.MAX_VALUE) приводит к следующему: 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
Это также работает для действительно небольших чисел. YourJS.fullNumber(Number.MIN_VALUE) возвращает это: 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005
Важно отметить, что эта функция всегда будет возвращать конечные числа в виде строк, но будет возвращать неконечные числа (например, NaN или Infinity) как undefined.
Вы можете проверить это в консоли YourJS здесь.
Ответ 19
function printInt(n) { return n.toPrecision(100).replace(/\..*/,""); }
с некоторыми проблемами:
- 0,9 отображается как "0"
- -0.9 отображается как "-0"
- 1e100 отображается как "1"
- работает только для чисел до ~ 1e99 => использовать другую константу для больших чисел; или меньше для оптимизации.
Ответ 20
Вы можете использовать number.toString(10.1):
console.log(Number.MAX_VALUE.toString(10.1));
Примечание. В настоящее время это работает в Chrome, но не в Firefox. В спецификации указано, что радиус должен быть целым числом, поэтому это приводит к ненадежному поведению.
Ответ 21
У меня была такая же проблема с возвратом оракула, но я нуждался в фактическом количестве для URL-адреса. Я просто использовал трюк PHP, вычитая нуль, и я получаю правильный номер.
например, 5.4987E7 - это val.
newval = val - 0;
newval теперь равен 54987000