JavaScript에서 큰 숫자에 대한 과학적 표기법을 피하는 방법은 무엇입니까?
JavaScript는 문자열 컨텍스트에서 사용할 때 21자리 이상의 정수를 과학적 표기로 변환합니다.URL의 일부로 정수를 인쇄하고 있습니다.변환이 발생하지 않도록 하려면 어떻게 해야 합니까?
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;
}
반복n'-'n'-'n'-'n'-')을 사용합니다.(new Array(n+1)).join(str)를 정의할 수 .String.prototype.repeat러시아 농민 곱셈을 사용하고 대신 그것을 사용합니다.
이 답변은 과학적 표기법을 사용하지 않고 큰 숫자를 표시하는 질문의 맥락에만 적용되어야 합니다.그 외의 경우에는 BigNumber, Leemon의 BigInt 또는 BigInteger와 같은 BigInt 라이브러리를 사용해야 합니다.앞으로 새로운 네이티브 BigInt(참고: Leemon's가 아님)를 사용할 수 있을 것입니다.Crome과 이를 기반으로 한 브라우저(Chrome, 새로운 Edge [v79+], Brave), Firefox는 모두 지원되며 Safari의 지원이 진행 중입니다.
BigInt를 BigInt는 BigInt입니다.BigInt(n).toString()
예:
const n = 13523563246234613317632;
console.log("toFixed (wrong): " + n.toFixed());
console.log("BigInt (right): " + BigInt(n).toString());단, JavaScript 번호(BigInt가 아님)로 출력하는 정수는 15-16자리(구체적으로는 다음 값보다 큼)를 초과합니다.Number.MAX_SAFE_INTEGER + 1[9,007,199,254,740,992])을 클릭합니다.JavaScript의 숫자 유형(IEEE-754 배정도 부동 소수점)은 이 점을 초과하는 모든 정수를 정확하게 유지할 수 없기 때문입니다.의 경우Number.MAX_SAFE_INTEGER + 1수 마찬가지로8
때문에 여러분이 할 수 은, 의지할 수 있다면,BigInt합니다.BigInt★★★★
const n = BigInt("YourNumberHere");
예:
const n1 = BigInt(18014398509481985); // WRONG, will round to 18014398509481984
// before `BigInt` sees it
console.log(n1.toString() + " <== WRONG");
const n2 = BigInt("18014398509481985"); // RIGHT, BigInt handles it
console.log(n2.toString() + " <== Right");오래된 질문인 건 알지만 최근에 활성화 된 것 같습니다.MDN to Locale String
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
의도한 결과에서 정확도가 중요한 경우 이는 바람직하지 않을 수 있습니다.
소수점 이하에서는 toFixed를 사용하고 regexp를 사용하여 후행 제로를 삭제할 수 있습니다.
Number(1e-7).toFixed(8).replace(/\.?0+$/,"") //0.000
또 하나의 가능한 해결책:
function toFix(i){
var str='';
do{
let a = i%10;
i=Math.trunc(i/10);
str = a+str;
}while(i>0)
return str;
}
규칙적인 표현들을 샅샅이 뒤지다.이것은 정밀도 문제도 없고 많은 코드도 아닙니다.
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;
}
}다음은 임의의 번호로 동작하는 짧은 메서드입니다.
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"다음 솔루션에서는 매우 크고 작은 숫자에 대해 자동 지수 형식을 사용하지 않습니다.다음은 오류를 수정한 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));른른른 른른!! !!! !!!! !!!!!!
javascript!
수치 결과가 필요한 경우 1번 함수의 결과를 곱하면 됩니다!
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;
}
from-exponential 모듈을 사용할 수 있습니다.가볍고 충분히 테스트되었습니다.
import fromExponential from 'from-exponential';
fromExponential(1.123e-10); // => '0.0000000001123'
질문:
number :0x68656c6c6f206f72656f
display:4.9299704811152646e+23
https://github.com/MikeMcl/bignumber.js 를 사용할 수 있습니다.
임의 정밀도 10진수 및 10진수 이외의 산술용 JavaScript 라이브러리입니다.
다음과 같습니다.
let ten =new BigNumber('0x68656c6c6f206f72656f',16);
console.log(ten.toString(10));
display:492997048111526447310191
.toPrecision,.toFixed , , , 등 , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ,.toString 에 보면.length.
숫자를 반복하여 반올림할 수 있습니다.
// 지정된 인덱스에서 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자리 미만의 숫자를 확장하고 지수를y x10으로 변환하는 데 사용되었습니다.
// 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;
}
}
비슷한 답변이 몇 가지 있을 것 같은데 제가 생각해낸 게 있어요.
// 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 loop 앞의 행에 log10이 아닌 log10을 사용할 때 문제가 있습니다.이것은 1000을 000으로 표기하기 때문에, 어쨌든 사람들은 대부분 base-10을 사용할 것이기 때문에 log10으로 변경했습니다.
이 솔루션은 정확하지 않을 수도 있지만 여러 베이스로 숫자를 번역할 수 있고 쉼표 옵션도 포함되어 있어 자랑스럽습니다.
몇 년이 지난 건 알지만, 최근에 비슷한 문제에 대해 연구하고 있어서 해결책을 게시하고 싶었습니다.현재 받아들여지고 있는 답변은 지수 부분을 0으로 채우고, 저는 정확한 답을 찾으려고 합니다만, 일반적으로 JS의 부동소수점 정밀도의 한계 때문에 매우 큰 숫자에 대해서는 정확하지 않습니다.
이것은 에 유효합니다.Math.pow(2, 100) 값 disp7650600228229401496703205376을
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표시만을 목적으로 하는 경우는, 반올림하기 전에 자리수로부터 배열을 작성할 수 있습니다.
var num = Math.pow(2, 100);
var reconstruct = [];
while(num > 0) {
reconstruct.unshift(num % 10);
num = Math.floor(num / 10);
}
console.log(reconstruct.join(''));
숫자보다 현악기로 작업을 해보니 잘 되는 것 같더라고요.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("");
}
Lodash를 사용해도 괜찮으시다면 To Safe가 필요합니다.정수()
_.toSafeInteger(3.2);
// => 3
_.toSafeInteger(Number.MIN_VALUE);
// => 0
_.toSafeInteger(Infinity);
// => 9007199254740991
_.toSafeInteger('3.2');
// => 3
Your JS.full Number 。를 들면, 「 」입니다.YourJS.fullNumber(Number.MAX_VALUE)는 다음과 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
아주 적은 숫자에도 효과가 있습니다. YourJS.fullNumber(Number.MIN_VALUE)값이 됩니다.0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005
「 」 「 」 、 「 」 、 「 」 （ 「 」 （ 「 」NaN또는Infinity)로서undefined.
여기 YourJS Console에서 테스트할 수 있습니다.
과학적 표기법을 정수로 변환하는 경우:
parseInt("5.645656456454545e+23", 10)
결과:5
function printInt(n) { return n.toPrecision(100).replace(/\..*/,""); }
몇 가지 문제가 있습니다.
- 0.9는 "0"으로 표시됩니다.
- -0.9는 "-0"으로 표시됩니다.
- 1e100은 "1"로 표시됩니다.
- 는 최대 ~1e99 =>의 숫자에 대해서만 동작합니다.더 큰 숫자에 대해서는 다른 상수를, 최적화에 대해서는 더 작은 상수를 사용합니다.
사용할 수 있습니다.number.toString(10.1):
console.log(Number.MAX_VALUE.toString(10.1));
주의: 이 기능은 현재 Chrome에서는 작동하지만 Firefox에서는 작동하지 않습니다.사양에 따르면 기수는 정수여야 하므로 신뢰할 수 없는 동작이 발생합니다.
oracle return scientic 표기법에서도 같은 문제가 있었습니다만, url에는 실제 번호가 필요했습니다.0을 빼서 PHP 트릭을 사용했는데 정확한 숫자가 나왔어요.
예를 들어 5.4987E7은 Val입니다.
newval = val - 0;
newval은 54987000과 같습니다.
언급URL : https://stackoverflow.com/questions/1685680/how-to-avoid-scientific-notation-for-large-numbers-in-javascript
'programing' 카테고리의 다른 글
| if-statement 내부에 변수 값 할당 (0) | 2023.01.24 |
|---|---|
| MySQL에서 두 데이터 시간 간의 차이 계산 (0) | 2023.01.24 |
| 커스텀 리스트 Android의 아이템에 대한 클릭 문제 표시 (0) | 2023.01.24 |
| Selenium - 페이지가 완전히 로드될 때까지 기다리는 방법 (0) | 2023.01.14 |
| Python에서 '@=' 기호는 무엇입니까? (0) | 2023.01.14 |