当在字符串上下文中使用时，JavaScript将超过21位的整数转换为科学符号。我打印了一个整数作为URL的一部分。我怎样才能阻止这种转变的发生?
有号码。固定，但如果数字>= 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;
}
上面使用了廉价-'n'-easy字符串重复((new Array(n+1)).join(str))。你可以用俄国农民乘法来定义String.prototype.repeat。
这个答案应该只适用于问题的上下文:显示一个大数字而不使用科学计数法。对于其他任何东西，您应该使用BigInt库，例如BigNumber、lemon 's BigInt或BigInteger。展望未来，新的原生BigInt(注意:不是lemon的)应该可用;Chromium和基于它的浏览器(Chrome、新的Edge [v79+]、Brave)和Firefox都支持;Safari的支持正在进行中。
BigInt(n).toString()
例子:
Const n = 13523563246234613317632; console.log("toFixed (wrong): " + n.toFixed()); console.log("BigInt(右):" + BigInt(n).toString());
Beware, though, that any integer you output as a JavaScript number (not a BigInt) that's more than 15-16 digits (specifically, greater than Number.MAX_SAFE_INTEGER + 1 [9,007,199,254,740,992]) may be be rounded, because JavaScript's number type (IEEE-754 double-precision floating point) can't precisely hold all integers beyond that point. As of Number.MAX_SAFE_INTEGER + 1 it's working in multiples of 2, so it can't hold odd numbers anymore (and similiarly, at 18,014,398,509,481,984 it starts working in multiples of 4, then 8, then 16, ...).
因此，如果你可以依赖BigInt支持，输出你的数字作为一个字符串传递给BigInt函数:
const n = BigInt("YourNumberHere");
例子:
const n1 = BigInt(18014398509481985);//错误，将四舍五入到18014398509481984 在' BigInt '看到它之前 console.log(n1.toString() + " <== error "); const n2 = BigInt("18014398509481985");//右，BigInt处理它 console.log(n2.toString() + " <== Right");
我有同样的问题与甲骨文返回科学符号，但我需要一个url的实际数字。我只是用了一个PHP技巧减去0，得到了正确的数字。
例如，5.4987E7是val。
newval = val - 0;
Newval现在等于54987000
您可以循环该数字并实现舍入
//函数替换给定索引的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--;
}
}
这就是我最终使用的从输入中获取值的方法，扩展小于17位的数字并将指数数转换为x10y
// 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;
}
}
我知道这是很多年后的事情了，但我最近一直在研究一个类似的问题，我想把我的解决方案发布出来。目前接受的答案是用0填充指数部分，我试图找到确切的答案，尽管由于JS在浮点精度方面的限制，通常它对于非常大的数字不是完全准确的。
这确实适用于数学。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
对于较小的数字，并且您知道需要多少小数，您可以使用toFixed，然后使用regexp删除后面的零。
Number(1e-7).toFixed(8).replace(/\.?0+$/,"") //0.000
你可以使用number.toString(10.1):
console.log(Number.MAX_VALUE.toString(10.1));
注意:这目前适用于Chrome，但不适用于Firefox。规范规定基数必须是整数，所以这会导致不可靠的行为。
还有一个可能的解决方案:
function toFix(i){
var str='';
do{
let a = i%10;
i=Math.trunc(i/10);
str = a+str;
}while(i>0)
return str;
}
下面是我的短变体的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(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"
你的问题:
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
如果您只是为了显示而这样做，您可以从四舍五入之前的数字构建一个数组。
var num = Math.pow(2, 100);
var reconstruct = [];
while(num > 0) {
reconstruct.unshift(num % 10);
num = Math.floor(num / 10);
}
console.log(reconstruct.join(''));
其他人的答案并不能给你确切的数字! 这个函数精确地计算所需的数字，并在字符串中返回它，以防止它被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;
}
下面的解决方案绕过了非常大和非常小的数字的自动指数格式。这是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));
我试着用字符串的形式，而不是数字，这似乎是可行的。我只在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;
}
目前还没有原生的功能来消解科学记数法。但是，出于这个目的，您必须编写自己的功能。
这是我的:
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("");
}
我想可能有几个类似的答案，但我想到了一个
// 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数学函数一样准确，并且在for循环之前的行上使用log而不是log10时存在问题;它会把1000以10为底数写成10000，所以我把它改成了log10，因为大多数人都会用10为底数。
这可能不是一个非常准确的解决方案，但我很自豪地说，它可以成功地跨基数转换数字，并提供了一个逗号选项!
我知道这是一个老问题，但最近很活跃。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
如果准确性在预期结果中很重要，这可能是不可取的。
你可以用从指数模块。它是轻量级的，并且经过了充分的测试。
import fromExponential from 'from-exponential';
fromExponential(1.123e-10); // => '0.0000000001123'
你也可以使用YourJS.fullNumber。例如，YourJS.fullNumber(Number.MAX_VALUE)的结果如下: 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
它也适用于非常小的数字。YourJS.fullNumber(Number.MIN_VALUE)返回: 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005
重要的是要注意，这个函数总是返回有限的数字作为字符串，但会返回非有限的数字(例如。NaN或无穷大)作为未定义的。
你可以在YourJS控制台进行测试。
function printInt(n) { return n.toPrecision(100).replace(/\..*/,""); }
有一些问题:
0.9显示为“0” -0.9显示为"-0" 1e100显示为“1” 仅适用于~1e99 =>以下的数字，对于更大的数字使用其他常数;或者更小的优化。
找出正则表达式。这没有精度问题，也不需要很多代码。
function toPlainString(num) { return (''+ +num).replace(/(-?)(\d*)\.?(\d*)e([+-]\d+)/, function(a,b,c,d,e) { return e < 0 ? b + '0.' + Array(1-e-c.length).join(0) + c + d : b + c + d + Array(e-d.length+1).join(0); }); } console.log(toPlainString(12345e+12)); console.log(toPlainString(12345e+24)); console.log(toPlainString(-12345e+24)); console.log(toPlainString(12345e-12)); console.log(toPlainString(123e-12)); console.log(toPlainString(-123e-12)); console.log(toPlainString(-123.45e-56)); console.log(toPlainString('1e-8')); console.log(toPlainString('1.0e-8'));
这篇文章的问题是避免用e表示数字，而将数字作为普通数字。
因此，如果所需要的只是将e(科学)表示法数字转换为普通数字(包括小数的情况)而不损失精度，那么必须避免使用Math对象和其他javascript数字方法，以便在处理大数字和大分数时不会发生舍入(由于内部存储为二进制格式，这总是发生)。
下面的函数将e(科学)表示法数字转换为处理大数和大分数的普通数字(包括分数)，而不损失准确性，因为它没有使用内置的数学和数字函数来处理或操作数字。
该函数还处理普通数字，因此可以将怀疑是'e'符号的数字传递给该函数进行修正。
该函数应该适用于不同的地区小数点。
提供了94个测试用例。
对于较大的电子表示法数字，将数字作为字符串传递。
例子:
eToNumber("123456789123456789.111122223333444455556666777788889999e+50");
// output:
"12345678912345678911112222333344445555666677778888999900000000000000"
eToNumber("123.456123456789123456895e-80");
// output:
"0.00000000000000000000000000000000000000000000000000000000000000000000000000000123456123456789123456895"
eToNumber("123456789123456789.111122223333444455556666777788889999e-50");
// output:
"0.00000000000000000000000000000000123456789123456789111122223333444455556666777788889999"
Javascript中有效的电子符号数字包括:
123e1 ==> 1230
123E1 ==> 1230
123e+1 ==> 1230
123.e+1 ==> 1230
123e-1 ==> 12.3
0.1e-1 ==> 0.01
.1e-1 ==> 0.01
-123e1 ==> -1230
/****************************************************************** * Converts e-Notation Numbers to Plain Numbers ****************************************************************** * @function eToNumber(number) * @version 1.00 * @param {e nottation Number} valid Number in exponent format. * pass number as a string for very large 'e' numbers or with large fractions * (none 'e' number returned as is). * @return {string} a decimal number string. * @author Mohsen Alyafei * @date 17 Jan 2020 * Note: No check is made for NaN or undefined input numbers. * *****************************************************************/ function eToNumber(num) { let sign = ""; (num += "").charAt(0) == "-" && (num = num.substring(1), sign = "-"); let arr = num.split(/[e]/ig); if (arr.length < 2) return sign + num; let dot = (.1).toLocaleString().substr(1, 1), n = arr[0], exp = +arr[1], w = (n = n.replace(/^0+/, '')).replace(dot, ''), pos = n.split(dot)[1] ? n.indexOf(dot) + exp : w.length + exp, L = pos - w.length, s = "" + BigInt(w); w = exp >= 0 ? (L >= 0 ? s + "0".repeat(L) : r()) : (pos <= 0 ? "0" + dot + "0".repeat(Math.abs(pos)) + s : r()); L= w.split(dot); if (L[0]==0 && L[1]==0 || (+w==0 && +s==0) ) w = 0; //** added 9/10/2021 return sign + w; function r() {return w.replace(new RegExp(`^(.{${pos}})(.)`), `$1${dot}$2`)} } //***************************************************************** //================================================ // Test Cases //================================================ let r = 0; // test tracker r |= test(1, "123456789123456789.111122223333444455556666777788889999e+50", "12345678912345678911112222333344445555666677778888999900000000000000"); r |= test(2, "123456789123456789.111122223333444455556666777788889999e-50", "0.00000000000000000000000000000000123456789123456789111122223333444455556666777788889999"); r |= test(3, "123456789e3", "123456789000"); r |= test(4, "123456789e1", "1234567890"); r |= test(5, "1.123e3", "1123"); r |= test(6, "12.123e3", "12123"); r |= test(7, "1.1234e1", "11.234"); r |= test(8, "1.1234e4", "11234"); r |= test(9, "1.1234e5", "112340"); r |= test(10, "123e+0", "123"); r |= test(11, "123E0", "123"); // //============================ r |= test(12, "123e-1", "12.3"); r |= test(13, "123e-2", "1.23"); r |= test(14, "123e-3", "0.123"); r |= test(15, "123e-4", "0.0123"); r |= test(16, "123e-2", "1.23"); r |= test(17, "12345.678e-1", "1234.5678"); r |= test(18, "12345.678e-5", "0.12345678"); r |= test(19, "12345.678e-6", "0.012345678"); r |= test(20, "123.4e-2", "1.234"); r |= test(21, "123.4e-3", "0.1234"); r |= test(22, "123.4e-4", "0.01234"); r |= test(23, "-123e+0", "-123"); r |= test(24, "123e1", "1230"); r |= test(25, "123e3", "123000"); r |= test(26, -1e33, "-1000000000000000000000000000000000"); r |= test(27, "123e+3", "123000"); r |= test(28, "123E+7", "1230000000"); r |= test(29, "-123.456e+1", "-1234.56"); r |= test(30, "-1.0e+1", "-10"); r |= test(31, "-1.e+1", "-10"); r |= test(32, "-1e+1", "-10"); r |= test(34, "-0", "-0"); r |= test(37, "0e0", "0"); r |= test(38, "123.456e+4", "1234560"); r |= test(39, "123E-0", "123"); r |= test(40, "123.456e+50", "12345600000000000000000000000000000000000000000000000"); r |= test(41, "123e-0", "123"); r |= test(42, "123e-1", "12.3"); r |= test(43, "123e-3", "0.123"); r |= test(44, "123.456E-1", "12.3456"); r |= test(45, "123.456123456789123456895e-80", "0.00000000000000000000000000000000000000000000000000000000000000000000000000000123456123456789123456895"); r |= test(46, "-123.456e-50", "-0.00000000000000000000000000000000000000000000000123456"); r |= test(47, "-0e+1", "-0"); r |= test(48, "0e+1", "0"); r |= test(49, "0.1e+1", "1"); r |= test(50, "-0.01e+1", "-0.1"); r |= test(51, "0.01e+1", "0.1"); r |= test(52, "-123e-7", "-0.0000123"); r |= test(53, "123.456e-4", "0.0123456"); r |= test(54, "1.e-5", "0.00001"); // handle missing base fractional part r |= test(55, ".123e3", "123"); // handle missing base whole part // The Electron's Mass: r |= test(56, "9.10938356e-31", "0.000000000000000000000000000000910938356"); // The Earth's Mass: r |= test(57, "5.9724e+24", "5972400000000000000000000"); // Planck constant: r |= test(58, "6.62607015e-34", "0.000000000000000000000000000000000662607015"); r |= test(59, "0.000e3", "0"); r |= test(60, "0.000000000000000e3", "0"); r |= test(61, "-0.0001e+9", "-100000"); r |= test(62, "-0.0e1", "-0"); r |= test(63, "-0.0000e1", "-0"); r |= test(64, "1.2000e0", "1.2000"); r |= test(65, "1.2000e-0", "1.2000"); r |= test(66, "1.2000e+0", "1.2000"); r |= test(67, "1.2000e+10", "12000000000"); r |= test(68, "1.12356789445566771234e2", "112.356789445566771234"); // ------------- testing for Non e-Notation Numbers ------------- r |= test(69, "12345.7898", "12345.7898") // no exponent r |= test(70, 12345.7898, "12345.7898") // no exponent r |= test(71, 0.00000000000001, "0.00000000000001") // from 1e-14 r |= test(72, 0.0000000000001, "0.0000000000001") // from 1e-13 r |= test(73, 0.000000000001, "0.000000000001") // from 1e-12 r |= test(74, 0.00000000001, "0.00000000001") // from 1e-11 r |= test(75, 0.0000000001, "0.0000000001") // from 1e-10 r |= test(76, 0.000000001, "0.000000001") // from 1e-9 r |= test(77, 0.00000001, "0.00000001") // from 1e-8 r |= test(78, 0.0000001, "0.0000001") // from 1e-7 r |= test(79, 1e-7, "0.0000001") // from 1e-7 r |= test(80, -0.0000001, "-0.0000001") // from 1e-7 r |= test(81, 0.0000005, "0.0000005") // from 1e-7 r |= test(82, 0.1000005, "0.1000005") // from 1e-7 r |= test(83, 1e-6, "0.000001") // from 1e-6 r |= test(84, 0.000001, "0.000001"); // from 1e-6 r |= test(85, 0.00001, "0.00001"); // from 1e-5 r |= test(86, 0.0001, "0.0001"); // from 1e-4 r |= test(87, 0.001, "0.001"); // from 1e-3 r |= test(88, 0.01, "0.01"); // from 1e-2 r |= test(89, 0.1, "0.1") // from 1e-1 r |= test(90, -0.0000000000000345, "-0.0000000000000345"); // from -3.45e-14 r |= test(91, -0, "0"); r |= test(92, "-0", "-0"); r |= test(93,2e64,"20000000000000000000000000000000000000000000000000000000000000000"); r |= test(94,"2830869077153280552556547081187254342445169156730","2830869077153280552556547081187254342445169156730"); if (r == 0) console.log("All 94 tests passed."); //================================================ // Test function //================================================ function test(testNumber, n1, should) { let result = eToNumber(n1); if (result !== should) { console.log(`Test ${testNumber} Failed. Output: ${result}\n Should be: ${should}`); return 1; } }
如果你不介意使用Lodash，它必须使用toSafeInteger()
_.toSafeInteger(3.2);
// => 3
_.toSafeInteger(Number.MIN_VALUE);
// => 0
_.toSafeInteger(Infinity);
// => 9007199254740991
_.toSafeInteger('3.2');
// => 3
这对我没有帮助:
console.log( myNumb.toLocaleString('fullwide', {useGrouping:false}) );
但这:
value.toLocaleString("fullwide", {
useGrouping: false,
maximumSignificantDigits: 20,
})
试试这个:
Number.standardizenumber = function (number,n) {
var mantissa = number.toLocaleString(
'en-US', {
useGrouping: false,
signDisplay: "never",
notation: "scientific",
minimumFractionDigits: 16,
maximumFractionDigits: 16
}
).toLowerCase().split('e')[0].replace(/\./g,'');
var exponentNegative = "0".repeat(Math.max(+Math.abs(number).toExponential().toLowerCase().split('e-')[1]-1,0)) + mantissa;
var exponentPositive = Math.abs(number)<1E17?mantissa.slice(0,+Math.abs(number).toExponential().toLowerCase().split('e+')[1]+1):mantissa+(Math.abs(number).toExponential().toLowerCase().split('e+')[1]-16);
var decimalExpPositive = Math.abs(number)<1E17?mantissa.slice(0,Math.abs(number).toExponential().toLowerCase().split('e+')[0]-16):undefined;
var fullDec = number===0?(1/number<0?'-0':'0'):(1/Math.sign(number)<0?'-':'')+(Math.abs(number)>=1?[exponentPositive,(number%1===0?(decimalExpPositive.slice(+Math.abs(number).toExponential().toLowerCase().split('e+')[1]+1)): undefined)].join('.'):`.${exponentNegative}`);
return isNaN(number)===false&&Math.abs(number)<1E17?((number%1===0?number.toLocaleString('en-US', {useGrouping: false}):fullDec).includes('.')===false?fullDec.split('.')[0].replace(/\B(?=(\d{3})+(?!\d))/g, ","):fullDec.replace(/(\.[0-9]*[1-9])0+$|\.0*$/,'$1').replace(/\B(?<!\.\d*)(?=(\d{3})+(?!\d))/g, ",")):number.toLocaleString('en-US');
}
Number.standardizenumber(.0000001) // .0000001
Number.standardizenumber(1E21) // 1,000,000,000,000,000,000,000
Number.standardizenumber(1_234_567_890.123456) // 1,234,567,890.123456
