¿Cómo puedo eliminar la parte decimal del número de JavaScript?

Tengo los resultados de una división y deseo descartar la porción decimal del número resultante.

¿Cómo puedo hacer esto?

Podrías usar ...

• Math.trunc() (parte fraccionaria truncada, ver también a continuación)
• Math.floor() (redondear a la baja)
• Math.ceil() (redondeo)
• Math.round() (redondear al entero más cercano)

... dependiendo de cómo quisieras eliminar el decimal.

Math.trunc()aún no es compatible con todas las plataformas (es decir, IE), pero mientras tanto podría usar fácilmente un polyfill .

Otro método para truncar la porción fraccional con excelente soporte de plataforma es mediante el uso de un operador bit a bit (.eg |0). El efecto secundario de usar un operador bit a bit en un número es que tratará su operando como un entero de 32 bits con signo, eliminando así el componente fraccional. Tenga en cuenta que esto también alterará los números mayores de 32 bits.

También puede estar hablando de la inexactitud del redondeo decimal con aritmética de coma flotante.

Lectura requerida: lo que todo informático debe saber sobre la aritmética de punto flotante .

También puede usar operadores bit a bit para truncar el decimal.

p.ej

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

Las operaciones bit a bit son considerablemente más eficientes que las funciones matemáticas. El operador de doble bit a bit no parece también superan ligeramente las x | 0y x << 0bit a bit operaciones por una cantidad 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);
}

También vale la pena señalar que el operador bit a bit no tiene prioridad sobre las operaciones aritméticas, por lo que es posible que necesite rodear los cálculos con paréntesis para obtener el resultado deseado:

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

Se puede encontrar más información sobre el operador doble bit a bit en NO doble bit a bit (~~)

También podrías hacer

parseInt(a/b)

También puede mostrar un cierto número de dígitos después del punto decimal (aquí 2 dígitos) usando el siguiente código:

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

Utiliza la Math.round()función.

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

Uso Math.round().

(La respuesta de Alex es mejor; hice una suposición :)

Con ES2015, Math.trunc () está disponible.

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

No es compatible con IE11 o inferior, pero funciona en Edge y en cualquier otro navegador moderno.

Si no le importa el enrutamiento, simplemente convierta el número en una cadena, luego elimine todo después del período, incluido el período. Esto funciona si hay un decimal o no.

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

toFixed se comportará como redondo.

Para un piso como comportamiento use%:

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

Aquí está la compresión en una explicación detallada con la ayuda de las publicaciones anteriores:

1. Math.trunc (): se utiliza para eliminar los dígitos seguidos de punto. Se convierte implícitamente. Pero, no es compatible con IE.

Ejemplo:

Math.trunc (10.5) // 10

Math.trunc (-10.5) // -10

Otra forma alternativa: Uso de bit a bit no operador:

Ejemplo:

x = 5.5

~~ x // 5

2. Math.floor (): se utiliza para dar el valor entero mínimo posible. Es compatible con todos los navegadores.

Ejemplo:

Math.floor (10.5) // 10

Math.floor (-10.5) // -11

3. Math.ceil (): se usa para dar el valor entero más alto posible. Es compatible con todos los navegadores.

Ejemplo:

Math.ceil (10.5) // 11

Math.ceil (-10.5) // -10

4. Math.round (): se redondea al entero más cercano. Es compatible con todos los navegadores.

Ejemplo:

Math.round (10.5) // 11

Math.round (-10.5) // -10

Math.round (10.49) // 10

Math.round (-10.51) // -11

Para una implementación de ES6, use algo como lo siguiente:

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

Esto es para aquellos que desean evitar que los usuarios ingresen números decimales

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

Puede usar .toFixed (0) para eliminar la parte decimal completa o proporcionar el número en argumentos hasta el que desea truncar el decimal.

Nota: toFixed convertirá el número a cadena.

Por ejemplo:

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 

o

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