මෙය භාෂාව මගින් අර්ථ දක්වා තිබේද? අර්ථ දක්වා ඇති උපරිමයක් තිබේද? විවිධ බ්‍රව්සර්වල එය වෙනස්ද?

ජාවාස්ක්‍රිප්ට් අංක වර්ග දෙකක් ඇත: Numberසහ BigInt.

වැඩිපුරම භාවිතා වන අංක වර්ගය, Numberබිට් 64 පාවෙන ලක්ෂ්‍ය IEEE 754 අංකයකි.

මෙම වර්ගයේ විශාලතම නිශ්චිත අනුකලනය වන්නේ Number.MAX_SAFE_INTEGER, එනම්:

• 2 ⁵³ -1, හෝ
• +/- 9,007,199,254,740,991, හෝ
• කෝටි නවය ට්‍රිලියන හතළිස් අනූ නවය බිලියන දෙසිය පනස්හතර මිලියන හත්සිය හතළිස් හත්සිය නවසිය අනූ එක

මෙය ඉදිරිදර්ශනය කිරීම සඳහා: බයිට් 1 ක් යනු පෙටබයිට් (හෝ ටෙරාබයිට් දහසක්) ය.

මෙම සන්දර්භය තුළ “ආරක්ෂිත” යන්නෙන් අදහස් කරන්නේ පූර්ණ සංඛ්‍යා හරියටම නිරූපණය කිරීමට සහ ඒවා නිවැරදිව සංසන්දනය කිරීමට ඇති හැකියාවයි.

පිරිවිතරයෙන්:

විශාලත්වය 2 ⁵³ ට නොඉක්මවන සියලු ධනාත්මක හා negative ණ පූර්ණ සංඛ්‍යා Numberවර්ගයෙහි නිරූපණය කළ හැකි බව සලකන්න (ඇත්ත වශයෙන්ම, නිඛිල 0 හි නිරූපණයන් දෙකක් ඇත, +0 සහ -0).

මෙයට වඩා විශාල සංඛ්‍යාවක් පූර්ණ ලෙස ආරක්ෂිතව භාවිතා කිරීම සඳහා, ඔබ භාවිතා කළ යුතුය BigInt, එය ඉහළ සීමාවක් නොමැත.

බිට්වේස් ක්‍රියාකරුවන් සහ මාරුව ක්‍රියාකරුවන් බිටු 32 ක පූර්ණ සංඛ්‍යාවක් මත ක්‍රියාත්මක වන බව සලකන්න, එම අවස්ථාවේ දී උපරිම ආරක්ෂිත නිඛිලය 2 ³¹ -1, හෝ 2,147,483,647 වේ.

const log = console.log
var x = 9007199254740992
var y = -x
log(x == x + 1) // true !
log(y == y - 1) // also true !

// Arithmetic operators work, but bitwise/shifts only operate on int32:
log(x / 2)      // 4503599627370496
log(x >> 1)     // 0
log(x | 1)      // 1

අංක 9,007,199,254,740,992 යන මාතෘකාව පිළිබඳ තාක්ෂණික සටහන: මෙම අගය පිළිබඳ නිශ්චිත IEEE-754 නිරූපණයක් ඇති අතර, ඔබට මෙම අගය විචල්‍යයකින් පැවරීමට සහ කියවීමට හැකිය, එබැවින් පූර්ණ සංඛ්‍යා වසමෙහි ඉතා ප්‍රවේශමෙන් තෝරාගත් යෙදුම් සඳහා අඩු හෝ සමාන මෙම අගය, ඔබට මෙය උපරිම අගයක් ලෙස සැලකිය හැකිය.

පොදුවේ ගත් කල, ඔබ මෙම IEEE-754 අගය නිරවද්‍ය ලෙස සැලකිය යුතුය, මන්ද එය තාර්කික අගය 9,007,199,254,740,992 හෝ 9,007,199,254,740,993 කේතනය කරන්නේද යන්න අපැහැදිලි බැවිනි.

> = ES6:

Number.MIN_SAFE_INTEGER;
Number.MAX_SAFE_INTEGER;

