Como converter um número flutuante em um número inteiro em JavaScript?

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.

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

Exemplos

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

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

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

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

Operador OR bit a bit

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

Comparação de desempenho?

Eu criei um teste JSPerf que compara o desempenho entre:

• Math.floor(val)
• val | 0 ^{OR bit a bit}
• ~~val ^{NÃO bit a bit}
• parseInt(val)

isso funciona apenas com números positivos. Nesse caso, é seguro usar operações bit a bit e Math.floorfunçõ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.

Nota

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

Nota: Você não pode usar Math.floor()como um substituto para truncar, porque Math.floor(-3.1) = -4e não -3!!

Uma substituição correta para truncar seria:

function truncate(value)
{
    if (value < 0) {
        return Math.ceil(value);
    }

    return Math.floor(value);
}

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.ceile Math.round.

> ~~2.5
2
> ~~(-1.4)
-1

Mais detalhes cortesia de James Padolsey.

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

Deslocamento de bits por 0, o que equivale à divisão por 1

// >> or >>>
2.0 >> 0; // 2
2.0 >>> 0; // 2

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 Mathobjeto 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.roundapenas 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...

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.

Arredondamento de gaussiano / banqueiro em JavaScript

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