Bu dil tarafından tanımlanmış mı? Tanımlanmış bir maksimum var mı? Farklı tarayıcılarda farklı mı?

JavaScript'in iki sayı türü vardır: Numberve BigInt.

En sık kullanılan sayı türü, Number64 bit kayan noktalı IEEE 754 sayıdır.

Bu türün en büyük tam integral değeri Number.MAX_SAFE_INTEGERşöyledir:

• 2 ⁵³ -1 veya
• +/- 9.007.199.254.740.991 veya
• dokuz katrilyon yedi trilyon yüz doksan dokuz milyar iki yüz elli dört milyon yedi yüz kırk bin dokuz yüz doksan bir

Bunu perspektife sokmak gerekirse: bir katrilyon bayt bir petabayt (veya bin terabayt).

Bu bağlamda "güvenli" tamsayıları tam olarak temsil etme ve doğru şekilde karşılaştırma yeteneğini ifade eder.

Spec'ten:

Büyüklüğü 2 ^53'ten büyük olmayan tüm pozitif ve negatif tamsayıların Numbertipte temsil edilebilir olduğuna dikkat edin (aslında, 0 tamsayısının +0 ve -0 olmak üzere iki gösterimi vardır).

Bundan daha büyük tamsayıları güvenle kullanmak için BigInt, üst sınırı olmayan kullanmanız gerekir .

Bitsel işleçlerin ve kaydırma işleçlerinin 32 bit tamsayılarda çalıştığına dikkat edin, bu durumda, maksimum güvenli tamsayı 2 ³¹ -1 veya 2.147.483.647'dir.

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 numarasının konusuyla ilgili teknik not: Bu değerin tam bir IEEE-754 temsili vardır ve bu değeri bir değişkenden atayabilir ve okuyabilirsiniz, böylece tamsayılardan küçük veya eşit olan tamsayılar alanında çok dikkatli bir şekilde seçilen uygulamalar için bu değer, bunu maksimum değer olarak değerlendirebilirsiniz.

Genel durumda, bu IEEE-754 değerini yanlış olarak değerlendirmelisiniz, çünkü mantıksal değeri 9,007,199,254,740,992 veya 9,007,199,254,740,993 kodlayıp kodlamadığı belirsizdir.

> = ES6:

Number.MIN_SAFE_INTEGER;
Number.MAX_SAFE_INTEGER;

<= ES5

Gönderen referans :

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'dir. Bunun nedeni Number, 52 bitlik bir mantiste s'nin kayan nokta olarak depolanmasıdır.

Min değeri -2 ^53'tür .

Bu eğlenceli şeyler oluyor

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

Ayrıca tehlikeli olabilir :)

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
}

