Como posso remover a parte decimal do número JavaScript?

Tenho os resultados de uma divisão e desejo descartar a parte decimal do número resultante.

Como posso fazer isso?

Você poderia usar ...

• Math.trunc() (parte fracionária truncada, veja também abaixo)
• Math.floor() (arredondar para baixo)
• Math.ceil() (arredondar para cima)
• Math.round() (arredondar para o número inteiro mais próximo)

... depende de como você deseja remover o decimal.

Math.trunc()ainda não é suportado em todas as plataformas (a saber, IE), mas você pode facilmente usar um polyfill nesse meio tempo.

Outro método de truncar a parte fracionária com excelente suporte à plataforma é usar um operador bit a bit (.eg |0). O efeito colateral de usar um operador bit a bit em um número é que ele tratará seu operando como um número inteiro de 32 bits assinado, removendo, portanto, o componente fracionário. Lembre-se de que isso também altera números maiores que 32 bits.

Você também pode estar falando sobre a imprecisão do arredondamento decimal na aritmética de ponto flutuante.

Leitura obrigatória - O que todo cientista da computação deve saber sobre aritmética de ponto flutuante .

Você também pode usar operadores bit a bit para truncar o decimal.

por exemplo

var x = 9 / 2;
console.log(x); // 4.5

x = ~~x;
console.log(x); // 4

x = -3.7
console.log(~~x) // -3
console.log(x | 0) // -3
console.log(x << 0) // -3

As operações bit a bit são consideravelmente mais eficientes que as funções matemáticas. O operador não bit a bit dupla também parece superar ligeiramente os x | 0e x << 0bit a bit operações por um valor insignificante.

// 952 milliseconds
for (var i = 0; i < 1000000; i++) {
    (i * 0.5) | 0;
}

// 1150 milliseconds
for (var i = 0; i < 1000000; i++) {
    (i * 0.5) << 0;
}

// 1284 milliseconds
for (var i = 0; i < 1000000; i++) {
    Math.trunc(i * 0.5);
}

// 939 milliseconds
for (var i = 0; i < 1000000; i++) {
    ~~(i * 0.5);
}

Também digno de nota é que o operador bit a bit não tem precedência sobre operações aritméticas, portanto, pode ser necessário cercar os cálculos entre parênteses para obter o resultado pretendido:

x = -3.7

console.log(~~x * 2) // -6
console.log(x * 2 | 0) // -7
console.log(x * 2 << 0) // -7

console.log(~~(x * 2)) // -7
console.log(x * 2 | 0) // -7
console.log(x * 2 << 0) // -7

Mais informações sobre o operador double bitwise not podem ser encontradas em Double bitwise NOT (~~)

Você também pode fazer

parseInt(a/b)

Você também pode mostrar um certo número de dígitos após o ponto decimal (aqui 2 dígitos) usando o seguinte código:

var num = (15.46974).toFixed(2)
console.log(num) // 15.47
console.log(typeof num) // string

Use a Math.round()função

Math.round(65.98) // will return 66 
Math.round(65.28) // will return 65

Use Math.round().

(A resposta de Alex é melhor; eu assumi :)

Com o ES2015, Math.trunc () está disponível.

Math.trunc(2.3)                       // 2
Math.trunc(-2.3)                      // -2
Math.trunc(22222222222222222222222.3) // 2.2222222222222223e+22
Math.trunc("2.3")                     // 2
Math.trunc("two")                     // NaN
Math.trunc(NaN)                       // NaN

Não é suportado no IE11 ou abaixo, mas funciona no Edge e em qualquer outro navegador moderno.

Se você não se importa com o roteamento, basta converter o número em uma sequência e remover tudo depois do período, inclusive o período. Isso funciona se existe um decimal ou não.

const sEpoch = ((+new Date()) / 1000).toString();
const formattedEpoch = sEpoch.split('.')[0];

O toFixed se comportará como redondo.

Para um comportamento semelhante ao piso, use%:

var num = 3.834234;
var floored_num = num - (num % 1); // floored_num will be 3

Aqui está o compressivo na explicação detalhada com a ajuda dos posts acima:

1. Math.trunc (): É usado para remover os dígitos que são seguidos pelo ponto. Ele converte implicitamente. Mas, não suportado no IE.

Exemplo:

Math.trunc (10.5) // 10

Math.trunc (-10.5) // -10

Outra maneira alternativa: Uso do operador bit a bit, não:

Exemplo:

x = 5,5

~~ x // 5

2. Math.floor (): É usado para fornecer o valor inteiro mínimo possível. É suportado em todos os navegadores.

Exemplo:

Math.floor (10.5) // 10

Math.floor (-10.5) // -11

3. Math.ceil (): É usado para fornecer o maior valor inteiro possível. É suportado em todos os navegadores.

Exemplo:

Math.ceil (10.5) // 11

Math.ceil (-10.5) // -10

4. Math.round (): é arredondado para o número inteiro mais próximo. É suportado em todos os navegadores.

Exemplo:

Math.round (10.5) // 11

Math.round (-10.5) // -10

Math.round (10.49) // 10

Math.round (-10.51) // -11

Para uma implementação ES6, use algo como o seguinte:

const millisToMinutesAndSeconds = (millis) => {
  const minutes = Math.floor(millis / 60000);
  const seconds = ((millis % 60000) / 1000).toFixed(0);
  return `${minutes}:${seconds < 10 ? '0' : ''}${seconds}`;
}

Isto é para aqueles que desejam impedir que os usuários insiram números decimais

<input id="myInput" onkeyup="doSomething()" type="number" />

<script>
    function doSomething() {

        var intNum = $('#myInput').val();

        if (!Number.isInteger(intNum)) {
            intNum = Math.round(intNum);
        }

        console.log(intNum);
    }
</script>

Você pode usar .toFixed (0) para remover a parte decimal completa ou fornecer o número nos argumentos até os quais você deseja que o decimal seja truncado.

Nota: toFixed converterá o número em string.

Por exemplo:

var x = 9.656;
x.toFixed(0);           // returns 10
x.toFixed(2);           // returns 9.66
x.toFixed(4);           // returns 9.6560
x.toFixed(6);           // returns 9.656000 

ou

parseInt("10");         // returns 10
parseInt("10.33");      // returns 10
parseInt("10 20 30");   // returns 10
parseInt("10 years");   // returns 10
parseInt("years 10");   // returns NaN