Qual é o valor inteiro mais alto do JavaScript que um número pode acessar sem perder a precisão?

951

Isso é definido pelo idioma? Existe um máximo definido? É diferente em navegadores diferentes?

TALlama
fonte
5
Você não precisa depender de limites de JS com bibliotecas como github.com/MikeMcl/big.js , ver, por exemplo aqui para os seus testes de confiabilidade
Dmitri Zaitsev
2
qual é o valor inteiro mais alto que você pode usar com big.js?
George
@George Aqui está a API do big.js: mikemcl.github.io/big.js/#dp
simhumileco
A questão não faz sentido. O que significa que um número "vai para" um valor inteiro? Se você deseja apenas perguntar qual é o número inteiro mais alto que você pode representar em JS, o próprio número mais alto (finito) é um número inteiro.
Veky
@DmitriZaitsev Não precisamos mais depender de bibliotecas externas (pelo menos em alguns navegadores). 1n << 10000né um número inteiro realmente grande, sem perder precisão, sem exigir dependências (e nem é preciso dizer, nem mesmo perto de um limite).
Amadan 6/01

Respostas:

868

JavaScript tem dois tipos de números: Numbere BigInt.

O tipo de número usado com mais frequência,, Numberé um número IEEE 754 de ponto flutuante de 64 bits .

O maior valor integral exato desse tipo Number.MAX_SAFE_INTEGERé:

  • 2 53 -1, ou
  • +/- 9.007.199.254.740.991, ou
  • nove quadrilhões sete trilhões cento e noventa e nove bilhões duzentos e cinquenta e quatro milhões setecentos e quarenta mil novecentos e noventa e um

Para colocar isso em perspectiva: um quatrilhão de bytes é um petabyte (ou mil terabytes).

"Seguro" neste contexto refere-se à capacidade de representar números inteiros exatamente e compará-los corretamente.

Das especificações:

Observe que todos os números inteiros positivos e negativos cuja magnitude não é maior que 2 53 são representáveis ​​no Numbertipo (de fato, o número 0 tem duas representações, +0 e -0).

Para usar com segurança números inteiros maiores que isso, você precisa usar BigInt, que não tem limite superior.

Observe que os operadores bit a bit e shift operam em números inteiros de 32 bits; portanto, nesse caso, o número máximo máximo de segurança é 2 31 -1 ou 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


Nota técnica sobre o assunto do número 9.007.199.254.740.992: Há uma representação exata do IEEE-754 desse valor, e você pode atribuir e ler esse valor de uma variável, portanto, com muito cuidado aplicativos escolhidos no domínio de números inteiros menores ou iguais a esse valor, você pode tratar isso como um valor máximo.

No caso geral, você deve tratar esse valor IEEE-754 como inexato, porque é ambíguo se ele está codificando o valor lógico 9.007.199.254.740.992 ou 9.007.199.254.740.993.

Jimmy
fonte
75
Isso parece certo, mas existe algum lugar em que isso é definido, como MAX_INT de C ou Integer de Java.MAX_VALUE?
TALlama
48
4294967295 === Math.pow(2,32) - 1;
precisa saber é o seguinte
13
Então, qual é o menor e o maior número inteiro que podemos usar para garantir a precisão exata?
Pacerier 15/10
38
Talvez valha a pena notar que não há (int) real em javascript. Toda instância de Number é (float) ou NaN.
Beterraba-Beterraba
53
9007199254740992 não é realmente o valor máximo, o último bit aqui já é assumido como zero e, portanto, você perdeu 1 bit de precisão. O número segura real é 9007199254740991 (Number.MAX_SAFE_INTEGER)
Willem D'Haeseleer
461

> = ES6:

Number.MIN_SAFE_INTEGER;
Number.MAX_SAFE_INTEGER;

<= ES5

A partir da referência :

Number.MAX_VALUE;
Number.MIN_VALUE;

Peter Bailey
fonte
23
Editei a pergunta para ser um pouco mais precisa quanto a querer os valores máximos de Inteiro, não apenas o valor máximo de Número. Desculpe pela confusão, aqui.
TALlama
5
O resultado retornado é garantido como igual em todos os navegadores?
Pacerier 21/09
7
Observe que Number.MIN_VALUEé o menor número positivo possível . O menor valor (ou seja, menor que qualquer outra coisa) é provavelmente -Number.MAX_VALUE.
Michael Scheper
34
O ES6 apresenta Number.MIN_SAFE_INTEGEReNumber.MAX_SAFE_INTEGER
superlukas
2
Portanto, neste caso, devemos votar negativamente a resposta porque ela está errada para a pergunta atualizada ou deixá-la porque o Peter Baily estava certo no momento em que foi respondida?
Rocketsarefast 27/05
112

