Cómo redondear dobles/flotantes en JavaScript

En este tutorial, aprenda a redondear números decimales (flotantes/dobles) en JavaScript a enteros enteros: hacia arriba, hacia abajo o el más cercano.

Introducción

Los flotantes y los dobles representan números de coma flotante, números con puntos decimales. Si bien este tipo es muy útil para una amplia variedad de entornos, dependiendo de para qué se usen, a veces queremos redondearlos a un número entero: el entero entero más cercano, hacia arriba o hacia abajo.

En este artículo, exploraremos cómo redondear números dobles/flotantes (incluyendo cadenas) en JavaScript utilizando métodos integrados del objeto Math.

El objeto Math

El objeto Math se utiliza para realizar operaciones matemáticas comunes. Debido a que el objeto Math es un objeto integrado estático, no puede y no necesitará inicializarlo; se puede invocar en cualquier punto como un objeto estático con métodos auxiliares. Tiene una gran cantidad de constantes y técnicas para realizar operaciones matemáticas, a las que se puede acceder directamente.

¡Veamos algunos de los métodos prácticos del objeto Math para redondear dobles/flotantes en JavaScript!

Math.round()

Math.round() es una función que se utiliza para devolver el valor de un número de punto flotante redondeado al entero más cercano. Dependiendo del flotante/doble suministrado, Math.round() redondea hacia arriba o hacia abajo.

Si el número de coma flotante es superior o igual a x.5, se redondea hacia arriba al entero más cercano. Si el número de punto flotante está por debajo de x.5, se redondea hacia abajo al entero más cercano:

1
2
3
4
Math.round(24.49); // 24
Math.round('29.5'); // 30
Math.round(72); // 72
Math.round(-40.51); // -41
Math.piso()

El método Math.floor() se usa para devolver el entero entero más cercano que es menor o igual a un valor especificado. En términos sencillos, el método floor() redondea un número hacia abajo y devuelve un resultado entero:

1
2
3
4
5
Math.floor(75.95); //  75
Math.floor(75.05); //  75
Math.floor(4); //   4
Math.floor('-65.05'); // -66
Math.floor(-65.95); // -66

{.icon aria-hidden=“true”}

Nota: Math.floor(null) devuelve 0, no un error NaN.

Math.ceil()

El método Math.ceil() redondea un número al entero más cercano. En pocas palabras, se utiliza para redondear un número y devolver un valor entero:

1
2
3
4
5
6
Math.ceil(0.95);    // 1
Math.ceil(7);      // 7
Math.ceil('9.008');  // 10
Math.ceil(-0.95);  // -0
Math.ceil(-7);     // -7
Math.ceil(-9.008); // -10

{.icon aria-hidden=“true”}

Nota: Math.ceil(null) devuelve el número entero 0 y no da un error NaN.

Math.trunc()

Si bien truncar no es redondear, vale la pena mencionar el método Math.trunc(). Devuelve el entero entero del número truncando (cortando) la precisión de coma flotante, independientemente de si el argumento es positivo o negativo:

1
2
3
4
5
6
7
8
Math.trunc(38.37);    // 38
Math.trunc(72.84);    // 72
Math.trunc(0.123);    //  0
Math.trunc(-0.13323);   // -0
Math.trunc('-1.18923'); // -1
Math.trunc(NaN);      // NaN
Math.trunc('john');    // NaN
Math.trunc();         // NaN

Conclusión

En este breve artículo, echamos un vistazo a cómo redondear dobles/flotantes en JavaScript, con la ayuda de Math.round(), Math.floor(), Math.ceil() y Matemáticas.trunc().