Este artigo traz a você conhecimento relevante sobre JavaScript, que apresenta principalmente o conteúdo relevante sobre tipos de números. Existem dois tipos de números em JavaScript: tipos Number e BigInt. ajuda.
[Recomendações relacionadas: tutorial em vídeo javascript, front-end da web]
Existem dois tipos de números em JavaScript :
O tipo Number , que é um tipo numérico no sentido convencional, é armazenado no formato IEEE-754 de 64 bits e é um "número de ponto flutuante de precisão dupla. Até agora, todos os números com os quais entramos em contato são". do tipo Number ;
O tipo BigInt representa números inteiros de qualquer comprimento. Normalmente não os usamos, a menos que representem números diferentes de 2 53 a -2 53. Apresentaremos esses tipos de dados profissionais em detalhes em capítulos posteriores;
A maneira de escrever números é muito simples, mas JavaScrpt tem muitos açúcares sintáticos convenientes e rápidos para usarmos. Aprender esses açúcares sintáticos não apenas melhorará nossa capacidade de leitura de código, mas também melhorará o sentido de alto nível de nosso código.
Os números decimais são os mais simples e os usaremos mais ou menos em quase todos os artigos. Por exemplo, criamos uma variável e armazenamos 100 bilhões:
deixe dez bilhões = 10000000000;
Embora a operação seja muito simples, há um problema: é difícil contar quantos 0 seguem 1 Se estivermos escrevendo um código de transferência, um 0 errado pode levar à falência.
Neste momento, podemos usar _ como delimitador, da seguinte forma:
deixe dez bilhões = 10_000_000_000;
O código acima pode contar claramente o número de 0 , o que é obviamente a solução ideal!
_ sublinhado aqui é um açúcar sintático do JavaScript , que será ignorado pelo mecanismo durante a execução. Os dois métodos de escrita acima têm o mesmo efeito, mas a experiência de leitura é muito diferente.
Circuito cerebral Qingqi
Alguns calçados infantis têm que perguntar, sempre estive em grupos de 4 0 desde criança, por que tenho que agrupar 3 0 ? Portanto, podemos escrevê-lo da seguinte maneira sem nenhum problema:
deixe dez bilhões = 100_0000_0000;
Ou poderia ser escrito assim:
deixe dez bilhões = 1_0000_0000_00;
O que quero expressar aqui é que não importa qual método de divisão você use, isso não afetará o tamanho do número em si. Crie o método mais poderoso!
Embora o uso de _ possa dividir elegantemente muitos 0 , na vida real geralmente não escrevemos desta forma. Por exemplo, muitas vezes escrevemos 10000000000 como "10 bilhões", de modo que muitos 0 podem ser omitidos, reduzindo assim a possibilidade de fazer. erros.
JavaScript também fornece uma maneira de omitir 0 Podemos usar a letra e seguida de um número para representar o número 0 Por exemplo:
deixe dez bilhões = 1e10;//10 bilhões, 1 seguido por 10 0sconsole.log(3.14e9);//3140000000, seguido por 7 0s, olhe para baixo se tiver alguma dúvida.
A compreensão do código acima é muito simples e10 pode ser entendido como 1_0000_0000_00 0 que é 1 seguido de 10 , então podemos pensar:
1e10 === 1 * 1_0000_0000_00;//e10 significa 1 seguido por 10 03.14e9 === 3,14 * 1_000_000_000;//e9 significa 1 seguido por 9 0s
Também podemos usar este método para representar números muito pequenos, como 1 nanômetro:
deixe nm = 0,000000001; //Unidade (metro)
Como há muitos 0 , também podemos usar _ :
seja nm = 0,000_000_001;
Claro, você também pode usar e para omitir todos os 0 , como segue:
deixe nm = 1e-9;//9 0s à esquerda de 1, incluindo aquele antes da vírgula decimal
Em outras palavras, e-9 significa 1 -9 , que é 1/1000_000_000 , então a seguinte equação é verdadeira:
1e-9 === 1/1_000_000_000;3.14e-8 === 3,14/1_000_000_00;
Hexadecimal é um formato comumente usado em programação, como cor, codificação, etc. Podemos adicionar 0x antes de números comuns para representar números hexadecimais:
deixe hex = 0xff; //255, não diferencia maiúsculas de minúsculas, 0xFF é o mesmo
Os números binários começam com 0b :
deixe bin = 0b1011;//11
Os números octais começam com 0o :
deixe outubro = 0o777;//511
Este método de escrita simples suporta apenas esses três tipos especiais. Quanto a outros números base, você pode usar funções especiais para gerá-los ( parseInt ).
O método toString pode converter o número em uma forma de string correspondente à base .
Dê uma castanha:
seja num = 996; console.log(num.toString(8));//Converter para string octal console.log(num.toString(16));//Converter para string hexadecimal console.log(num.toString( 32));// Converter para string hexadecimal de 32
Os resultados da execução do código são os seguintes:
O intervalo de base pode ser de 2 a 36 Se não for preenchido, o padrão é 10 .
Observe que se você usar números para chamar diretamente o método toString , em alguns casos será necessário aplicar dois . por exemplo:
console.log(123.toString(8));//Erro, erro de sintaxe console.log(123..toString(8));//Correto, 173
Existem dois . depois do número. Isso ocorre porque em JavaScript o primeiro . depois do número é considerado o ponto decimal e o segundo ponto é o .
Se for um decimal, este problema não existe.
console.log(3.14.toString(8));
Ou podemos usar parênteses para evitar o uso de dois pontos, por exemplo:
console.log((123).toString(8));//'173
O arredondamento é uma das operações mais comuns com números e geralmente inclui:
Arredondar para baixo, Math.floor(num)
console.log(Math.floor(3.14));//3 console.log(Math.floor(9.99));//9 console.log(Math.floor(-3.14));//-4 console.log(Math.floor(-9.99));//-10
Não siga o princípio do arredondamento e pegue diretamente o número inteiro mais próximo menor ou igual ao valor atual.
Arredondar, Math.ceil(num)
console.log(Math.ceil(3.14));//4 console.log(Math.ceil(9.99));//10 console.log(Math.ceil(-3.14));//-3 console.log(Math.ceil(-9.99));//-9
Não siga o princípio do arredondamento e pegue diretamente o número inteiro mais próximo maior ou igual ao número atual.
Arredonde para o número inteiro mais próximo, Math.round(num)
console.log(Math.round(3.14));//3 console.log(Math.round(9.99));//10 console.log(Math.round(-3.14));//-3 console.log(Math.round(-9.99));//-10
Seguindo o princípio do arredondamento, é obtido o número inteiro mais próximo do número atual.
Remova decimais, Math.trunc(num)
console.log(Math.trunc(3.14));//3 console.log(Math.trunc(9.99));//9 console.log(Math.trunc(-3.14));//-3 console.log(Math.trunc(-9.99));//-9
Remova diretamente os números após a vírgula decimal e arredonde para dígitos inteiros. O navegador IE não suporta este método
Compare os quatro métodos acima:
| Math.floor | Matemática.ceil | Rodada matemática | Matemática.trunc | |
|---|---|---|---|---|
| 3.14 | 3 | 4 | 3 | 3 |
| 9,99 | 9 | 10 | 10 | 9 |
| -3,14 | -4 | -3 | -3 | -3 |
| -9,99 | -10 | -9 | -10 | -9 |
O método acima simplesmente arredonda o decimal para um número inteiro. Em alguns casos, precisamos de decimais com uma precisão específica. Por exemplo, o que devemos fazer se pegarmos os últimos 4 dígitos de pi.
Existem dois métodos:
multiplicação matemática e contagem de divisão
deixe pi = 3,1415926;console.log(Math.round(pi * 10000) / 10000);//3.1416
O código acima primeiro multiplica pi por 10000 , depois arredonda e depois divide por 10000 , obtendo assim um resultado que atende aos requisitos de precisão. No entanto, isso parece bobo e JavaScript nos fornece uma maneira mais fácil.
para Fixo(n)
deixe pi = 3.1415926;console.log(pi.toFixed(4));//3.1416
O código acima parece não ter problemas com a saída. Na verdade, toFixed retorna uma string. Se precisarmos de um tipo numérico, podemos usar o operador unário + pi.toFixed(4) .
Além disso, se a mantissa decimal não for longa o suficiente, toFixed adicionará '0' no final:
deixe num = 3.1;console.log(num.toFixed(9));
Os resultados da execução do código são os seguintes: 
Isso também prova que o valor de retorno de toFixed é uma string, caso contrário, 0 será omitido.
As representações de ponto flutuante são sempre tendenciosas em muitos casos
Dentro do computador, os números de ponto flutuante são representados de acordo com IEEE-754 , onde os números de ponto flutuante de precisão simples são de 32 bits e os números de ponto flutuante de precisão dupla são de 64 bits. Em um número de ponto flutuante de precisão dupla, 1 bit é usado para representar o sinal, 52 bits são usados para armazenar os dígitos significativos e 11 bits são usados para armazenar a posição do ponto decimal.
Embora 64 bits já possam representar números muito grandes, ainda existe a possibilidade de cruzar a fronteira, por exemplo:
deixe bigNum = 1e999;console.log(bigNum);//infinito
O número que ultrapassar o valor máximo se tornará Infinity (infinito), perdendo assim o tamanho do número original, o que é uma espécie de desvio.
Há outro tipo de desvio que precisamos aprender:
console.log(0,1+0,2 === 0,3);//falseconsole.log(0,1 + 0,2);
Os resultados da execução do código são os seguintes:
Isso mesmo, o resultado de 0.1 + 0.2 não é 0.3 , mas um monte de 0 seguidos de 4 .
Este tipo de desvio é muito fatal, especialmente em centros comerciais e cenários de trabalho bancário. Mesmo um desvio muito pequeno levará à perda de riqueza infinita em cenários de elevado volume de negócios.
Certa vez ouvi uma história sobre um funcionário de banco que roubou milhões de dólares deduzindo o salário dos trabalhadores. O salário de cada funcionário era de apenas 20 centavos!
Acho que se isso acontecesse comigo, eu definitivamente não seria capaz de encontrá-lo, por isso é muito importante ser preciso o tempo todo.
Não sei se essa história é verdadeira ou não~~
Vamos tomar nosso sistema decimal comum como exemplo. Todos nós sabemos que existem duas coisas estranhas nos decimais, uma é chamada de decimais 1/3 infinitos e a outra é chamada de decimais infinitos não repetitivos. decimal 0.3333333(3) e pi É um decimal infinito e não repetitivo. Infinito significa que o tamanho do número não pode ser claramente descrito numericamente e o que podemos escrever é impreciso.
Existem também alguns números em loop infinito em binário. A diferença é que em decimal, um número como 0.1 que parece muito simples, é um decimal em loop infinito em binário.
Por exemplo:
deixe x = 0,1;console.log(x.toFixed(20));
Os resultados da execução do código são os seguintes:
Você não acha incrível? Simplesmente criamos uma variável e atribuímos a ela o valor 0.1 e depois pegamos 20 casas decimais, mas obtivemos um resultado incrível.
Se mudarmos o ângulo, pode ser mais fácil entender esse fenômeno. No sistema decimal, qualquer número inteiro dividido por 10 ou 10 potências inteiras é um número normal e preciso, como 1/10 ou 996/1000 . No entanto, se você dividir por 3 , obterá um resultado em loop, como 1/3 .
Esta descrição também é válida se convertida para binário.
Em binário, qualquer número inteiro dividido por 2 ou uma potência inteira de 2 é um número exato normal. No entanto, se você dividi-lo por 10 , obterá um loop infinito de números binários.
Portanto, podemos concluir que os números binários não podem representar com precisão 0.1 e 0.2 assim como os números decimais não podem descrever 1/3 .
Perceber:
Esse tipo de desvio de dados não é um defeito do JavaScript, é o mesmo resultado para PHP, Java, C, Perl e Ruby.
Arredondamento
Ao exibir um decimal infinitamente recorrente, podemos usar diretamente o método toFixed para arredondar o decimal. Este método retorna diretamente uma string, o que é muito conveniente para exibir preços.
0.3.toFixed(2);//0.30
Use unidades pequenas
Outra maneira é que podemos usar unidades menores para calcular preços e distâncias, como usar centavos em vez de yuans para calcular o preço total. No entanto, este método apenas reduz o número de ocorrências de decimais e não há como evitar completamente a ocorrência de decimais.
Existem dois valores especiais em números JavaScript : Infinity e NaN .
Como julgar se um número é um número normal?
Podemos usar dois métodos:
éFinito(val)
Esta função converterá o parâmetro val em um tipo numérico, determinará se o número é finito e retornará true quando o número não for NaN , Infinity ou -Infinity .
console.log(isFinite(NaN));//falseconsole.log(isFinite(Infinity));//falseconsole.log(isFinite(3));//trueconsole.log(isFinite('12'));// verdadeiro Os resultados da execução do código são os seguintes:
Como uma string que não pode ser convertida em um número será convertida em NaN , podemos usar o método isFinite para determinar se a string é uma string numérica:
console.log(isFinite('xxxx'));//falseconsole.log(isFinite('Infinite'));//falseconsole.log(isFinite(' '));//true, string vazia é convertida para 0Os resultados da execução do código são os seguintes:
éNaN(val)
Retorna true quando val é NaN ou outro valor que não pode ser convertido em um número.
console.log(isNaN(NaN));//trueconsole.log(isNaN('Infinito'));//true Resultados de execução de código:
Por que usar a função isNaN em vez de lê-la diretamente?
Por exemplo:
console.log(NaN === NaN); //falso
Os resultados da execução do código são os seguintes:
Isso ocorre porque NaN não é igual a nenhum número, inclusive a si mesmo.
Object.is(a,b) pode determinar se os parâmetros a e b são iguais. Se forem iguais, retorna true , caso contrário, retorna false .
Pode ser comparado a NaN
console.log(Object.is(NaN,NaN));//true
Resultados de execução de código:
0 e -0
console.log(Object.is(0,-0));//falso
Resultados de execução de código:
No computador, positivo e negativo são representados por 0 e 1 Devido aos sinais diferentes, 0 e -0 são na verdade diferentes e são expressos de maneiras diferentes.
outro
Outras situações de comparação são exatamente iguais a === b .
parseInt e parseFloat podem converter strings em números. Ao contrário de + e Number , suas restrições são mais flexíveis. Por exemplo, usar + e Number para uma string como "100￥" retornará inevitavelmente NaN , mas parseInt e parseFloat podem lidar com isso facilmente.
Por exemplo:
console.log(+"100￥");console.log(parseInt("100￥"));console.log(parseFloat("12.5￥"));Resultados de execução de código:
parseInt e parseFloat leem números de uma string até que eles não possam mais ser lidos. Ambos são particularmente adequados para processar strings começando com números como "99px" e "11.4em" , mas NaN é retornado para strings começando com outros caracteres.
console.log(parseInt('ff2000'));//NaN No entanto, descobrimos ff2000 é na verdade uma string digital hexadecimal. parseInt também pode lidar com essa situação, mas precisa adicionar um parâmetro hexadecimal.
Por exemplo:
console.log(parseInt('FF2000',16));
//16719872
console.log(parseInt('0xFF2000',16));
//16719872
console.log(parseInt('nnnnnn',36));
//1430456963Resultados de execução de código:
O objeto Math integrado contém muitas constantes e métodos que usamos com frequência. Aqui estão apenas alguns exemplos dos mais usados:
Matemática.PI
Pi Π é uma constante não cíclica infinita, podemos usar Math.PI em vez disso:
console.log(Math.PI);
Matemática.random()
Gere um número aleatório no intervalo [0,1) :
console.log(Math.random());console.log(Math.random());
Se precisarmos de um número aleatório dentro de um intervalo específico, podemos multiplicá-lo por um valor específico e depois arredondá-lo.
Matemática.pow(a,b)
Calcule a b , por exemplo:
console.log(Math.pow(2,3));//8
Math.max()/Math.min()
Escolha um valor máximo/mínimo entre qualquer número de argumentos:
console.log(Math.max(1,2,3,4,5));//5console.log(Math.min(1,2,3,4,5));//1
