Gostaria de converter um número flutuante em um número inteiro em JavaScript. Na verdade, eu gostaria de saber como fazer AMBAS as conversões padrão: truncando e arredondando. E de forma eficiente, não através da conversão para uma string e análise.
Gostaria de converter um número flutuante em um número inteiro em JavaScript. Na verdade, eu gostaria de saber como fazer AMBAS as conversões padrão: truncando e arredondando. E de forma eficiente, não através da conversão para uma string e análise.
Respostas:
var intvalue = Math.floor( floatvalue );
var intvalue = Math.ceil( floatvalue );
var intvalue = Math.round( floatvalue );
// `Math.trunc` was added in ECMAScript 6
var intvalue = Math.trunc( floatvalue );
Referência de objeto matemático
// value=x // x=5 5<x<5.5 5.5<=x<6
Math.floor(value) // 5 5 5
Math.ceil(value) // 5 6 6
Math.round(value) // 5 5 6
Math.trunc(value) // 5 5 5
parseInt(value) // 5 5 5
~~value // 5 5 5
value | 0 // 5 5 5
value >> 0 // 5 5 5
value >>> 0 // 5 5 5
value - value % 1 // 5 5 5
Negativo
// value=x // x=-5 -5>x>=-5.5 -5.5>x>-6
Math.floor(value) // -5 -6 -6
Math.ceil(value) // -5 -5 -5
Math.round(value) // -5 -5 -6
Math.trunc(value) // -5 -5 -5
parseInt(value) // -5 -5 -5
value | 0 // -5 -5 -5
~~value // -5 -5 -5
value >> 0 // -5 -5 -5
value >>> 0 // 4294967291 4294967291 4294967291
value - value % 1 // -5 -5 -5
Positivo - números maiores
// x = Number.MAX_SAFE_INTEGER/10 // =900719925474099.1
// value=x x=900719925474099 x=900719925474099.4 x=900719925474099.5
Math.floor(value) // 900719925474099 900719925474099 900719925474099
Math.ceil(value) // 900719925474099 900719925474100 900719925474100
Math.round(value) // 900719925474099 900719925474099 900719925474100
Math.trunc(value) // 900719925474099 900719925474099 900719925474099
parseInt(value) // 900719925474099 900719925474099 900719925474099
value | 0 // 858993459 858993459 858993459
~~value // 858993459 858993459 858993459
value >> 0 // 858993459 858993459 858993459
value >>> 0 // 858993459 858993459 858993459
value - value % 1 // 900719925474099 900719925474099 900719925474099
Negativo - números maiores
// x = Number.MAX_SAFE_INTEGER/10 * -1 // -900719925474099.1
// value = x // x=-900719925474099 x=-900719925474099.5 x=-900719925474099.6
Math.floor(value) // -900719925474099 -900719925474100 -900719925474100
Math.ceil(value) // -900719925474099 -900719925474099 -900719925474099
Math.round(value) // -900719925474099 -900719925474099 -900719925474100
Math.trunc(value) // -900719925474099 -900719925474099 -900719925474099
parseInt(value) // -900719925474099 -900719925474099 -900719925474099
value | 0 // -858993459 -858993459 -858993459
~~value // -858993459 -858993459 -858993459
value >> 0 // -858993459 -858993459 -858993459
value >>> 0 // 3435973837 3435973837 3435973837
value - value % 1 // -900719925474099 -900719925474099 -900719925474099
var intValue = ~~floatValue;
. Se a notação é demasiado obscuro para o seu gosto, apenas escondê-lo em uma função: function toInt(value) { return ~~value; }
. (Isso também converte seqüências de caracteres em números inteiros, se você quiser fazê-lo.) #
Math.trunc(val);
Comentário porque esta é a resposta aceita
2.3 - 2.3 % 1
Um bit a bit ou operador pode ser usado para truncar figuras de ponto flutuante e funciona para positivos e negativos:
function float2int (value) {
return value | 0;
}
Resultados
float2int(3.1) == 3
float2int(-3.1) == -3
float2int(3.9) == 3
float2int(-3.9) == -3
Eu criei um teste JSPerf que compara o desempenho entre:
Math.floor(val)
val | 0
OR bit a bit~~val
NÃO bit a bitparseInt(val)
isso funciona apenas com números positivos. Nesse caso, é seguro usar operações bit a bit e Math.floor
funções.
Mas se você precisar que seu código funcione com positivos e negativos , uma operação bit a bit é a mais rápida (OU é a preferida). Esse outro teste JSPerf compara o mesmo, onde é bastante óbvio que, devido à verificação adicional de sinais, o Math agora é o mais lento dos quatro.
Conforme declarado nos comentários, os operadores BITWISE operam em números inteiros de 32 bits assinados; portanto, grandes números serão convertidos, por exemplo:
1234567890 | 0 => 1234567890
12345678901 | 0 => -539222987
Math.floor()
é mais rápido (pelo menos de acordo com a execução do seu primeiro teste JSPerf no Google Chrome, versão 30.0.1599.101), mais robusto (porque não depende de como os números são representados em bits, que pode mudar e possivelmente quebrar essa solução bit a bit) e, mais importante, mais explícita.
~~
é melhor porque é um operador unário. 4.2|0+4
igual 4
mas ~~4.2+4
igual8
Nota: Você não pode usar Math.floor()
como um substituto para truncar, porque Math.floor(-3.1) = -4
e não -3
!!
Uma substituição correta para truncar seria:
function truncate(value)
{
if (value < 0) {
return Math.ceil(value);
}
return Math.floor(value);
}
Math.trunc(value)
foi adicionado no ECMAScript 6
floor
arredonda para -in infinito, truncate
arredonda para zero. ( ceil
arredonda para + infinito).
Um operador não bit a bit duplo pode ser usado para truncar flutuadores. As outras operações que você mencionou estão disponíveis através de Math.floor
, Math.ceil
e Math.round
.
> ~~2.5
2
> ~~(-1.4)
-1
<canvas>
mecanismo de renderização de fontes em JS . Obrigado!
Para truncar:
var intvalue = Math.floor(value);
Para rodada:
var intvalue = Math.round(value);
Você pode usar o método parseInt para não arredondar. Tenha cuidado com a entrada do usuário devido às opções de prefixo 0x (hex) e 0 (octal).
var intValue = parseInt(floatValue, 10);
parseInt(1000000000000000000000, 10);
resulta em 1, não em 1 000 000 000 000 000 000 000 000. De qualquer forma, a pergunta explicitamente não queria " converter para uma string e analisar ", embora isso seja relativamente menor ...;)
parseInt()
espera que uma string não seja um número como seu primeiro parâmetro. Quando você passar este número inteiro, ele é convertido para 1e21
e, em seguida, parseInt
analisa a cadeia 1e21
, o que resulta em 1
.
Deslocamento de bits por 0, o que equivale à divisão por 1
// >> or >>>
2.0 >> 0; // 2
2.0 >>> 0; // 2
>> 0
parece funcionar apenas para números inteiros < 2 ^ 31-1 e >>> 0
para números inteiros < 2 ^ 32-1 . Isso retorna 0 para valores maiores
No seu caso, quando você deseja uma sequência no final (para inserir vírgulas), também pode usar a Number.toFixed()
função, no entanto, isso fará o arredondamento.
Há muitas sugestões aqui. O OR bit a bit parece ser o mais simples de longe. Aqui está outra solução curta que funciona com números negativos, também usando o operador de módulo. Provavelmente é mais fácil entender do que o OR bit a bit:
intval = floatval - floatval%1;
Este método também funciona com números de alto valor, onde nem '| 0' nem '~~' nem '>> 0' funcionam corretamente:
> n=4294967295;
> n|0
-1
> ~~n
-1
> n>>0
-1
> n-n%1
4294967295
Para truncar :
// Math.trunc() is part of the ES6 spec
Math.trunc( 1.5 ); // returns 1
Math.trunc( -1.5 ); // returns -1
// Math.floor( -1.5 ) would return -2, which is probably not what you wanted
Para arredondar :
Math.round( 1.5 ); // 2
Math.round( 1.49 ); // 1
Math.round( -1.6 ); // -2
Math.round( -1.3 ); // -1
Mais uma maneira possível - use a operação XOR:
console.log(12.3 ^ 0); // 12
console.log("12.3" ^ 0); // 12
console.log(1.2 + 1.3 ^ 0); // 2
console.log(1.2 + 1.3 * 2 ^ 0); // 3
console.log(-1.2 ^ 0); // -1
console.log(-1.2 + 1 ^ 0); // 0
console.log(-1.2 - 1.3 ^ 0); // -2
A prioridade das operações bit a bit é menor que a prioridade das operações matemáticas, é útil. Experimente em https://jsfiddle.net/au51uj3r/
Se olhar para um Math
objeto nativo em JavaScript, você obtém todo o conjunto de funções para trabalhar com números e valores, etc ...
Basicamente, o que você quer fazer é bastante simples e nativo em JavaScript ...
Imagine que você tem o número abaixo:
const myValue = 56.4534931;
e agora, se você quiser arredondá-lo para o número mais próximo, basta:
const rounded = Math.floor(myValue);
e você obtém:
56
Se você quiser arredondar para o número mais próximo, faça o seguinte:
const roundedUp = Math.ceil(myValue);
e você obtém:
57
Também Math.round
apenas arredondá-lo para um número maior ou menor depende de qual deles está mais próximo do número do flot.
Também é possível usar ~~
atrás do número do flutuador, que converterá um flutuador em um número inteiro.
Você pode usá-lo como ~~myValue
...
~~
porque, se o número for maior que o limite int 32, ele mudará o valor para o valor limite int 32.
//Convert a float to integer
Math.floor(5.95)
//5
Math.ceil(5.95)
//6
Math.round(5.4)
//5
Math.round(5.5)
//6
Math.trunc(5.5)
//5
//Quick Ways
console.log(5.95| 0)
console.log(~~5.95)
console.log(5.95 >> 0)
//5
Eu só quero ressaltar que monetariamente você deseja arredondar, e não truncar. É muito menos provável que você gaste um centavo, pois 4.999452 * 100 arredondado fornecerá 5, uma resposta mais representativa.
Além disso, não se esqueça do arredondamento dos banqueiros , que é uma maneira de combater o viés levemente positivo que o arredondamento direto oferece - seu aplicativo financeiro pode exigir isso.
Se você estiver usando angularjs, a solução simples é a seguinte: Em Ligação de modelo HTML
{{val | number:0}}
ele converterá val em inteiro
siga este link docs.angularjs.org/api/ng/filter/number