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)