É 2 53 == 9 007 199 254 740 992. Isso ocorre porque Numbers são armazenados como ponto flutuante em uma mantissa de 52 bits.

O valor mínimo é -2 53 .

Isso faz algumas coisas divertidas acontecerem

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

E também pode ser perigoso :)

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
}

Outras leituras: http://blog.vjeux.com/2010/javascript/javascript-max_int-number-limits.html

Vjeux
fonte
1
embora nunca chegaria ao fim desse loop for em um prazo sã, você pode querer dizeri += 1000000000
ninjagecko
2
@ninjagecko, ele começa em MAX_INT, então o fim está aí. O uso de i + = 1000000000 deixaria de ser um loop infinito. Tente.
Ted Bigham
@TedBigham: Ah, oops, estava pronto rápido demais para isso. Obrigado por me corrigir duas vezes.
Ninjagecko
Veja o argumento de Jimmy para 9.007.199.254.740.991 em vez de 9.007.199.254.740.992 aqui . Isso, combinado com o meu acompanhamento, parece persuasivo.
TJ Crowder
60

Em JavaScript, há um número chamado Infinity.

Exemplos:

(Infinity>100)
=> true

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

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

Isso pode ser suficiente para algumas perguntas sobre este tópico.

BananaNeil
fonte
25
Algo me diz que o infinito não se qualifica como um número inteiro. :)
devios1
7
Mas é bom o suficiente para inicializar uma minvariável quando você procura um valor mínimo.
djjeck
9
Note queInfinity - 1 === Infinity
H.Wolper
2
também (Infinito <100) => false e Math.pow (2,1024) === Infinito
Sijav
6
Também não vale nada, pois ele lida com o Infinito negativo também. Então1 - Infinity === -Infinity
dmccabe
41

A resposta de Jimmy representa corretamente o espectro inteiro contínuo do JavaScript como -9007199254740992 a 9007199254740992 inclusive (desculpe 9007199254740993, você pode pensar que é 9007199254740993, mas está errado! Demonstração abaixo ou em jsfiddle ).

console.log(9007199254740993);

No entanto, não há resposta que encontre / prove isso programaticamente (além da mencionada por CoolAJ86 em sua resposta que terminaria em 28,56 anos;), então aqui está uma maneira um pouco mais eficiente de fazer isso (para ser preciso, é mais eficiente por cerca de 28,559999999968312 anos :), juntamente com um violino de teste :

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

Briguy37
fonte
8
@ CoolAJ86: Lol, eu estou ansioso para 15 de março de 2040. Se nossos números corresponder devemos dar uma festa :)
Briguy37
var x = Math.pow (2,53) -3; while (x! = x + 1) x ++; -> 9007199254740991
MickLH
@MickLH: recebo 9007199254740992 com esse código . Qual mecanismo JavaScript você está usando para testar?
Briguy37
Você obtém 9007199254740992 com seu próprio código, eu não usei o valor final de x, mas a avaliação final de x ++ por razões paranóicas. Google Chrome btw.
MickLH 18/11
@MickLH: a avaliação x++fornece o valor de x antes que o incremento ocorra, o que provavelmente explica a discrepância. Se você deseja que a expressão seja avaliada da mesma forma que o valor final de x, altere-a para ++x.
Peterflynn
32

Estar seguro

var MAX_INT = 4294967295;

Raciocínio

Eu pensei que seria inteligente e encontraria o valor pelo qual x + 1 === xcom uma abordagem mais pragmática.

Minha máquina pode contar apenas 10 milhões por segundo, mais ou menos ... então postarei de volta com a resposta definitiva em 28,56 anos.

Se você não pode esperar tanto, estou disposto a apostar que

  • A maioria dos seus loops não dura 28,56 anos
  • 9007199254740992 === Math.pow(2, 53) + 1 é prova suficiente
  • Você deve manter o 4294967295que é Math.pow(2,32) - 1para evitar problemas esperados com a mudança de bits

