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

parsefloat javascript 2 decimales

Question

Me gustaría convertir un flotador en un número entero en JavaScript. De hecho, me gustaría saber cómo hacer AMBOS de las conversiones estándar: truncando y redondeando. Y de manera eficiente, no a través de la conversión a una cadena y el análisis.

Answer 1

Operador bit a bit o

Un bitwise o un operador se puede usar para truncar figuras de punto flotante y funciona tanto para positivos como 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 val | 0 ^{bitwise OR}
• ~~val ^{bitwise NO}
• parseInt(val)

Eso solo funciona con números positivos. En este caso, es seguro utilizar operaciones bitwise como función Math.floor .

Pero si necesita que su código funcione con positivos y negativos , entonces una operación a nivel de bits 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 de signos adicionales, Math es ahora el más lento de los cuatro.

Nota

Como se indica en los comentarios, los operadores de BITWISE operan con enteros de 32 bits firmados, por lo que se convertirán grandes números, por ejemplo:

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

Answer 2

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

Answer 3

Hay muchas sugerencias aquí. El bit a bit OR parece ser el más simple por mucho. Aquí hay otra solución corta que funciona con números negativos y también con 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

Answer 4

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

Un reemplazo correcto para truncar sería:

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

    return Math.floor(value);
}

Answer 5

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

Answer 6

Para truncar:

var intvalue = Math.floor(value);

Para redondo:

var intvalue = Math.round(value);

Answer 7

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

var intValue = parseInt(floatValue, 10);

Answer 8

Se puede utilizar un operador de doble bit no para truncar flotadores. Las otras operaciones que mencionó están disponibles a través de Math.floor , Math.ceil y Math.round .

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

Más detalles cortesía de James Padolsey.

Answer 9

Si está usando angularjs, entonces la solución simple es la siguiente: En Encuadernación de plantillas HTML

{{val | number:0}}

se convertirá val en entero

siga este enlace docs.angularjs.org/api/ng/filter/number

Answer 10

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

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

Redondeo gaussiano / bancario en JavaScript

Answer 11

Una forma más posible - usar 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 bitwise es menor que la prioridad de las operaciones matemáticas, es útil. Pruébelo en https://jsfiddle.net/au51uj3r/

Answer 12

Cambio de bit en 0, que es equivalente a división por 1

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

Answer 13

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 matematico

Ejemplos

Positivo

value = 5.5 Math.floor(value) // 5 Math.ceil(value) // 6 Math.round(value) // 6 Math.trunc(value) // 5 parseInt(value) // 5 ~~value // 5 value | 0 // 5 value >> 0 // 5 value >>> 0 // 5 value - value % 1 // 5 Negativo

value = -5.5 Math.floor(value) // -6 Math.ceil(value) // -5 Math.round(value) // -5 Math.trunc(value) // -5 parseInt(value) // -5 value | 0 // -5 ~~value // -5 value >> 0 // -5 value >>> 0 // 4294967291 value - value % 1 // -5 Positivo - Números más grandes

value = Number.MAX_SAFE_INTEGER/10 // 900719925474099.1 Math.floor(value) // 900719925474099 Math.ceil(value) // 900719925474100 Math.round(value) // 900719925474099 Math.trunc(value) // 900719925474099 parseInt(value) // 900719925474099 value | 0 // 858993459 ~~value // 858993459 value >> 0 // 858993459 value >>> 0 // 858993459 value - value % 1 // 900719925474099 Negativo - Números más grandes

value = Number.MAX_SAFE_INTEGER/10 * -1 // -900719925474099.1

Math.floor(value) // -900719925474100
Math.ceil(value)  // -900719925474099
Math.round(value) // -900719925474099
Math.trunc(value) // -900719925474099
parseInt(value)   // -900719925474099
value | 0         // -858993459
~~value           // -858993459
value >> 0        // -858993459
value >>> 0       //  3435973837
value - value % 1 // -900719925474099