<= ES5

සිට සමුද්දේශ :

Number.MAX_VALUE;
Number.MIN_VALUE;

console.log('MIN_VALUE', Number.MIN_VALUE);
console.log('MAX_VALUE', Number.MAX_VALUE);

console.log('MIN_SAFE_INTEGER', Number.MIN_SAFE_INTEGER); //ES6
console.log('MAX_SAFE_INTEGER', Number.MAX_SAFE_INTEGER); //ES6

එය 2 ⁵³ == 9 007 199 254 740 992. මෙයට හේතුව Numberවන්නේ බිට් 52 මැන්ටිස්සක පාවෙන ලක්ෂ්‍යයක් ලෙස s ගබඩා කර තිබීමයි.

මෙම විනා අගය වේ -2 ⁵³ .

මෙය විනෝදජනක දේවල් සිදු කරයි

Math.pow(2, 53) == Math.pow(2, 53) + 1
>> true

එසේම භයානක විය හැකිය :)

var MAX_INT = Math.pow(2, 53); // 9 007 199 254 740 992
for (var i = MAX_INT; i < MAX_INT + 2; ++i) {
    // infinite loop
}

_{වැඩිදුර කියවීම: http://blog.vjeux.com/2010/javascript/javascript-max_int-number-limits.html}

ජාවාස්ක්‍රිප්ට් හි අංකයක් Infinityඇත.

උදාහරණ:

(Infinity>100)
=> true

// Also worth noting
Infinity - 1 == Infinity
=> true

Math.pow(2,1024) === Infinity
=> true

මෙම මාතෘකාව පිළිබඳ සමහර ප්‍රශ්න සඳහා මෙය ප්‍රමාණවත් විය හැකිය.

ජිමීගේ පිළිතුර නිවැරදි ජාවාස්ක්‍රිප්ට් නිඛිල වර්ණාවලිය -9007199254740992 සිට 9007199254740992 දක්වා ඇතුළත් වේ (සමාවන්න 9007199254740993, ඔබ 9007199254740993 යැයි සිතිය හැකිය, නමුත් ඔබ වැරදියි! පහත හෝ jsfiddle හි නිරූපණය ).

console.log(9007199254740993);

කෙසේ වෙතත්, මෙය ක්‍රමලේඛයෙන් සොයා ගන්නා / සනාථ කරන පිළිතුරක් නොමැත (CoolAJ86 ඔහුගේ පිළිතුරෙහි සඳහන් කර ඇති පිළිතුර වසර 28.56 කින් අවසන් වනු ඇත;), එබැවින් එය කිරීමට තරමක් කාර්යක්ෂම ක්‍රමයක් මෙන්න (නිවැරදිව කිවහොත් එය වඩාත් කාර්යක්ෂම වේ අවුරුදු 28.559999999968312 පමණ වන විට :), පරීක්ෂණ ප්‍රබන්ධයක් සමඟ :

/**
 * Checks if adding/subtracting one to/from a number yields the correct result.
 *
 * @param number The number to test
 * @return true if you can add/subtract 1, false otherwise.
 */
var canAddSubtractOneFromNumber = function(number) {
    var numMinusOne = number - 1;
    var numPlusOne = number + 1;
    
    return ((number - numMinusOne) === 1) && ((number - numPlusOne) === -1);
}

//Find the highest number
var highestNumber = 3; //Start with an integer 1 or higher

//Get a number higher than the valid integer range
while (canAddSubtractOneFromNumber(highestNumber)) {
    highestNumber *= 2;
}

//Find the lowest number you can't add/subtract 1 from
var numToSubtract = highestNumber / 4;
while (numToSubtract >= 1) {
    while (!canAddSubtractOneFromNumber(highestNumber - numToSubtract)) {
        highestNumber = highestNumber - numToSubtract;
    }
    
    numToSubtract /= 2;
}        

//And there was much rejoicing.  Yay.    
console.log('HighestNumber = ' + highestNumber);

ආරක්ෂිත වීමට

var MAX_INT = 4294967295;

තර්කනය

මම හිතුවා මම දක්ෂයි කියලා x + 1 === x වඩාත් ප්‍රායෝගික ප්‍රවේශයකින් .

මගේ යන්ත්‍රයට ගණනය කළ හැක්කේ තත්පරයට මිලියන 10 ක් හෝ ඊට වැඩි ගණනකි ... එබැවින් මම වසර 28.56 කින් නිශ්චිත පිළිතුරක් සමඟ නැවත තැපැල් කරමි.

ඔබට එතරම් කාලයක් බලා සිටීමට නොහැකි නම්, මම එය ඔට්ටු ඇල්ලීමට කැමැත්තෙමි

• ඔබගේ ලූප බොහොමයක් අවුරුදු 28.56 ක් පුරා ක්‍රියාත්මක නොවේ
• 9007199254740992 === Math.pow(2, 53) + 1 ප්‍රමාණවත් සාක්ෂි
• ඔබ ඇලුම් කළ යුතු 4294967295වන Math.pow(2,32) - 1වැලැක්විමට කිරීමට ටිකක්-රැගෙන යාමත් සමගිනි ප්රශ්න බලාපොරොත්තු වූ පරිදි

සොයා ගැනීම x + 1 === x:

(function () {
  "use strict";

  var x = 0
    , start = new Date().valueOf()
    ;

  while (x + 1 != x) {
    if (!(x % 10000000)) {
      console.log(x);
    }

    x += 1
  }

  console.log(x, new Date().valueOf() - start);
}());

කෙටි පිළිතුර “එය රඳා පවතී.”

ඔබ ඕනෑම තැනක බිට්වේස් ක්‍රියාකරුවන් භාවිතා කරන්නේ නම් (හෝ ඔබ අරාවෙහි දිග ගැන සඳහන් කරන්නේ නම්), පරාසයන්:

අත්සන් නොකළ: 0…(-1>>>0)

අත්සන් කළේ: (-(-1>>>1)-1)…(-1>>>1)

(එය එසේ වන්නේ බිට්වේස් ක්‍රියාකරුවන් සහ අරාවෙහි උපරිම දිග බිටු 32 ට පූර්ණ සංඛ්‍යාවක් ලෙස සීමා කරමිනි.)

ඔබ බිට්වේස් ක්‍රියාකරුවන් භාවිතා නොකරන්නේ නම් හෝ අරාව දිග සමඟ වැඩ කරන්නේ නම්:

අත්සන් කළේ: (-Math.pow(2,53))…(+Math.pow(2,53))

සාමාන්‍යයෙන් IEEE 754 ද්විත්ව නිරවද්‍යතාවයෙන් යුත් පාවෙන ලක්ෂ්‍ය නිරූපණයට අනුරූප වන “අංකය” වර්ගයේ අභ්‍යන්තර නිරූපණය මගින් මෙම සීමාවන් පනවනු ලැබේ. (සාමාන්‍ය අත්සන් කළ නිඛිල සංඛ්‍යාවක් මෙන් නොව, negative ණාත්මක සීමාවේ විශාලත්වය ධනාත්මක සීමාවේ විශාලත්වයට සමාන වන අතර අභ්‍යන්තර නිරූපණයේ ලක්ෂණ නිසා ඇත්ත වශයෙන්ම negative ණ 0 ක් ඇතුළත් වේ !)

ECMAScript 6:

Number.MAX_SAFE_INTEGER = Math.pow(2, 53)-1;
Number.MIN_SAFE_INTEGER = -Number.MAX_SAFE_INTEGER;

9 007 199 254 740 991 උපරිම සහ ආරක්ෂිත පූර්ණ සංඛ්‍යාවක් බව තහවුරු කර ගැනීමේ ප්‍රති result trueල මීට පෙර බොහෝ පිළිතුරු මගින් පෙන්වා දී ඇත.9007199254740992 === 9007199254740992 + 1

අපි දිගටම සමුච්චය කරන්නේ නම්:

input: 9007199254740992 + 1  output: 9007199254740992  // expected: 9007199254740993
input: 9007199254740992 + 2  output: 9007199254740994  // expected: 9007199254740994
input: 9007199254740992 + 3  output: 9007199254740996  // expected: 9007199254740995
input: 9007199254740992 + 4  output: 9007199254740996  // expected: 9007199254740996

9 007 199 254 740 992 ට වඩා වැඩි සංඛ්‍යාවක් අතරින් නිරූපණය කළ හැක්කේ සංඛ්‍යා පමණක් බව අපට සොයාගත හැකිය .

ද්වි-නිරවද්‍යතාව 64-බිට් ද්විමය ආකෘතිය මේ සඳහා ක්‍රියා කරන්නේ කෙසේද යන්න පැහැදිලි කිරීමට එය පිවිසුමකි . 9 007 199 254 740 992 ආකාරය බලමුමෙම ද්විමය ආකෘතිය භාවිතා කරමින් රඳවා තබා .

4 503 599 627 370 496 සිට එය නිරූපණය කිරීමට කෙටි අනුවාදයක් භාවිතා කිරීම :

  1 . 0000 ---- 0000  *  2^52            =>  1  0000 ---- 0000.  
     |-- 52 bits --|    |exponent part|        |-- 52 bits --|

ඊතලයේ වම්පස, අපට බිට් අගය 1 ක් ද , යාබද රේඩික්ස් ලක්ෂ්‍යයක් ද ඇත , පසුව ගුණ කිරීමෙන් 2^52, අපි රැඩික්ස් ලක්ෂ්‍යය පියවර 52 ක් දකුණට ගෙන යන අතර එය අවසානය දක්වා ගමන් කරයි. දැන් අපට ද්විමය වශයෙන් 4503599627370496 ලැබේ.

දැන් අපි සියලු බිටු 1 ට සකසන තුරු මෙම අගයට 1 ක් රැස් කිරීමට පටන් ගනිමු, එය දශමයෙන් 9 007 199 254 740 991 ට සමාන වේ .

  1 . 0000 ---- 0000  *  2^52  =>  1  0000 ---- 0000.  
                       (+1)
  1 . 0000 ---- 0001  *  2^52  =>  1  0000 ---- 0001.  
                       (+1)
  1 . 0000 ---- 0010  *  2^52  =>  1  0000 ---- 0010.  
                       (+1)
                        . 
                        .
                        .
  1 . 1111 ---- 1111  *  2^52  =>  1  1111 ---- 1111. 

දැන්, ද්වි-නිරවද්‍යතාව 64-බිට් ද්විමය ආකෘතියෙන් , එය භාග සඳහා බිටු 52 ක් තදින් ලබා දී ඇති නිසා, තවත් 1 ක් එකතු කිරීම සඳහා තවත් බිට් ලබා ගත නොහැක, එබැවින් අපට කළ හැක්කේ සියලු බිටු නැවත 0 ට සැකසීම සහ, on ාතීය කොටස හැසිරවීම:

  |--> This bit is implicit and persistent.
  |        
  1 . 1111 ---- 1111  *  2^52      =>  1  1111 ---- 1111. 
     |-- 52 bits --|                     |-- 52 bits --|

                          (+1)
                                     (radix point has no way to go)
  1 . 0000 ---- 0000  *  2^52 * 2  =>  1  0000 ---- 0000. * 2  
     |-- 52 bits --|                     |-- 52 bits --|

  =>  1 . 0000 ---- 0000  *  2^53 
         |-- 52 bits --| 

දැන් අපට ලැබෙන්නේ 9 007 199 254 740 992 වන අතර , ඊට වඩා වැඩි සංඛ්‍යාවක් සමඟ, ආකෘතියට රඳවා ගත හැකි දෙය භාගයේ 2 ගුණයක් වේ , එයින් අදහස් වන්නේ දැන් භාගයේ සෑම 1 එකතු කිරීමක්ම සැබවින්ම 2 එකතු කිරීමකට සමාන වේ, ඒ නිසා දෙගුණයක් -Precision 64-bit ද්විමය ආකෘතියට 9 007 199 254 740 992 ට වඩා වැඩි වූ විට අමුතු සංඛ්‍යා රඳවා තබා ගත නොහැක :

                            (consume 2^52 to move radix point to the end)
  1 . 0000 ---- 0001  *  2^53  =>  1  0000 ---- 0001.  *  2
     |-- 52 bits --|                 |-- 52 bits --|

එබැවින් එම සංඛ්‍යාව 9 007 199 254 740 992 * 2 = 18 014 398 509 481 984 ට වඩා වැඩි වූ විට, භාගයේ 4 ගුණයක් පමණක් රඳවා ගත හැකිය:

input: 18014398509481984 + 1  output: 18014398509481984  // expected: 18014398509481985
input: 18014398509481984 + 2  output: 18014398509481984  // expected: 18014398509481986
input: 18014398509481984 + 3  output: 18014398509481984  // expected: 18014398509481987
input: 18014398509481984 + 4  output: 18014398509481988  // expected: 18014398509481988

[ 2 251 799 813 685 248 , 4 503 599 627 370 496 ) අතර සංඛ්‍යාව කෙසේද?

 1 . 0000 ---- 0001  *  2^51  =>  1 0000 ---- 000.1
     |-- 52 bits --|                |-- 52 bits  --|

රේඩික්ස් ලක්ෂ්‍යයෙන් පසු බිට් අගය 1 හරියටම 2 ^ -1 වේ. (= 1/2, = 0.5) එබැවින් 4 503 599 627 370 496 (2 ^ 52) ට වඩා අඩු සංඛ්‍යාවක් ඇති විට, නිඛිලයේ 1/2 ගුණයක් නිරූපණය කිරීමට එක් බිට් එකක් තිබේ :

input: 4503599627370495.5   output: 4503599627370495.5  
input: 4503599627370495.75  output: 4503599627370495.5  
            

වඩා අඩු 2 251 799 813 685 248 (2 ^ 51)

input: 2251799813685246.75   output: 2251799813685246.8  // expected: 2251799813685246.75 
input: 2251799813685246.25   output: 2251799813685246.2  // expected: 2251799813685246.25 
input: 2251799813685246.5    output: 2251799813685246.5
                
// If the digits exceed 17, JavaScript round it to print it.
//, but the value is held correctly:

input: 2251799813685246.25.toString(2) 
output: "111111111111111111111111111111111111111111111111110.01"
input: 2251799813685246.75.toString(2) 
output: "111111111111111111111111111111111111111111111111110.11"
input: 2251799813685246.78.toString(2)   
output: "111111111111111111111111111111111111111111111111110.11"

On ාතීය කොටසෙහි පවතින පරාසය කුමක්ද? ආකෘතිය ඒ සඳහා බිටු 11 ක් වෙන් කරයි. විකී වෙතින් සම්පූර්ණ ආකෘතිය : (වැඩි විස්තර සඳහා කරුණාකර එහි යන්න)

එබැවින් on ාතීය කොටස 2 ^ 52 බවට පත් කිරීම සඳහා, අපට හරියටම e = 1075 සැකසිය යුතුය.

අනෙක් අය දැනටමත් සාමාන්‍ය පිළිතුර ලබා දී ඇති නමුත් එය තීරණය කිරීම සඳහා වේගවත් ක්‍රමයක් ලබා දීම හොඳ අදහසක් වනු ඇතැයි මම සිතුවෙමි:

for (var x = 2; x + 1 !== x; x *= 2);
console.log(x);

එය මට ක්‍රෝම් 30 හි මිලි තත්පරයකට අඩු 9007199254740992 ලබා දෙයි.

1 එකතු කළ විට, තමාට සමාන වන්නේ කුමක්දැයි සොයා ගැනීමට එය 2 හි බලයන් පරීක්ෂා කරනු ඇත.

බිට්වේස් මෙහෙයුම් සඳහා ඔබට භාවිතා කිරීමට අවශ්‍ය ඕනෑම දෙයක් 0x80000000 (-2147483648 හෝ -2 ^ 31) සහ 0x7fffffff (2147483647 හෝ 2 ^ 31 - 1) අතර විය යුතුය.

0x80000000 +2147483648 ට සමාන බව කොන්සෝලය ඔබට කියනු ඇත, නමුත් 0x80000000 සහ 0x80000000 සමාන -2147483648.

උත්සාහ කරන්න:

maxInt = -1 >>> 1

ෆයර්ෆොක්ස් 3.6 හි එය 2 ^ 31 - 1 වේ.

ලිවීමේ මොහොතේදී, ජාවාස්ක්‍රිප්ටයට නව දත්ත වර්ගයක් ලැබේ : BigInt. එය එක්මාස්ක්‍රිප්ට් 2020 ට ඇතුළත් කිරීම සඳහා 4 වන අදියරේදී TC39 යෝජනාවකි . BigIntChrome 67+, FireFox 68+, Opera 54 සහ Node 10.4.0 වලින් ලබා ගත හැකිය. එය සෆාරි හි සිදු වෙමින් පවතී, සහ වෙනත් ... එය "n" උපසර්ගයක් ඇති සංඛ්‍යාත්මක සාහිත්‍යකරුවන් හඳුන්වා දෙන අතර අත්තනෝමතික නිරවද්‍යතාවයකට ඉඩ දෙයි:

var a = 123456789012345678901012345678901n;

ඇත්ත වශයෙන්ම, එවැනි සංඛ්‍යාවක් සංඛ්‍යා දත්ත වර්ගයකට බල කරන විට (සමහර විට නොදැනුවත්ව) නිරවද්‍යතාවය තවමත් නැති වී යනු ඇත.

තවද, පැහැදිලිවම, සෑම විටම සීමිත මතකය හේතුවෙන් නිරවද්‍ය සීමාවන් ඇති අතර, අවශ්‍ය මතකය වෙන් කිරීම සහ එවැනි විශාල සංඛ්‍යාවක් සඳහා ගණිතය සිදු කිරීම සඳහා කාලය අනුව පිරිවැයක් දැරීමට සිදුවේ.

නිදසුනක් ලෙස, දශම සංඛ්‍යා ලක්ෂයක් සහිත සංඛ්‍යාවක් උත්පාදනය කිරීම, සම්පූර්ණ කිරීමට පෙර සැලකිය යුතු ප්‍රමාදයක් ගනු ඇත:

console.log(BigInt("1".padEnd(100000,"0")) + 1n)

... නමුත් එය ක්‍රියාත්මක වේ.

මම සූත්‍රයක් සමඟ සරල පරීක්ෂණයක් කළෙමි, X- (X + 1) = - 1, සහ XI හි විශාලතම අගය සෆාරි, ඔපෙරා සහ ෆයර්ෆොක්ස් (OS X මත පරීක්ෂා කර ඇත) මත වැඩ කිරීමට ලබා ගත හැකිය 9e15. පරීක්ෂා කිරීම සඳහා මා භාවිතා කළ කේතය මෙන්න:

javascript: alert(9e15-(9e15+1));

මම එය මෙසේ ලියමි:

var max_int = 0x20000000000000;
var min_int = -0x20000000000000;
(max_int + 1) === 0x20000000000000;  //true
(max_int - 1) < 0x20000000000000;    //true

Int32 සඳහා සමාන වේ

var max_int32 =  0x80000000;
var min_int32 = -0x80000000;

අපි මූලාශ්‍ර වෙත යමු

විස්තර

මෙම MAX_SAFE_INTEGERනියත වටිනාකමක් ඇති 9007199254740991(9,007,199,254,740,991 හෝ ~ 9 ක්වොඩ්රිලියනය). එම අංකයට හේතුව වන්නේ ජාවාස්ක්‍රිප්ට් IEEE 754 හි නිශ්චිතව දක්වා ඇති පරිදි ද්විත්ව නිරවද්‍යතාවයකින් යුත් පාවෙන ලක්ෂ්‍ය ආකෘති අංක භාවිතා කරන අතර ආරක්ෂිතව නිරූපණය කළ හැක්කේ සහ අතර සංඛ්‍යා පමණි .-(2^53 - 1)2^53 - 1

මෙම සන්දර්භය තුළ ආරක්ෂිත යන්නෙන් අදහස් කරන්නේ පූර්ණ සංඛ්‍යා හරියටම නිරූපණය කිරීමට සහ ඒවා නිවැරදිව සංසන්දනය කිරීමට ඇති හැකියාවයි. උදාහරණයක් ලෙස, Number.MAX_SAFE_INTEGER + 1 === Number.MAX_SAFE_INTEGER + 2සත්‍ය ලෙස ඇගයීමට ලක් කරනු ඇත, එය ගණිතමය වශයෙන් වැරදිය. වැඩි විස්තර සඳහා Number.isSafeInteger () බලන්න .

නිසා MAX_SAFE_INTEGERස්ථිතික දේපළක් අංකය , ඔබ හැම විටම ලෙස එය භාවිතා Number.MAX_SAFE_INTEGER, එය ක දේපල ලෙස වඩා අංකය ඔබ විසින් නිර්මාණය වස්තුව.

බ්‍රව්සර් අනුකූලතාව

ගූගල් ක්‍රෝම් තුළ ඇති ජාවාස්ක්‍රිප්ට් තුළ, අංකය අනන්තය ලෙස හැඳින්වීමට පෙර ඔබට ආසන්න වශයෙන් 2 ^ 1024 වෙත යා හැකිය.

ජාවාස්ක්‍රිප්ට් හි සංඛ්‍යා නිරූපණය වේ 2^53 - 1.

කෙසේ වෙතත් , Bitwise operationගණනය කරනු ලබන්නේ 32 bits ( 4 bytes ), ඔබ බිටු 32 මාරුව ඉක්මවා ගියහොත් ඔබ බිටු ලිහිල් කිරීමට පටන් ගනී.

Scato wrotes:

බිට්වේස් මෙහෙයුම් සඳහා ඔබට භාවිතා කිරීමට අවශ්‍ය ඕනෑම දෙයක් 0x80000000 (-2147483648 හෝ -2 ^ 31) සහ 0x7fffffff (2147483647 හෝ 2 ^ 31 - 1) අතර විය යුතුය.

0x80000000 +2147483648 ට සමාන බව කොන්සෝලය ඔබට කියනු ඇත, නමුත් 0x80000000 සහ 0x80000000 සමාන -2147483648

හෙක්ස්-දශම යනු අත්සන් නොකළ ධනාත්මක අගයන් බැවින් 0x80000000 = 2147483648 - එය ගණිතමය වශයෙන් නිවැරදි ය. ඔබට එය අත්සන් කළ අගයක් බවට පත් කිරීමට අවශ්‍ය නම් ඔබට මාරුවිය යුතුය: 0x80000000 >> 0 = -2147483648. ඒ වෙනුවට ඔබට 1 << 31 ද ලිවිය හැකිය.

ෆයර්ෆොක්ස් 3 විශාල සංඛ්‍යා සමඟ ගැටළුවක් ඇති බවක් නොපෙනේ.

1e + 200 * 1e + 100 දඩය 1e + 300 දක්වා ගණනය කරනු ඇත.

සෆාරි සමඟ ද එහි කිසිදු ගැටළුවක් නොමැති බව පෙනේ. (වාර්තාව සඳහා, මෙය වෙනත් අයෙකු විසින් පරීක්ෂා කිරීමට තීරණය කළහොත් මෙය මැක්හි ඇත.)

දවසේ මේ වේලාවේදී මගේ මොළය නැතිවුනේ නැත්නම්, මෙය බිට් 64 ක පූර්ණ සංඛ්‍යාවකට වඩා විශාලය.

Node.js සහ ගූගල් ක්‍රෝම් යන දෙකම බිට් 1024 පාවෙන ලක්ෂ්‍ය අගයන් භාවිතා කරන බව පෙනේ:

Number.MAX_VALUE = 1.7976931348623157e+308