जावास्क्रिप्ट में बड़ी संख्या के लिए वैज्ञानिक संकेतन से कैसे बचें?

Question

जब संख्या बड़ी हो जाती है तो जावास्क्रिप्ट एक बड़े INT को वैज्ञानिक संकेतन में परिवर्तित करता है । मेरे द्वारा इसे होने से कैसे रोका जा सकता है?

Comments

क्या आप चाहते हैं कि 1E21 '1000000000000000000000' के रूप में प्रदर्शित हो? क्या आप इस बात से चिंतित हैं कि संख्या कैसे प्रदर्शित की जाती है, या इसे कैसे संग्रहीत किया जाता है?

— एनआईएस

मैं इस बारे में चिंतित हूँ कि यह कैसे प्रदर्शित होता है: मेरे पास डॉक्यूमेंट है। राइट (myvariable) कमांड है

— chris

मैं किसी URL के भाग के रूप में संख्या की आवश्यकता

— क्रिस

@outis: मानव उपयोगकर्ता केवल वही नहीं हैं जो संख्याएँ पढ़ना चाहते हैं। ऐसा लगता है कि डी 3 एक अपवाद को फेंक देगा जब एक translateपरिवर्तन का सामना करना पड़ता है जिसमें वैज्ञानिक संकेतन में निर्देशांक होते हैं।

— या मैपर

इसके लिए एक उपयोग अभी भी है जब आप एक निश्चित आकार तक की संख्या के साथ काम कर रहे हैं। वैज्ञानिक संकेतन उन उपयोगकर्ताओं के लिए पढ़ना कठिन होगा जो वैज्ञानिक नोटेशन के बाद भी नहीं जानते हैं।

— हिप्पिएट्रैल

Answer 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;
}

ऊपर सस्ते -n'- आसान स्ट्रिंग पुनरावृत्ति ( (new Array(n+1)).join(str)) का उपयोग करता है । आप परिभाषित कर सकते हैंString.prototype.repeat रूसी किसान गुणन का उपयोग करके कर और इसके बजाय इसका उपयोग कर सकते हैं।

यह उत्तर केवल प्रश्न के संदर्भ में लागू किया जाना चाहिए: वैज्ञानिक अंकन का उपयोग किए बिना बड़ी संख्या में प्रदर्शित करना। कुछ और के लिए, आप एक का उपयोग करना चाहिए BigInt जैसे पुस्तकालय, BigNumber , Leemon के BigInt , या BigInteger । आगे बढ़ते हुए, नया देशी बिगइंट (नोट: लेमन का नहीं) उपलब्ध होना चाहिए; क्रोमियम और इसके आधार पर ब्राउज़र ( क्रोम , नया एज [v79 +], बहादुर ) और फ़ायरफ़ॉक्स सभी का समर्थन है; सफारी का सहारा चल रहा है।

यहां बताया गया है कि आप इसके लिए BigInt का उपयोग कैसे करेंगे: BigInt(n).toString()

उदाहरण:

const n = 13523563246234613317632;
console.log("toFixed (wrong): " + n.toFixed());
console.log("BigInt (right):  " + BigInt(n).toString());

हालांकि, सावधान रहें कि आप किसी भी पूर्णांक को जावास्क्रिप्ट संख्या ( Number.MAX_SAFE_INTEGER + 1बिगआईंट नहीं) के रूप में आउटपुट करते हैं, जो 15-16 अंकों से अधिक है (विशेष रूप से, [9,007,199,254,740,992 से अधिक ]) को गोल किया जा सकता है, क्योंकि जावास्क्रिप्ट का नंबर प्रकार (IEEE-754 डबल-परिशुद्धता) फ्लोटिंग पॉइंट) उस बिंदु से परे सभी पूर्णांकों को ठीक से पकड़ नहीं सकता है। जैसा कि Number.MAX_SAFE_INTEGER + 1यह 2 के गुणकों में काम कर रहा है, इसलिए यह अब और विषम संख्या नहीं पकड़ सकता है (और अनजाने में, 18,014,398,509,481,984 पर यह 4 के गुणकों में काम करना शुरू कर देता है, फिर 8, फिर 16, ...)।