Encontrando 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);
}());
CoolAJ86
fonte
4
você não pode simplesmente começar em 2 ^ 53 - 2 para testar? (sim você pode, eu apenas tentei, mesmo com -3 para ser seguro: var x = Math.pow (2,53) -3; while (x! = x + 1) x ++;) -> 9007199254740991
MickLH
Boa resposta! Além disso, eu sei que o valor está acertado, mas por que não usar a pesquisa binária para sua descoberta?
higuaro
1
Qual é a graça disso? Além disso, @ Briguy37 chegou antes de mim: stackoverflow.com/a/11639621/151312
CoolAJ86
observe que esse MAX_INT 'seguro' baseado em 32 bits não funcionará ao comparar com os valores de data. 4294967295 é tão ontem!
Jerry
1
A resposta "Para estar seguro: var MAX_INT = 4294967295;" não é engraçado. Se você não mudar de bits, não se preocupe com isso (a menos que precise de um int maior que 4294967295; nesse caso, você provavelmente deve armazená-lo como uma string e usar uma biblioteca bigint).
CoolAJ86
29

A resposta curta é "depende".

Se você estiver usando operadores bit a bit em qualquer lugar (ou se estiver se referindo ao comprimento de uma matriz), os intervalos serão:

Não assinado: 0…(-1>>>0)

Assinado: (-(-1>>>1)-1)…(-1>>>1)

(Ocorre que os operadores bit a bit e o comprimento máximo de uma matriz são restritos a números inteiros de 32 bits.)

Se você não estiver usando operadores bit a bit ou trabalhando com comprimentos de matriz:

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

Essas limitações são impostas pela representação interna do tipo “Número”, que geralmente corresponde à representação de ponto flutuante de precisão dupla IEEE 754. (Observe que, diferentemente dos números inteiros assinados típicos, a magnitude do limite negativo é a mesma que a magnitude do limite positivo, devido às características da representação interna, que na verdade inclui um 0 negativo !)

danorton
fonte
Esta é a resposta que eu queria encontrar sobre como converter X em um número inteiro de 32 bits ou número inteiro não assinado. Votou sua resposta para isso.
Charlie Affumigato
29

ECMAScript 6:

Number.MAX_SAFE_INTEGER = Math.pow(2, 53)-1;
Number.MIN_SAFE_INTEGER = -Number.MAX_SAFE_INTEGER;
WaiKit Kung
fonte
1
Cuidado, ainda não é suportado por todos os navegadores! Hoje, o iOS (nem mesmo o Chrome), o Safari e o IE não gostam disso.
Cregox # 6/15
5
Leia a resposta com atenção, não estamos usando a implementação padrão do Number.MAX_SAFE_INTEGER no ECMAScript 6, estamos definindo-a por Math.pow (2, 53) -1
WaiKit Kung
Eu pensei que era apenas uma referência a como ela é implementada no ECMA 6! : PI acha que meu comentário ainda é válido, no entanto. Tudo uma questão de contexto. ;)
cregox
3
É confiável calcular MAX_SAFE_INTEGERem todos os navegadores trabalhando de trás para frente? Em vez disso, você deve avançar? Ou seja, Number.MAX_SAFE_INTEGER = 2 * (Math.pow (2, 52) - 1) + 1;
kjv
É Math.pow(2, 53)-1uma operação segura? Vai um número maior que o maior número inteiro seguro.
439 ioquatix
21

Muitas respostas de épocas anteriores mostraram o resultado truede 9007199254740992 === 9007199254740992 + 1verificar se 9 007 199 254 740 991 é o número máximo e seguro.

E se continuarmos fazendo acumulação:

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

Pudemos descobrir que, entre números maiores que 9 007 199 254 740 992 , apenas números pares são representáveis .

É uma entrada para explicar como o formato binário de 64 bits de precisão dupla funciona nisso. Vamos ver como 9 007 199 254 740 992 são mantidos (representados) usando este formato binário.

Usando uma versão resumida para demonstrá-la em 4 503 599 627 370 496 :

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

No lado esquerdo da seta, temos o valor de bit 1 e um ponto de raiz adjacente ; então, multiplicando 2^52, movemos à direita o ponto de raiz 52 passos, e ele vai até o fim. Agora temos 4503599627370496 em binário.

Agora começamos a acumular 1 para esse valor até que todos os bits sejam definidos como 1, o que equivale a 9 007 199 254 740 991 em decimal.

  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. 

Agora, como no formato binário de 64 bits de precisão dupla , ele distribui estritamente 52 bits por fração, não há mais bits disponíveis para adicionar mais 1, então o que podemos fazer é definir todos os bits de volta para 0 e manipular a parte do expoente:

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

Agora, obtemos 9 007 199 254 740 992 e, com o número maior, o que o formato pode conter são 2 vezes a fração , significa que agora cada 1 adição na parte da fração é realmente igual a 2, é por isso que o dobro formato binário de 64 bits de precisão não pode conter números ímpares quando o número for maior que 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 --|