_{Daha fazla okuma: http://blog.vjeux.com/2010/javascript/javascript-max_int-number-limits.html}

JavaScript'te adlı bir sayı var Infinity.

Örnekler:

(Infinity>100)
=> true

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

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

Bu konuyla ilgili bazı sorular için yeterli olabilir.

Jimmy'nin cevabı doğru olarak sürekli JavaScript tamsayı spektrumunu temsil -9007199254740992 için 9007199254740992 dahil (9007199254740993 üzgün, düşündüğünüzden sen 9007199254740993 vardır, ama yanlış! Şunlardır altında veya içinde Gösteri jsfiddle ).

console.log(9007199254740993);

Ancak buluntular / programlama (diğer ima biri CoolAJ86 daha bu kanıtlıyor cevabı yok onun cevabını 28.56 yıl içinde bitirmek istiyorum;), işte bunun için biraz daha etkili yoludur (kesin konuşmak gerekirse, daha verimlidir yaklaşık 28.559999999968312 yıl :), bir test kemanı ile birlikte :

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

Güvende olmak

var MAX_INT = 4294967295;

muhakeme

Zeki olacağımı ve x + 1 === xdaha pragmatik bir yaklaşımla değeri bulacağımı düşündüm .

Makinem saniyede sadece 10 milyon sayabilir ... bu yüzden 28.56 yıl içinde kesin cevapla geri göndereceğim.

Eğer bu kadar bekleyemezsen, bahse girmeye hazırım

• Döngülerinizin çoğu 28.56 yıldır
• 9007199254740992 === Math.pow(2, 53) + 1 yeterince kanıt
• Bit kaydırma ile ilgili beklenen sorunları önlemek için 4294967295hangisine bağlı kalmalısınızMath.pow(2,32) - 1

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

Kısa cevap “duruma bağlıdır”.

Herhangi bir yerde bitsel operatörler kullanıyorsanız (veya bir Dizinin uzunluğundan bahsediyorsanız) aralıklar şunlardır:

İmzasız: 0…(-1>>>0)

İmza: (-(-1>>>1)-1)…(-1>>>1)

(Böylece, bitsel operatörler ve bir dizinin maksimum uzunluğu 32 bit tamsayılarla sınırlıdır.)

Bitsel işleçler kullanmıyorsanız veya dizi uzunluklarıyla çalışmıyorsanız:

İmza: (-Math.pow(2,53))…(+Math.pow(2,53))

Bu sınırlamalar, genellikle IEEE 754 çift kesinlikli kayar nokta gösterimine karşılık gelen “Sayı” tipinin iç temsili tarafından uygulanır. (Tipik imzalı tam sayıların aksine, negatif sınırın büyüklüğünün, aslında negatif 0 içeren dahili gösterimin özellikleri nedeniyle, pozitif sınırın büyüklüğü ile aynı olduğunu unutmayın .)

ECMAScript 6:

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

Önceki zamanlardan daha fazla cevaplar sonucunu göstermiştir trueait 9007199254740992 === 9007199254740992 + 1olduğunu doğrulamak için 9 007 199 254 740 991 maksimum ve güvenli tam sayıdır.

Ya biriktirmeye devam edersek:

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

9007 199 254 740 992'den büyük sayılar arasında sadece çift sayıların temsil edilebildiğini görebiliriz .

Bu, çift ​​duyarlıklı 64 bit ikili formatın bu konuda nasıl çalıştığını açıklayan bir giriş . Şimdi bu ikili formatı kullanarak 9 007 199 254 740 992'nin nasıl tutulduğunu (temsil edildiğini) görelim .

4 503 599 627 370 496'dan göstermek için kısa bir sürüm kullanma :

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

Okun sol tarafında, bit değeri 1 ve bitişik bir yarıçap noktası var , daha sonra çarparak 2^52, yarıçap noktasını 52 adım sağa hareket ettiriyoruz ve sonuna kadar gidiyor. Şimdi ikilide 4503599627370496 alıyoruz.

Şimdi, tüm bitler 1 olarak ayarlanana kadar 1'i bu değerde biriktirmeye başlıyoruz, bu da ondalık ondalık 9 007 199 254 740 991'e eşittir .

  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. 

Şimdi, çift ​​duyarlıklı 64 bit ikili formatta , kesinlikle kesir için 52 bit ayırdığı için, bir tane daha 1 eklemek için daha fazla bit mevcut değildir, bu yüzden yapabileceğimiz tüm bitleri 0'a geri döndürmek ve üs kısmını manipüle etmek:

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

Şimdi 9 007 199 254 740 992'yi alıyoruz ve sayıdan daha büyük bir sayı ile formatın tutabileceği kesirin 2 katı, şimdi kesir kısmındaki her 1 ekleme aslında 2 toplama anlamına geliyor, bu yüzden çift 6400 bit ikili biçim , sayı 9 007 199254 740 992'den büyük olduğunda tek sayıları tutamaz :

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

Bu nedenle sayı 9007 199 254 740 992 * 2 = 18 014 398 509 481 984'den büyük olduğunda, kesirin sadece 4 katı tutulabilir:

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 251799813685248 , 4 503 599 627 370 496 ) arasındaki sayıya ne dersiniz ?

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

Yarıçap noktasından sonraki bit değeri 1 tam olarak 2 ^ -1'dir. (= 1/2 , = 0,5) Dolayısıyla, 4 503 599 627 370 496'dan (2 ^ 52) küçük bir sayı olduğunda, tamsayının 1/2 katını temsil etmek için bir bit vardır :

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

Az 2 251 799 813 685 248 (^ 51 2)

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"

Ve mevcut üs parçası aralığı nedir? biçim bunun için 11 bit ayırır. Komple biçimi Wiki : (daha fazla detay oraya gitmek için lütfen)

Bu nedenle üs parçasını 2 ^ 52 yapmak için tam olarak e = 1075 ayarlamamız gerekiyor.

Diğerleri zaten genel bir cevap vermiş olabilir, ancak bunu belirlemenin hızlı bir yolunu vermenin iyi bir fikir olacağını düşündüm:

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

Bu da bana Chrome 30'da bir milisaniyeden daha kısa sürede 9007199254740992 veriyor.

'1' eklendiğinde kendisine hangisinin eşit olduğunu bulmak için 2'nin gücünü test edecektir.

Bitsel işlemler için kullanmak istediğiniz her şey 0x80000000 (-2147483648 veya -2 ^ 31) ile 0x7fffffff (2147483647 veya 2 ^ 31-1) arasında olmalıdır.