नतीजतन, यदि आप 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");

Comments

आपका समाधान मुझे wolframalpha की तुलना में 2 ^ 1000 के लिए एक बहुत अलग परिणाम देता है। कोई संकेत?

— शेन रस्टल

@Shane: यह Q & A फ़्लोटिंग पॉइंट नंबरों को बेस -10 पूर्णांक के रूप में प्रदर्शित करने के बारे में है और उन नंबरों को संबोधित नहीं करता है जिन्हें फ़्लोटिंग पॉइंट फॉर्मेट में प्रस्तुत नहीं किया जा सकता है (जो कि बेस 10 में परिवर्तित होने पर उत्पन्न होगा)। आपको जेएस बिगिंट लाइब्रेरी की आवश्यकता है , जैसा कि अंतिम पंक्ति में बताया गया है।

— 1

@PeterOlson: जैसा मैंने छोड़ा था, वैसा ही देखो Math.abs। सर उठाने के लिए धन्यवाद।

— आउट

toFixed(Number.MAX_VALUE) == Number.MAX_VALUEफिर वापस लौटना चाहिए, लेकिन यह नहीं है ...

— 22

वास्तव में यह कोड क्योंकि यह बहुत छोटे नकारात्मक संख्याओं के लिए काम नहीं करता है: toFixed (-1E-20) -> "0.0000000000000000000.09999999999999999"

— davidthings

Answer 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

यह शायद अवांछनीय है यदि सटीकता वांछित परिणाम में महत्वपूर्ण है।

Comments

यह मूर्खतापूर्ण उत्तर है।

— आरिया

यह प्रेत 2.1.1 में काम नहीं करता है - यह अभी भी वैज्ञानिक संकेतन में समाप्त होता है। क्रोम में ठीक है।

— ईगोर नेपोम्न्यसचीह

यह बहुत छोटे दशमलव के लिए काम नहीं करता है: var myNumb = 0.0000000001; सांत्वना।

— eh1160

एक बहुत ही छोटे दशमलव को प्रारूपित करने के लिए अधिकतमसिग्नेंटडिजिट्स विकल्प (अधिकतम 21) सेट कर सकता है, अर्थात:js console.log( myNumb.toLocaleString('fullwide', { useGrouping: true, maximumSignificantDigits:6}) );

— सर। MaNiAl

Answer 3

छोटी संख्या के लिए, और आप जानते हैं कि आप कितने डेसीमल चाहते हैं, तो आप उपयोग कर सकते हैं और फिर ट्रेलिंग शून्य को हटाने के लिए एक regexp का उपयोग कर सकते हैं।

Number(1e-7).toFixed(8).replace(/\.?0+$/,"") //0.000

Comments

प्रश्न बड़ी संख्या में पूछा गया

— swyx

सावधान रहने के लिए 0 से बचने के एक तर्क के रूप में फोन - यह महत्वपूर्ण अनुगामी शून्य को मिटाने में खत्म हो जाएगा:(1000).toFixed(0).replace(/\.?0+$/,"") // 1, not 1000

— Egor Nepomnyaschih

Answer 4

एक और संभव समाधान:

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

Comments

यह मूल मूल्य को संरक्षित नहीं करता है ... उदाहरण के लिए 31415926535897932384626433832795 31415926535897938480804068462624

— शून्य_cool

सकारात्मक नहीं है, लेकिन जावास्क्रिप्ट बड़ी संख्या को कैसे संभालता है, इसके साथ होने की संभावना है।

— शून्य_कूल

@domsson मूल रूप से क्योंकि IEEE फ़्लोटिंग पॉइंट संख्या अंकगणितीय लागू होते हैं। जावास्क्रिप्ट में संख्याओं को वास्तव में फ्लोटिंग पॉइंट संख्या के साथ-साथ "दशमलव संख्या" के रूप में दर्शाया गया है, कोई मूल "पूर्णांक सटीक प्रकार" नहीं है। आप यहाँ और अधिक पढ़ सकते हैं: medium.com/dailyjs/javascripts-number-type-8d59199db1b6

