O JS possui apenas um tipo de dados numéricos. Seja um número inteiro ou um número de ponto flutuante, o JS o classifica como um número.
tipo de 17; // "número"
tipo de 98,6; // "número"
tipo de 2.1; // "número"
Todos os números no JS são números de ponto flutuante de dupla precisão. É um número codificado de 64 bits formulado pelo padrão IEEE754 (o que é isso, eu não sei, basta procurar e conferir)
Então, como o JS expressa números inteiros? Os números de ponto flutuante de dupla precisão podem representar perfeitamente os números inteiros com precisão de até 53 bits (sem conceito, não processei muitos dados, não usei!) E todos os números inteiros de -9007199254740992 (-253) a 90071925474099 (253) são válidos.
A maioria dos operadores aritméticos pode ser calculada usando números inteiros, números reais ou uma combinação de ambos.
0,1*1,9 //0.19
-99+100 // 1
21-12.3 //8.7
2.5/5 //0.5
21%8 // 5
Os operadores aritméticos são bastante especiais. O JS não calcula diretamente os operando como números de ponto flutuante, mas implicitamente os converte em números inteiros de 32 bits para executar operações. (Para ser preciso, será convertido em um número inteiro representando 2 de Big-Endian de 32 bits (para ser sincero, eu realmente não sei o que isso significa aqui, por favor, procure ciência popular)) Use Bitwise ou Operação Expressões como
exemplo:
8 | 1; // 9
Processo de computação
Primeiro de tudo, 8 e 1 são números de ponto flutuante de precisão dupla. Mas também pode ser representado como um número inteiro de 32 bits, ou seja, uma representação binária de 32 bits.
O número inteiro 8 é representado como binário de 32 bits como:
0000 0000 0000 0000 0000 0000 0000 1000
Também pode ser
(8) .ToString (2); // "1000"
A tostragem do parâmetro é a base de conversão
(A seguir é o que tentei converter com outra cardinalidade, e não tem nada a ver com este artigo)
(8) .ToString (8); // "10"
(8) .ToString (16); // "8"
O número inteiro 1 é representado como binário de 32 bits como:
0000 0000 0000 0000 0000 0000 0000 0000 0001
Corra bitwise ou
0000 0000 0000 0000 0000 0000 0000 1000
0000 0000 0000 0000 0000 0000 0000 0000 0001
--------------------------------------------------------------------------------------------------------------------------------------------------
0000 0000 0000 0000 0000 0000 0000 1001
O mesmo usa a função de biblioteca padrão verificação de parseint e usa 2 como cardinalidade. A liderança 0 não afeta o resultado do cálculo, o que é desnecessário.
Parseint ('1001', 2) // 9
(A seguir é o que tentei converter com outra cardinalidade, e não tem nada a ver com este artigo)
Parseint ('1001', 8) // 513
Parseint ('1001', 16) // 4097
O processo de resumo da operação aritmética é converter operandos em números inteiros, depois usar o modo de bit inteiro para executar operações e, finalmente, converter o resultado em um número padrão de ponto flutuante JS.
Aviso dos números de ponto flutuante: notoriamente imprecisos. por exemplo
0,1+0,2; //0.30000000000000000004
Razão: embora a precisão dos números de ponto flutuante de 64 bits já seja muito alto, os números de ponto flutuante de precisão dupla podem representar apenas um conjunto de números finitos, mas não pode representar todos os conjuntos de números reais. As operações de ponto flutuante só podem produzir resultados aproximados, arredondando para o número real mais próximo representável. Quando você realiza uma série de operações, à medida que o erro de arredondamento se acumula, os resultados da operação se tornarão menos precisos. O arredondamento também causa alguns desvios nas leis das operações aritméticas. Por exemplo, a lei do vínculo. Para qualquer número real
x, y, z sempre satisfaz (x+y)+z = x+(y+z)
Os pontos flutuantes não são necessariamente:
(0,1+0,2) +0,3; //0.60000000000000000001
0,1+ (0,2+0,3); //0.6
Os números de ponto flutuante pesam a precisão e o desempenho. Quando você se preocupa com precisão, tenha cuidado com as limitações dos números de pontos flutuantes.
A solução é converter operações de ponto flutuante em operações inteiras.
(10+20) +30; // 60
10+ (20+30); // 60
Em seguida, divida o fator de ampliação. Observe que o intervalo inteiro deve estar dentro de -253 ~ 253.
Resumir
1. Os números de JS são números de ponto flutuante de precisão dupla
2. O número inteiro de JS é apenas um subconjunto de números de ponto flutuante de precisão dupla, não um único tipo
3. Operação de bit trata os números como números inteiros assinados de 32 bits
4. Cuidado com a precisão das operações de ponto flutuante
O artigo acima detalhado dos números de pontos flutuantes no JavaScript é todo o conteúdo que compartilhei com você. Espero que possa lhe dar uma referência e espero que você possa apoiar mais o wulin.com.