¿Cómo convierto un número flotante a un número entero en JavaScript?

Me gustaría convertir un flotante a un número entero en JavaScript. En realidad, me gustaría saber cómo hacer AMBAS conversiones estándar: truncando y redondeando. Y de manera eficiente, no mediante la conversión a una cadena y el análisis.

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

Referencia de objeto matemático

Ejemplos

// 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 a nivel de bit

Se puede usar un operador u bit a bit para truncar figuras de punto flotante y funciona tanto para positivos como para negativos:

function float2int (value) {
    return value | 0;
}

Resultados

float2int(3.1) == 3
float2int(-3.1) == -3
float2int(3.9) == 3
float2int(-3.9) == -3

¿Comparación de rendimiento?

He creado una prueba JSPerf que compara el rendimiento entre:

• Math.floor(val)
• val | 0 ^{bitwise O}
• ~~val ^{NO bit a bit}
• parseInt(val)

eso solo funciona con números positivos. En este caso, es seguro usar operaciones bit a bit como Math.floorfunción.

Pero si necesita que su código funcione con positivos y negativos , entonces una operación bit a bit es la más rápida (O es la preferida). Esta otra prueba JSPerf compara lo mismo donde es bastante obvio que debido a la comprobación adicional de signos, Math es ahora el más lento de los cuatro.

Nota

Como se indicó en los comentarios, los operadores BITWISE operan con enteros de 32 bits con signo, por lo tanto, se convertirán grandes números, por ejemplo:

1234567890  | 0 => 1234567890
12345678901 | 0 => -539222987

Nota: ¡No se puede usar Math.floor()como un reemplazo para truncar, porque Math.floor(-3.1) = -4y no -3!

Un reemplazo correcto para truncar sería:

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

    return Math.floor(value);
}

Se puede usar un operador doble no bit a bit para truncar los flotadores. Las otras operaciones que usted ha mencionado están disponibles a través Math.floor, Math.ceily Math.round.

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

Más detalles cortesía de James Padolsey.

Para truncar:

var intvalue = Math.floor(value);

Por ronda:

var intvalue = Math.round(value);

Puede usar el método parseInt para no redondear. Tenga cuidado con la entrada del usuario debido a las opciones de prefijo 0x (hexadecimal) y 0 (octal).

var intValue = parseInt(floatValue, 10);

Desplazamiento de bits por 0, que es equivalente a la división por 1

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

En su caso, cuando desee una cadena al final (para insertar comas), también puede usar la Number.toFixed()función, sin embargo, esto realizará el redondeo.

Hay muchas sugerencias aquí. El OR bit a bit parece ser el más simple con diferencia. Aquí hay otra solución corta que también funciona con números negativos utilizando el operador de módulo. Probablemente sea más fácil de entender que el bit a bit O:

intval = floatval - floatval%1;

Este método también funciona con números de alto valor donde ni '| 0' ni '~~' ni '>> 0' funcionan correctamente:

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

Math.round( 1.5 );  // 2
Math.round( 1.49 ); // 1
Math.round( -1.6 ); // -2
Math.round( -1.3 ); // -1

Una forma más posible: utilice la operación 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

La prioridad de las operaciones bit a bit es menor que la prioridad de las operaciones matemáticas, es útil. Pruebe en https://jsfiddle.net/au51uj3r/

Si busca un Mathobjeto nativo en JavaScript, obtiene todas las funciones para trabajar en números y valores, etc.

Básicamente, lo que quieres hacer es bastante simple y nativo en JavaScript ...

Imagina que tienes el siguiente número:

const myValue = 56.4534931;

y ahora si quieres redondearlo al número más cercano, simplemente haz lo siguiente:

const rounded = Math.floor(myValue);

y obtienes:

56

Si desea redondearlo al número más cercano, simplemente haga lo siguiente:

const roundedUp = Math.ceil(myValue);

y obtienes:

57

Además, Math.roundsimplemente redondearlo a un número mayor o menor depende de cuál esté más cerca del número de flotador.

También puede usar ~~detrás del número flotante, que convertirá un flotante en un número entero.

Puedes usarlo como ~~myValue...

Solo quiero señalar que monetariamente quieres redondear, y no truncar. Estar fuera por un centavo es mucho menos probable, ya que 4.999452 * 100 redondeado le dará 5, una respuesta más representativa.

Y además de eso, no se olvide del redondeo bancario , que es una forma de contrarrestar el sesgo ligeramente positivo que produce el redondeo directo: su aplicación financiera puede requerirlo.

Redondeo gaussiano / bancario en JavaScript

Si está utilizando angularjs, entonces la solución simple de la siguiente manera en Enlace de plantilla HTML

{{val | number:0}}

convertirá val en entero

ve a través de este enlace docs.angularjs.org/api/ng/filter/number