— Pac0

@zero_cool Number.MAX_SAFE_INTEGERइस समस्या से पीड़ित होने की संभावना से अधिक संख्या ।

— पच0

Answer 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"

Comments

यदि आप Number.MAX_VALUE.toFixedSpecial (2) से Number.MAX_VALUE की तुलना करते हैं, तो आप देखेंगे कि वे समान नहीं हैं।

— ९

@ मनमुटाव बेशक वे समान नहीं हैं, क्योंकि पहला एक स्वरूपित स्ट्रिंग है और दूसरा एक है Number। यदि आप पहले एक को कास्ट करते हैं Number, तो आप देखेंगे कि वे बिल्कुल बराबर हैं: jsfiddle.net/qd6hpnyx/1 । आप अपने :P

— डाउनवोट को

काफी हद तक .... मैंने अभी तक ध्यान नहीं दिया, जब तक कि आप अपना उत्तर संपादित नहीं कर रहे।

— 23

.0खाली स्ट्रिंग के साथ किसी भी अनुगामी को बदलने के लिए बेहतर है ।

— vsync

जब मैं कोशिश करता हूं तो मुझे कुछ अजीब मूल्य मिलता है console.log(2.2e307.toFixedSpecial(10))। मेरा मतलब है ... मुझे कई ट्रेलिंग शून्य मिलते हैं। वैसे भी Upvoting क्योंकि यह मैं क्या जरूरत के करीब लगता है।

— पेट्रोप्रोव

Answer 6

निम्न समाधान बहुत बड़ी और बहुत छोटी संख्याओं के लिए स्वचालित घातांक स्वरूपण को दरकिनार कर देता है। यह बगसिक्स के साथ आउटिस का समाधान है : यह बहुत कम नकारात्मक संख्याओं के लिए काम नहीं कर रहा था।

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));

Comments

नंबरट्रीमिंग (0.0000002) "0.00000019999999999999998"

— रेपहेडको

@raphadko यह कुख्यात जावास्क्रिप्ट फ़्लोटिंग पॉइंट प्रिसिजन प्रॉब्लम है, जो JS में नंबर का उपयोग करते समय एक और पूरी तरह से अलग दर्द है ... उदाहरण के लिए देखें stackoverflow.com/questions/1458633/…

— user56reinstatemonica8

Answer 7

दूसरों के जवाब आपको सटीक संख्या नहीं देते हैं!
यह फ़ंक्शन वांछित संख्या की सही गणना करता है और इसे जावास्क्रिप्ट द्वारा परिवर्तित होने से रोकने के लिए इसे स्ट्रिंग में लौटाता है!
यदि आपको एक संख्यात्मक परिणाम की आवश्यकता है, तो केवल संख्या एक में फ़ंक्शन का परिणाम गुणा करें!

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;
}

Comments

इस कोड के बारे में कुछ अतिरिक्त जानकारी केवल उत्तर ही उपयोगी होगी।

— प्‍लेव्स

टिप्पणियाँ समारोह में जोड़ा गया।

Answer 8

उपयोग .toPrecision, .toFixedआदि। आप अपनी संख्या में अंकों की संख्या को एक स्ट्रिंग में परिवर्तित करके और .toStringफिर उसकी ओर देखकर गिन सकते हैं .length।

Comments

किसी कारण से, काम करने के लिए काम नहीं करता है। अगर आप का प्रयास करें: window.examplenum = 1352356324623461346, और फिर कहते हैं कि चेतावनी (window.examplenum.toPrecision (20)), यह एक चेतावनी पॉप अप नहीं करता है

— क्रिस

वास्तव में यह कभी-कभी वैज्ञानिक संकेतन दिखाते हुए पॉप अप करता है, और अन्य बार यह बिल्कुल भी पॉप नहीं होता है। मैं क्या गलत कर रहा हूं?

— क्रिस

सुझाव विधियों में से कोई भी बड़ी (या छोटी) संख्याओं के लिए काम नहीं करता है। (2e64).toString()वापस आ जाएगा "2e+64", इसलिए .lengthबेकार है।

