JavaScript แปลงINT ขนาดใหญ่เป็นเครื่องหมายทางวิทยาศาสตร์เมื่อจำนวนกลายเป็นใหญ่ ฉันจะป้องกันไม่ให้เกิดเหตุการณ์เช่นนี้ได้อย่างไร

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

ด้านบนใช้การทำซ้ำสตริงราคาถูก '' ง่าย '( (new Array(n+1)).join(str)) คุณสามารถกำหนดString.prototype.repeatโดยใช้การคูณชาวนารัสเซียและใช้สิ่งนั้นแทน

คำตอบนี้ควรใช้กับบริบทของคำถามเท่านั้น: แสดงเป็นจำนวนมากโดยไม่ใช้สัญลักษณ์ทางวิทยาศาสตร์ สำหรับสิ่งอื่นที่คุณควรใช้bigintห้องสมุดเช่นBigNumber , Leemon ของbigintหรือBigInteger ในอนาคตข้างหน้าBigIntพื้นเมืองใหม่(หมายเหตุ: ไม่ใช่ Leemon) ควรมีให้ Chromiumและเบราว์เซอร์ที่ใช้ ( Chrome , Edgeใหม่[v79 +], Brave ) และFirefoxล้วนรองรับ การสนับสนุนของ Safari กำลังดำเนินการอยู่

นี่คือวิธีที่คุณใช้ 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มันทำงานในทวีคูณของ 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");

ฉันรู้ว่านี่เป็นคำถามที่มีอายุมากกว่า แต่แสดงให้เห็นว่าใช้งานล่าสุด 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

นี่อาจเป็นสิ่งที่ไม่พึงประสงค์หากความแม่นยำมีความสำคัญในผลลัพธ์ที่ต้องการ

สำหรับจำนวนน้อยและคุณทราบจำนวนทศนิยมที่คุณต้องการคุณสามารถใช้ 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;
}

นี่คือตัวแปรสั้น ๆ ของฉัน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"

วิธีการแก้ปัญหาต่อไปนี้ข้ามการจัดรูปแบบเลขชี้กำลังแบบอัตโนมัติสำหรับจำนวนมากและน้อยมาก นี่เป็นวิธีการแก้ปัญหาของข้อผิดพลาด : มันไม่ทำงานสำหรับจำนวนลบที่น้อยมาก

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

คำตอบของคนอื่นไม่ให้หมายเลขที่แน่นอน!
ฟังก์ชั่นนี้จะคำนวณจำนวนที่ต้องการอย่างถูกต้องและส่งกลับในสตริงเพื่อป้องกันไม่ให้ถูกเปลี่ยนโดยจาวาสคริปต์!
หากคุณต้องการผลลัพธ์ที่เป็นตัวเลขเพียงแค่คูณผลลัพธ์ของฟังก์ชันในหมายเลขหนึ่ง!

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

ใช้.toPrecision, .toFixedฯลฯ คุณสามารถนับจำนวนตัวเลขในตัวเลขของคุณโดยแปลงเป็นสตริงด้วยการ .toStringดูจาก.lengthนั้น

นี่คือสิ่งที่ฉันลงเอยด้วยการใช้ค่าจากอินพุตเพิ่มจำนวนน้อยกว่า 17 หลักและแปลงเลขชี้กำลังเป็น 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;
  }
}

คุณสามารถวนซ้ำหมายเลขและบรรลุการปัดเศษ

// ฟังก์ชั่นเพื่อแทนที่ถ่านที่ดัชนีที่กำหนด

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

ฉันพยายามทำงานกับสตริงรูปแบบมากกว่าจำนวนและดูเหมือนว่าจะทำงานได้ ฉันเพิ่งทดสอบสิ่งนี้บน 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;
}

ฉันคิดว่าอาจมีคำตอบที่คล้ายกันหลายคำ แต่นี่คือสิ่งที่ฉันคิดไว้

// 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 และมีปัญหาเมื่อใช้บันทึกแทน log10 ในบรรทัดก่อน for for loop; มันจะเขียน 1,000 ใน base-10 เป็น 000 ดังนั้นฉันเปลี่ยนเป็น log10 เพราะคนส่วนใหญ่จะใช้ base-10 อย่างไรก็ตาม

นี่อาจไม่ใช่วิธีที่แม่นยำมาก แต่ฉันภูมิใจที่จะบอกว่าสามารถแปลตัวเลขข้ามฐานได้สำเร็จและมาพร้อมตัวเลือกสำหรับเครื่องหมายจุลภาค!

คำถามของคุณ:

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

ฉันรู้ว่าหลายปีต่อมา แต่ฉันทำงานเกี่ยวกับปัญหาที่คล้ายกันเมื่อเร็ว ๆ นี้และฉันต้องการโพสต์โซลูชันของฉัน คำตอบที่ได้รับการยอมรับในปัจจุบันจะแจกแจงส่วนเลขชี้กำลังด้วย 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

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

หากคุณเพียงแค่ทำเพื่อแสดงคุณสามารถสร้างอาร์เรย์จากตัวเลขก่อนที่จะถูกปัดเศษ

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

ขณะนี้ยังไม่มีฟังก์ชั่นพื้นฐานในการสลายสัญกรณ์ทางวิทยาศาสตร์ อย่างไรก็ตามเพื่อจุดประสงค์นี้คุณต้องเขียนฟังก์ชั่นของคุณเอง

นี่คือของฉัน:

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

คุณสามารถใช้โมดูลจากเลขชี้กำลัง มันมีน้ำหนักเบาและทดสอบอย่างเต็มที่

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หรือInfinity)undefinedเป็น

คุณสามารถทดสอบออกในคอนโซล YourJS ที่นี่

คุณสามารถใช้number.toString(10.1):

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

หมายเหตุ: ปัจจุบันสามารถใช้งานได้ใน Chrome แต่ไม่สามารถใช้งานใน Firefox ข้อมูลจำเพาะระบุว่า radix ต้องเป็นจำนวนเต็มดังนั้นผลลัพธ์นี้จึงมีพฤติกรรมที่ไม่น่าเชื่อถือ

ฉันมีปัญหาเดียวกันกับ oracle ที่ส่งคืนโน้ตทางวิทยาศาสตร์ แต่ฉันต้องการหมายเลขจริงสำหรับ URL ฉันเพิ่งใช้เคล็ดลับ PHP โดยการลบศูนย์และฉันได้ตัวเลขที่ถูกต้อง

เช่น 5.4987E7 คือ val

newval = val - 0;

ตอนนี้ใหม่เท่ากับ 54987000