with que para numeros number flotantes javascript floating-point numbers decimal rounding

javascript - que - parseint



Obtenga una porción decimal de un número con JavaScript (16)

¿Cómo es 0.2999999999999998 una respuesta aceptable? Si yo fuera el que pregunta, me gustaría una respuesta de .3. Lo que tenemos aquí es una precisión falsa, y mis experimentos con floor,%, etc. indican que Javascript es aficionado a la precisión falsa para estas operaciones. Por lo tanto, creo que las respuestas que usan conversión a cadena están en el camino correcto.

Yo haría esto:

var decPart = (n+"").split(".")[1];

Específicamente, estaba usando 100233.1 y quería la respuesta ".1".

Tengo números flotantes como 3.2 y 1.6 .

Necesito separar el número en la parte entera y decimal. Por ejemplo, un valor de 3.2 se dividiría en dos números, es decir, 3 y 0.2

Obtener la parte entera es fácil:

n = Math.floor(n);

Pero estoy teniendo problemas para obtener la porción decimal. He intentado esto:

remainer = n % 2; //obtem a parte decimal do rating

Pero no siempre funciona correctamente.

El código anterior tiene el siguiente resultado:

n = 3.1 => remainer = 1.1

¿Qué me falta aquí?


Así es como lo hago, que creo que es la forma más directa de hacerlo:

var x = 3.2; int_part = Math.trunc(x); // returns 3 float_part = Number((x-int_part).toFixed(2)); // return 0.2


Después de mirar varios de estos, ahora estoy usando ...

var rtnValue = Number(7.23); var tempDec = ((rtnValue / 1) - Math.floor(rtnValue)).toFixed(2);


Estoy usando:

var n = -556.123444444; var str = n.toString(); var decimalOnly = 0; if( str.indexOf(''.'') != -1 ){ //check if has decimal var decimalOnly = parseFloat(Math.abs(n).toString().split(''.'')[1]); }

Entrada: -556.123444444

Resultado: 123444444


Lenguaje de manera independiente:

var a = 3.2; var fract = a * 10 % 10 /10; //0.2 var integr = a - fract; //3

tenga en cuenta que solo corrige los números con una sola longitud de fractura)


Lo siguiente funciona independientemente de las configuraciones regionales para el separador decimal ... con la condición solo se usa un carácter para un separador.

var n = 2015.15; var integer = Math.floor(n).toString(); var strungNumber = n.toString(); if (integer.length === strungNumber.length) return "0"; return strungNumber.substring(integer.length + 1);

No es bonito, pero es preciso.


Podrías convertir a cadena, ¿verdad?

n = (n + "").split(".");


Puede convertirlo en una cadena y usar el método de reemplazar para reemplazar la parte entera por cero, luego convertir el resultado a un número:

var number = 123.123812, decimals = +number.toString().replace(/^[^/.]+/,''0'');


Puede usar la función pareseInt() para obtener la parte entera que usarla para extraer la parte decimal

var myNumber = 3.2; var integerPart = parseInt(myNumber); var decimalPart = myNumber - integerPart;


Según el uso que le des a continuación, esta sencilla solución también podría ayudarte.

No digo que sea una buena solución, pero para algunos casos concretos funciona

var a = 10.2 var c = a.toString().split(".") console.log(c[1] == 2) //True console.log(c[1] === 2) //False

Pero llevará más tiempo que la solución propuesta por @Brian M. Hunt

(2.3 % 1).toFixed(4)


Si la precisión importa y necesita resultados consistentes, aquí hay algunas proposiciones que devolverán la parte decimal de cualquier número como una cadena, incluido el "0." inicial. Si lo necesita como un flotador, simplemente agregue var f = parseFloat( result ) al final.

Si la parte decimal es igual a cero, se devolverá "0.0". Nulo, NaN y números indefinidos no son probados.

1. Array.split

var nstring = (n + ""), narray = nstring.split("."), result = "0." + ( narray.length > 1 ? narray[1] : "0" );

2. String.substring, String.indexOf

var nstring = (n + ""), nindex = nstring.indexOf("."), result = "0." + (nindex > -1 ? nstring.substring(nindex + 1) : "0");

3. Math.floor, Number.toFixed, String.indexOf

var nstring = (n + ""), nindex = nstring.indexOf("."), result = ( nindex > -1 ? (n - Math.floor(n)).toFixed(nstring.length - nindex - 1) : "0.0");

4. Math.floor, Number.toFixed, String.split

var nstring = (n + ""), narray = nstring.split("."), result = (narray.length > 1 ? (n - Math.floor(n)).toFixed(narray[1].length) : "0.0");

Aquí hay un enlace jsPerf: https://jsperf.com/decpart-of-number/

Podemos ver que la proposición # 2 es la más rápida.


Tuve un caso en el que sabía que todos los números en cuestión tendrían solo un decimal y quería obtener la porción decimal como un entero, así que terminé usando este tipo de enfoque:

var number = 3.1, decimalAsInt = Math.round((number - parseInt(number)) * 10); // returns 1

Esto funciona muy bien también con números enteros, devolviendo 0 en esos casos.


Una forma simple de hacerlo es:

var x = 3.2; var decimals = x - Math.floor(x); console.log(decimals); //Returns 0.20000000000000018

Desafortunadamente, eso no devuelve el valor exacto. Sin embargo, eso se soluciona fácilmente:

var x = 3.2; var decimals = x - Math.floor(x); console.log(decimals.toFixed(1)); //Returns 0.2

Puede usar esto si no sabe la cantidad de decimales:

var x = 3.2; var decimals = x - Math.floor(x); var decimalPlaces = x.toString().split(''.'')[1].length; decimals = decimals.toFixed(decimalPlaces); console.log(decimals); //Returns 0.2


Usa 1 , no 2 .

js> 2.3 % 1 0.2999999999999998


float a=3.2; int b=(int)a; // you''ll get output b=3 here; int c=(int)a-b; // you''ll get c=.2 value here


var decimal = n - Math.floor(n)

Aunque esto no funcionará para los números negativos, entonces podríamos tener que hacer

n = Math.abs(n); // Change to positive var decimal = n - Math.floor(n)