— कोडमैनएक्स

Answer 9

यह है कि मैं क्या, एक इनपुट से मूल्य लेने के लिए का उपयोग कर x10 के विस्तार संख्या 17digits से भी कम समय और परिवर्तित घातीय संख्या समाप्त हो गया है ^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;
  }
}

Answer 10

आप संख्या पर लूप कर सकते हैं और गोलाई प्राप्त कर सकते हैं

// कार्यक्षमता को दिए गए सूचकांक में चार को बदलने के लिए

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--;
 }
}

Answer 11

मैंने संख्या के बजाय स्ट्रिंग रूप के साथ काम करने की कोशिश की और यह काम करने लगा। मैंने इसे केवल 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;
}

Answer 12

मुझे लगता है कि इस तरह के कई उत्तर हो सकते हैं, लेकिन यहां एक बात सामने आई है

// 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);

नोट: यह केवल जावास्क्रिप्ट गणित कार्यों के समान सटीक है और लूप के लिए लाइन पर लॉग 10 के बजाय लॉग का उपयोग करते समय समस्याएँ हैं; यह बेस -10 में 1000 को 000 के रूप में लिखेगा इसलिए मैंने इसे log10 में बदल दिया क्योंकि लोग ज्यादातर बेस -10 का उपयोग कर रहे होंगे।

यह एक बहुत सटीक समाधान नहीं हो सकता है, लेकिन मुझे यह कहते हुए गर्व है कि यह सफलतापूर्वक आधारों पर संख्याओं का अनुवाद कर सकता है और अल्पविराम के लिए एक विकल्प के साथ आता है!

Answer 13

आपका प्रश्न:

number :0x68656c6c6f206f72656f
display:4.9299704811152646e+23

आप इसका उपयोग कर सकते हैं: https://github.com/MikeMcl/bignumber.js

मनमाने ढंग से सटीक दशमलव और गैर-दशमलव अंकगणित के लिए एक जावास्क्रिप्ट पुस्तकालय।

इस तरह:

let ten =new BigNumber('0x68656c6c6f206f72656f',16);
console.log(ten.toString(10));
display:492997048111526447310191

Comments

खैर, खबरदार है कि bignumber.js 15 महत्वपूर्ण अंकों से आगे नहीं जा सकते हैं ...

— माइकल हेउबर्गर

Answer 14

मुझे पता है कि यह कई साल बाद है, लेकिन मैं हाल ही में इसी तरह के मुद्दे पर काम कर रहा था और मैं अपना समाधान पोस्ट करना चाहता था। वर्तमान में स्वीकृत उत्तर को 0 के साथ घातांक वाले हिस्से से बाहर निकालता है, और मेरा सटीक उत्तर खोजने का प्रयास करता है, हालांकि सामान्य तौर पर फ्लोटिंग पॉइंट परिशुद्धता में जेएस की सीमा के कारण यह बहुत बड़ी संख्या के लिए बिल्कुल सटीक नहीं है।

यह 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

Comments

@ ओरियल - हाँ, आप सही कह रहे हैं; मुझे लगता है कि मैंने जो कुछ भी पहले से कोशिश की थी, वह अन्य कारकों के कारण इस तरह से काम कर रहा था। मैं अपने उत्तर में उस छोटे नोट को हटा दूंगा।

— औरि

काम नहीं करता है:toFixed(Number.MAX_VALUE) == Number.MAX_VALUE

— 22

Answer 15

function printInt(n) { return n.toPrecision(100).replace(/\..*/,""); }

कुछ मुद्दों के साथ:

• 0.9 को "0" के रूप में प्रदर्शित किया जाता है
• -0.9 "-0" के रूप में प्रदर्शित होता है
• 1e100 को "1" के रूप में प्रदर्शित किया जाता है
• केवल ~ 1e99 तक की संख्याओं के लिए काम करता है => अधिक संख्याओं के लिए अन्य स्थिरांक का उपयोग करें; या अनुकूलन के लिए छोटा है।

Comments

हाँ, वे कुछ मुद्दे हैं।

— एडम लेगट