Portanto, quando o número chegar a mais de 9 007 199 254 740 992 * 2 = 18 014 398 509 481 984, apenas 4 vezes da fração poderiam ser mantidas:

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

Que tal um número entre [ 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  --|

O valor do bit 1 após o ponto radix é 2 ^ -1 exatamente. (= 1/2, = 0,5) Portanto, quando o número for menor que 4 503 599 627 370 496 (2 ^ 52), há um bit disponível para representar as 1/2 vezes do número inteiro :

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

Menos de 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"

E qual é o intervalo disponível da parte do expoente ? o formato aloca 11 bits para ele. Formato completo do Wiki : (Para mais detalhes, visite o site)

Formato de ponto flutuante duplo IEEE 754.svg

insira a descrição da imagem aqui

Portanto, para fazer a parte do expoente ser 2 ^ 52, precisamos exatamente definir e = 1075.

Carr
fonte
13

Outros já podem ter dado a resposta genérica, mas pensei que seria uma boa idéia fornecer uma maneira rápida de determiná-la:

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

O que me dá 9007199254740992 em menos de um milissegundo no Chrome 30.

Ele testará poderes de 2 para descobrir qual deles, quando 'adicionado' 1, é igual a si mesmo.

Philippe97
fonte
Pode travar seu aplicativo, pensou.
Sapphire_Brick
8

Tudo o que você deseja usar para operações bit a bit deve estar entre 0x80000000 (-2147483648 ou -2 ^ 31) e 0x7fffffff (2147483647 ou 2 ^ 31 - 1).

O console informará que 0x80000000 é igual a +2147483648, mas 0x80000000 e 0x80000000 é igual a -2147483648.

Scato
fonte
6

Tentar:

maxInt = -1 >>> 1

No Firefox 3.6, é 2 ^ 31 - 1.

Martin Naatz
fonte
2
@danorton: Não sei se você entende o que está fazendo. ^meios elevados ao poder . No console javascript, ^é XOR , não levantou-to
kumarharsh
2
abra o console do Chrome / Firefox. Digite 5 ^ 2. Em binário, 5 é 101e 2 é 010. Agora, se você XOR-los, você vai ter 5(101) ^ 2(010) = 7(111) LEIA ESTE Se você está confuso O que está sendo discutido aqui é Math.pow()não o ^operador
kumarharsh
3
Mais uma vez, não estou nada confuso. Eu comentei e votei com voto negativo no que está escrito . Se Math.pow () é o que significa, então é isso que deve ser escrito. Em uma resposta a uma pergunta sobre JavaScript, é inadequado usar sintaxe de um idioma diferente. É ainda mais inapropriado usar uma sintaxe válida em JavaScript, mas com uma interpretação em JavaScript que tenha um significado diferente do pretendido.
Danorton
10
2 ^ 31 é como se escreve dois no trigésimo primeiro poder em inglês. Não está em um bloco de código. Você reclamaria de alguém usando um; em uma resposta, porque esse é um personagem com um significado diferente em Javascript?
Lmm
3
Mesmo que se deva escrever 2³¹ e não 2 ^ 31 em texto simples, é comum fazê-lo, porque a maioria dos layouts de teclado não possui esses caracteres por padrão. Pelo menos não tive problemas para entender o que significava nesta resposta.
Jocke
6

No momento da escrita, JavaScript está recebendo um novo tipo de dados: BigInt. É uma proposta do TC39 no estágio 4 a ser incluída no EcmaScript 2020 . BigIntestá disponível no Chrome 67+, FireFox 68+, Opera 54 e Node 10.4.0. Está em andamento no Safari, etc. Ele introduz literais numéricos com o sufixo "n" e permite precisão arbitrária:

var a = 123456789012345678901012345678901n;

A precisão ainda será perdida, é claro, quando esse número for (talvez não intencionalmente) coagido a um tipo de dados numérico.

E, obviamente, sempre haverá limitações de precisão devido à memória finita e um custo em termos de tempo para alocar a memória necessária e executar aritmética em números tão grandes.

Por exemplo, a geração de um número com cem mil dígitos decimais levará um atraso notável antes da conclusão:

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

... mas funciona.

trincot
fonte
4

Fiz um teste simples com uma fórmula, X- (X + 1) = - 1, e o maior valor de XI pode funcionar no Safari, Opera e Firefox (testado no OS X) é 9e15. Aqui está o código que eu usei para testar:

javascript: alert(9e15-(9e15+1));
Raynet
fonte
1
Observe que 9e15 = 2 ^ 53 (consulte a resposta de @ Jimmy).
Wedge
6
9e15 = 9000000000000000. 2 ^ 53 = 9007199254740992. Portanto, para ser pedante, 9e15 é apenas aproximadamente igual a 2 ^ 53 (com dois dígitos significativos).
precisa saber é o seguinte
@chaiguy 9000000000000000Existe um número significativo. em 9007199254740992, existem 15 números significativos.
Royi Namir
@RoyiNamir Não quero iniciar um argumento inútil aqui, mas 9000000000000000 possui 16 dígitos significativos. Se você quiser apenas 1, teria que ser escrito como 9x10 ^ 15.
devios1
1
@chaiguy No. 9000000000000000como é - tem 1SF. onde 90*10^14tem 2. ( sigfigscalculator.appspot.com ) & mathsfirst.massey.ac.nz/Algebra/Decimals/SigFig.htm (seção inferior)
Royi Namir
3

Eu escrevo assim:

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

Mesmo para int32

var max_int32 =  0x80000000;
var min_int32 = -0x80000000;
Jerome
fonte
3

Vamos às fontes

Descrição

A MAX_SAFE_INTEGERconstante tem um valor de 9007199254740991(9.007.199.254.740.991 ou ~ 9 quadrilhões). O raciocínio por trás desse número é que o JavaScript usa números de formato de ponto flutuante de precisão dupla, conforme especificado no IEEE 754 e pode representar apenas números com segurança entre -(2^53 - 1)e2^53 - 1 .

Seguro neste contexto refere-se à capacidade de representar números inteiros exatamente e compará-los corretamente. Por exemplo, Number.MAX_SAFE_INTEGER + 1 === Number.MAX_SAFE_INTEGER + 2avaliará como verdadeiro, que é matematicamente incorreto. Consulte Number.isSafeInteger () para obter mais informações.

Como MAX_SAFE_INTEGERé uma propriedade estática de Number , você sempre a usa como Number.MAX_SAFE_INTEGER, e não como uma propriedade de um objeto Number que você criou.

Compatibilidade do navegador

insira a descrição da imagem aqui

simhumileco
fonte
0

No javascript interno do Google Chrome, você pode ir para aproximadamente 2 ^ 1024 antes que o número seja chamado infinito.

Tommy
fonte
-1

Scato escreve:

qualquer coisa que você queira usar para operações bit a bit deve estar entre 0x80000000 (-2147483648 ou -2 ^ 31) e 0x7fffffff (2147483647 ou 2 ^ 31 - 1).

o console informará que 0x80000000 é igual a +2147483648, mas 0x80000000 e 0x80000000 é igual a -2147483648

Os decimais hexadecimais são valores positivos não assinados, portanto, 0x80000000 = 2147483648 - isso é matematicamente correto. Se você deseja transformá-lo em um valor assinado, precisa mudar à direita: 0x80000000 >> 0 = -2147483648. Você também pode escrever 1 << 31.

SammieFox
fonte
-7

O Firefox 3 parece não ter problemas com grandes números.

1e + 200 * 1e + 100 calculará multa para 1e + 300.

O Safari parece não ter problemas com isso também. (Para constar, este é um Mac se alguém decidir testá-lo.)

A menos que eu tenha perdido o cérebro a essa hora do dia, isso é muito maior que um número inteiro de 64 bits.

jishi
fonte
18
não é um número inteiro de 64 bits, é um número de ponto flutuante de 64 bits, dos quais 52/53 bits são a parte inteira. portanto, ele suporta até 1e300, mas não com precisão exata.
2113 Jimmy Jimmy
4
Jimmy está correto. Tente isso no seu navegador ou na linha de comando JS:100000000000000010 - 1 => 100000000000000020
Ryan
-7

O Node.js e o Google Chrome parecem estar usando valores de ponto flutuante de 1024 bits, portanto:

Number.MAX_VALUE = 1.7976931348623157e+308
TinyTimZamboni
fonte
1
-1: o número máximo representável (integral não exata) pode ser ~ 2 ^ 1024, mas isso não significa que eles estão se desviando do padrão IEEE-754 de 64 bits.
Roy Tinker
2
MAX_INT? Você quer dizer MAX_VALUE?
Raul Guiu
3
é o máximo de um valor de ponto flutuante . Isso não significa que você pode armazenar um int por tanto tempo
phuclv
1
Ou mais, você não pode armazenar um int de maneira confiável por muito tempo sem perda de precisão . 2^53é chamado MAX_SAFE_INTporque, acima desse ponto, os valores se tornam aproximações, da mesma forma que as frações.
IMSOP