Converter um número flutuante em int em JavaScript

1. Converter Float em Int usando a função parseInt() em JavaScript
2. Converter Float em Int usando Number.toFixed() em JavaScript
3. Converter flutuante em int com operadores bit a bit em JavaScript
4. Converter Float em Int usando as funções da biblioteca Math em JavaScript
5. Conclusão

Em JavaScript, temos muitas maneiras de converter float em int, conforme mostrado abaixo.

• A função parseInt()
• O método Number.toFixed()
• Conversão com operadores bit a bit
  • Aplicando OR por 0
  • Usando o operador duplo NOT
  • SHIFT à direita por 0
• Usando funções de biblioteca Math em javascript
  • Math.floor()
  • Math.round()
  • Math.ceil()
  • Math.trunc()

Converter Float em Int usando a função parseInt() em JavaScript

parseInt() é amplamente usado em JavaScript. Com esta função, podemos converter os valores de diferentes tipos de dados para o tipo inteiro. Nesta seção, veremos a conversão de um número flutuante em um número inteiro. A sintaxe de parseInt() é parseInt(<value>). O código a seguir mostra o comportamento da função.

console.log(parseInt(123.321));
console.log(parseInt(123.998));

Resultado:

123
123

Observações

• Para obter mais informações, consulte os documentos do MSN.
• Ao converter valores flutuantes, parseInt() descarta os decimais e não os considera ao retornar a parte do número inteiro do valor flutuante.
• parseInt() retorna NaN caso a conversão não seja possível. Portanto, é bom incluir uma verificação isNaN() durante a conversão de valores para que o código seja seguro e não quebre.

Converter Float em Int usando Number.toFixed() em JavaScript

Number.toFixed() se comporta um pouco diferente do parseInt(). Ele arredonda o número para o valor inteiro mais próximo. Portanto, tome cuidado com o fato arredondado. Number.toFixed() arredonda o valor decimal de float menor que .5 para o valor inteiro inferior. Se o valor decimal for 0.5 ou maior, o número flutuante será arredondado para o próximo valor inteiro mais alto. A sintaxe da função Number.toFixed() é a seguinte.

numberObject.toFixed(<number of digits>);

Normalmente, precisamos passar um parâmetro para esta função que especifica o número de dígitos após o decimal na saída. Para o nosso propósito, não precisamos mencionar nenhum argumento, pois, por padrão, leva o parâmetro como sendo 0, retornando, portanto, um valor inteiro. Consulte os seguintes códigos de amostra.

console.log( (123.123).toFixed(2) );
console.log( (123.123).toFixed() );
console.log( (123.98).toFixed() );
console.log( (123.49).toFixed() );
console.log( (123.5).toFixed() );

Resultado:

123.12
123
124
123
124

Observações

• Ao contrário do método parseInt(), Number.toFixed() não é tão famoso por extrair a parte inteira, pois faz um arredondamento do valor flutuante passado como um parâmetro.
• Pode-se usar esta função para converter apenas valores flutuantes. Ao contrário da função parseInt(), a conversão do valor da string em float não é suportada por Number.toFixed().

Converter flutuante em int com operadores bit a bit em JavaScript

Vimos os métodos de parseInt() e Number.toFixed(). Ambos executam algumas operações internas para obter os resultados desejados. Os operadores bit a bit são eficientes, rápidos e por formante na conversão dos valores flutuantes em um inteiro quando comparados aos dois métodos. Podemos usar os seguintes operadores bit a bit para a conversão.

Aplicando OR por 0

Podemos usar o operador OR bit a bit para obter a parte do número inteiro de um número de ponto flutuante. Os operadores bit a bit funcionam no nível binário. Ele converte o número do operando em binário e, em seguida, a operação OR bit a bit é executada. Aplicar OR com 0 a qualquer número de ponto flutuante na faixa aceitável retornará a parte do número inteiro do valor de ponto flutuante. Consulte os exemplos abaixo.

console.log(123.321 | 0);
console.log(123.5432 | 0);
console.log(123.921 | 0);
console.log(216 | 0);
console.log(-321.456 | 0)

Resultado:

123
123
123
216
-321

Usando o operador duplo NOT

Outro operador bit a bit é o operador NOT, representado pelo sinal ~. Sendo um operador unário, podemos usar o operador NOT bit a bit para eliminar a parte decimal de um número flutuante. O operador NOT, no nível binário, inverte os valores dos bits binários (retornando 0 para um bit 1 e 1 para um valor de bit 0). Isso significa que se um número for representado em binário por 10110, aplicar NOT a ele resulta no valor invertido 01001. Aplicar novamente a funcionalidade NOT retorna os bits originais (10110) do número. Portanto, a aplicação do operador NOT duas vezes retorna o valor numérico e, durante o processo, não altera o número se for um inteiro. Mas para um valor flutuante, a aplicação do operador NOT duas vezes retornará apenas a parte do número inteiro do número flutuante. Os exemplos a seguir esclarecem esse fato.

console.log(~~(123.321));
console.log(~~(123.53));
console.log(~~(23.97));
console.log(~~(-23.97));
console.log(~~(-0.97));

Resultado:

123
123
23
-23
0

Deslocamento à direita em 0