Answer 16

नियमित भावों को तोड़ना। इसका कोई सटीक मुद्दा नहीं है और यह बहुत अधिक कोड नहीं है।

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));

Answer 17

यदि आप इसे केवल प्रदर्शन के लिए कर रहे हैं, तो आप गोल होने से पहले अंकों से एक सरणी बना सकते हैं।

var num = Math.pow(2, 100);
var reconstruct = [];
while(num > 0) {
    reconstruct.unshift(num % 10);
    num = Math.floor(num / 10);
}
console.log(reconstruct.join(''));

Comments

यह सही उत्तर लौटाएगा, लेकिन इतना समय लगेगा और निष्पादन समाप्त होने तक समाप्त हो सकता है।

— हन्नाह मई

Answer 18

वर्तमान में वैज्ञानिक संकेतन को भंग करने के लिए कोई मूल कार्य नहीं है। हालाँकि, इस उद्देश्य के लिए आपको अपनी कार्यक्षमता लिखनी होगी।

मेरा यहाँ है:

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("");
}

Comments

यह वास्तव में बड़ी संख्या के लिए विफल रहता है। मैंने 2830869077153280552556547081187254342445169156730 की कोशिश की और 283086907715328050000000000000000000000000000

— कॉलबैक

Answer 19

आप घातीय मॉड्यूल से उपयोग कर सकते हैं । यह हल्का है और पूरी तरह से परीक्षण किया गया है।

import fromExponential from 'from-exponential';

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

Answer 20

आप YourJS.fullNumber का भी उपयोग कर सकते हैं। उदाहरण के लिए YourJS.fullNumber(Number.MAX_VALUE)निम्नलिखित में परिणाम: 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

यह वास्तव में छोटी संख्या के लिए भी काम करता है। YourJS.fullNumber(Number.MIN_VALUE)यह रिटर्न: 0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005

यह ध्यान रखना महत्वपूर्ण है कि यह फ़ंक्शन हमेशा परिमित संख्याओं को स्ट्रिंग्स के रूप में लौटाएगा लेकिन गैर-परिमित संख्याओं (जैसे NaNया Infinity) के रूप में लौटाएगा undefined।

आप इसे योरेज कंसोल में यहां से देख सकते हैं ।

Answer 21

आप उपयोग कर सकते हैं number.toString(10.1):

console.log(Number.MAX_VALUE.toString(10.1));

नोट: यह वर्तमान में क्रोम में काम करता है, लेकिन फ़ायरफ़ॉक्स में नहीं। विनिर्देश कहते हैं कि मूलांक का पूर्णांक होना चाहिए, इसलिए यह अविश्वसनीय व्यवहार करता है।

Comments

यह क्या करता है? 10.1 का मूलांक?

— जोनिबा

यह काम नहीं करता है। ES5 के बाद से, तर्क पर Toteteger का उपयोग करने के लिए कार्यान्वयन की आवश्यकता होती है। तो उपयोग 10.1 या 10कुछ भी नहीं के बराबर हैं।

— ओरिऑल

हां, यह वास्तव में हाल ही में कुछ हद तक काम करना बंद कर दिया है। किंडा उदास है, लेकिन यह जवाब अब अप्रासंगिक है।

— ज़ांबोनोफ़ेक्स

Answer 22

मेरे पास oracle लौटने के वैज्ञानिक विवरण के साथ एक ही मुद्दा था, लेकिन मुझे एक url के लिए वास्तविक संख्या की आवश्यकता थी। मैंने केवल शून्य को घटाकर एक PHP चाल का उपयोग किया है, और मुझे सही संख्या मिलती है।

उदाहरण के लिए 5.4987E7 घाटी है।

newval = val - 0;

newval अब 54987000 के बराबर है

Comments

इसका कोई असर नहीं हुआ। 5.4987E7 में एक घातांक 21 से कम है, इसलिए यह स्ट्रिंग में परिवर्तित होने के बावजूद पूर्ण संख्या के रूप में दिखाई देता है। (5.4987E21 - 0) .toString () => "5.4987e + 21"

— ड्वाइट