Konsol, 0x80000000'in +2147483648'e eşit olduğunu, ancak 0x80000000 ve 0x80000000'in -2147483648'e eşit olduğunu söyleyecektir.

Deneyin:

maxInt = -1 >>> 1

Firefox 3.6'da 2 ^ 31-1'dir.

Yazım anında JavaScript yeni bir veri türü alıyor: BigInt. EcmaScript 2020'ye dahil edilmesi aşama 4'teki bir TC39 önerisidir . Chrome 67+, FireFox 68+, Opera 54 ve Düğüm 10.4.0'da mevcuttur. Safari, et al ... Devam ediyor "n" sonekine sahip sayısal değişmezleri tanıtır ve keyfi hassasiyet sağlar:BigInt

var a = 123456789012345678901012345678901n;

Elbette, böyle bir sayı bir sayı veri türüne zorlandığında (belki de kasıtsız) kesinlik hala kaybolacaktır.

Ve açıkçası, sonlu bellek nedeniyle her zaman hassas sınırlamalar ve gerekli belleği tahsis etmek ve bu kadar büyük sayılar üzerinde aritmetik yapmak için zaman açısından bir maliyet olacaktır.

Örneğin, yüz bin ondalık basamağı olan bir sayının oluşturulması, tamamlanmadan önce belirgin bir gecikme alacaktır:

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

... ama işe yarıyor.

Bir formülle basit bir test yaptım, X- (X + 1) = - 1 ve XI'nin Safari, Opera ve Firefox (OS X'te test edilmiş) üzerinde çalışabileceği en büyük değer 9e15. İşte test için kullandığım kod:

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

Ben şöyle yazıyorum:

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

Aynı int32 için

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

Kaynaklara gidelim

Açıklama

MAX_SAFE_INTEGERSabit bir değere sahiptir 9007199254740991(9,007,199,254,740,991 veya ~ 9 katrilyon). Bu sayının arkasındaki mantık JavaScript kullanmasıdır çift duyarlı kayan noktalı format numaralarını belirtilen IEEE 754 ve ancak güvenle arasındaki sayıları temsil edebilir -(2^53 - 1)ve 2^53 - 1.

Bu bağlamda güvenli, tam sayıları tam olarak temsil etme ve doğru bir şekilde karşılaştırma yeteneğini ifade eder. Örneğin Number.MAX_SAFE_INTEGER + 1 === Number.MAX_SAFE_INTEGER + 2, matematiksel olarak yanlış olan doğru olarak değerlendirilir. Daha fazla bilgi için Number.isSafeInteger () öğesine bakın .

Çünkü MAX_SAFE_INTEGERstatik özelliği olan Number , her zaman olarak kullanabilirsiniz Number.MAX_SAFE_INTEGER, yerine bir özelliği olarak Numarası oluşturduğunuz nesne.

Tarayıcı Uyumluluğu

Google Chrome yerleşik javascript'te, numara sonsuz olarak adlandırılmadan önce yaklaşık 2 ^ 1024'e gidebilirsiniz.

JavaScript'te sayıların temsili 2^53 - 1.

Ancak , Bitwise operationhesaplanır 32 bits ( 4 bytes ), yani 32 bitlik kaydırmaları aşarsanız bitleri kaybedersiniz.

Scato wrotes:

bitsel işlemler için kullanmak istediğiniz her şey 0x80000000 (-2147483648 veya -2 ^ 31) ile 0x7fffffff (2147483647 veya 2 ^ 31-1) arasında olmalıdır.

konsol size 0x80000000 değerinin +2147483648 değerine, ancak 0x80000000 & 0x80000000 değerinin -2147483648 değerine eşit olduğunu söyleyecektir.

Onaltılı Ondalık işaretsiz pozitif değerlerdir, bu nedenle 0x80000000 = 2147483648 - bu matematiksel olarak doğrudur. İşaretli bir değer yapmak istiyorsanız sağa kaydırmanız gerekir: 0x80000000 >> 0 = -2147483648. Bunun yerine 1 << 31 de yazabilirsiniz.

Firefox 3'ün büyük sayılarla bir sorunu yok gibi görünüyor.

1e + 200 * 1e + 100, 1e + 300'e kadar ince hesaplar.

Safari de onunla hiçbir sorun var gibi görünüyor. (Kayıt için, başka biri bunu test etmeye karar verirse bu bir Mac'te.)

Günün bu saatinde beynimi kaybetmediğim sürece, bu 64 bitlik bir tam sayıdan çok daha büyük.

Node.js ve Google Chrome'un her ikisi de 1024 bit kayan nokta değerleri kullanıyor gibi görünüyor:

Number.MAX_VALUE = 1.7976931348623157e+308