Podemos aplicar o operador de deslocamento à direita bit a bit (representado por caracteres >>). Ele converterá o valor flutuante em um inteiro. Abaixo, no nível binário, o operador SHIFT bit a bit à direita desloca os bits binários do operando para a direita por uma contagem especificada pelo segundo operando. Conseqüentemente, ele ignora os bits que transbordam para a direita. Ao fazer isso, a função preserva o valor do sinal do número. Os códigos a seguir representam o funcionamento do operador SHIFT correto.

console.log(123.321 >> 0);
console.log(123.53 >> 0);
console.log(23.97 >> 0);
console.log(-23.97 >> 0);
console.log(-0.97 >> 0);

Resultado:

123
123
23
-23
0

Observações

• Operadores bit a bit são mais rápidos porque estão mais próximos da linguagem de máquina e não precisam realizar verificações ou operações adicionais como seriam feitas internamente por parseInt() ou Number.toFixed().
• Operadores bit a bit como OR, NOT etc., quando aplicados em números grandes, podem dar resultados inesperados. O valor máximo suportado para obter o valor decimal truncado é 2147483647 (2³¹-1). Qualquer número superior a 2147483647 fornecerá resultados inesperados.
• Em JavaScript, os números de ponto flutuante são representados por 64 bits, com um bit reservado para preservar o valor do sinal (positivo ou negativo), 32 bits para toda a parte do número. Os operadores bit a bit operam nos números de 32 bits com sinal, ignorando o valor decimal. Portanto, obtemos a parte do número inteiro do valor flutuante.

Converter Float em Int usando as funções da biblioteca Math em JavaScript

Podemos usar a biblioteca JavaScript Math, que tem várias funções para obter inteiros de números de ponto flutuante. Ao contrário dos operadores bit a bit, eles oferecem recursos adicionais com base em requisitos como arredondamento de valores para os números mais próximos, valores de truncamento, etc. Podemos usar os métodos a seguir para essa finalidade.

Conversão com Math.floor()

A função Math.floor() arredonda o valor passado como parâmetro para o próximo valor inteiro inferior. A sintaxe de Math.floor() é Math.floor (<valor flutuante>). A seguir estão alguns exemplos que mostram o uso e como ele converte um float em um número inteiro.

console.log(Math.floor(123.321));
console.log(Math.floor(123.53));
console.log(Math.floor(23.97));
console.log(Math.floor(-23.97));
console.log(Math.floor(-0.97));

Resultado:

123
123
23 - 24 - 1

O caso de números flutuantes negativos como Math.floor(-23.97) pode parecer confuso, mas a função converte corretamente o valor para o próximo inteiro inferior, -24. Lembre-se de que quanto maior o valor numérico de um número negativo, menor é seu valor real.

Conversão com Math.round()

Ao contrário da função Math.floor(), Math.round() aproxima o valor passado nos parâmetros. Se o valor após o decimal for 5 ou maior, o número será arredondado para o próximo inteiro mais alto. Caso contrário, se o valor após o decimal for menor que 5, ele será arredondado para o número inteiro inferior. Portanto, com base no valor após o ponto decimal, a função Math.round() pode se comportar de forma semelhante às funções Math.floor() ou Math.ceil(). A seguir estão alguns exemplos com Math.round().

console.log(Math.round(123.321));
console.log(Math.round(123.53));
console.log(Math.round(23.97));
console.log(Math.round(-23.97));
console.log(Math.round(-0.97));

Resultado:

123
124
24
-24
-1

Conversão com Math.ceil()

A função Math.ceil() se comporta de forma oposta à função Math.floor(). Em vez de arredondar para o próximo inteiro inferior como em Math.floor(), Math.ceil() retorna o próximo valor inteiro mais alto. A seguir estão algumas conversões com Math.ceil().

console.log(Math.ceil(123.321));
console.log(Math.ceil(123.53));
console.log(Math.ceil(23.97));
console.log(Math.ceil(-23.97));
console.log(Math.ceil(-0.97));

Resultado:

124
124
24
-23
-0

Conversão com Math.trunc()

Como o nome sugere, a função Math.trunc() trunca o valor decimal e retorna a parte do número inteiro do valor flutuante. Este método pode ser considerado semelhante aos operadores bit a bit discutidos anteriormente. Aqui, não há arredondamento para os inteiros mais próximos. Em vez disso, ele retorna a parte do número inteiro do valor flutuante como está. A seguir estão alguns casos de uso com Math.trunc().

console.log(Math.trunc(123.321));
console.log(Math.trunc(123.53));
console.log(Math.trunc(23.97));
console.log(Math.trunc(-23.97));
console.log(Math.trunc(-0.97));

Resultado:

123
123
23
-23
-0

Conclusão

Existem várias maneiras de obter a parte inteira de um valor flutuante. Os operadores bit a bit são mais rápidos na execução, pois realizam operações no nível binário sem os requisitos de conversão ou qualquer outro processamento. parseInt(), Math.trunc() e os operadores bit a bit (OR por 0, duplo NOT, deslocamento à direita por 0) fornecem o número inteiro exato como se rasgassem o valor flutuante na vírgula decimal e retornar apenas a parte do número inteiro dela. Se estivermos interessados ​​em processar o número flutuante para arredondá-lo ou obter o número inteiro mais próximo com base na necessidade do negócio, seria bom escolher Number.toFixed(), Math.round(), Math.ceil() e as funções Math.floor().