Tengo números flotantes como 3.2y 1.6.

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

Obtener la porción 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 estoy perdiendo aquí?

Uso 1, no 2.

js> 2.3 % 1
0.2999999999999998

var decimal = n - Math.floor(n)

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

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

Podrías convertir a cadena, ¿verdad?

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

¿Cómo es 0.2999999999999998 una respuesta aceptable? Si fuera el autor de la pregunta, me gustaría una respuesta de .3. Lo que tenemos aquí es precisión falsa, y mis experimentos con floor,%, etc. indican que a Javascript le gusta la precisión falsa para estas operaciones. Así que creo que las respuestas que están usando la 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".

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

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

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 el número 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

Forma independiente del idioma:

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

tenga en cuenta que solo se corrige para números con una longitud fractioanal)

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

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

O podría usar expresiones regulares como:

splitFloat = function(n){
   const regex = /(\d*)[.,]{1}(\d*)/;
   var m;

   if ((m = regex.exec(n.toString())) !== null) {
       return {
          integer:parseInt(m[1]),
          decimal:parseFloat(`0.${m[2]}`)
       }
   }
}

Lo siguiente funciona independientemente de la configuración regional para el separador decimal ... con la condición de que solo se use 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 exacto.

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

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

1. String.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.

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

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

Dependiendo del uso que le darás después, pero esta solución simple 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)

Tuve un caso en el que sabía que todos los números en cuestión solo tendrían 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 enteros, devolviendo 0 en esos casos.

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

Las funciones matemáticas son más rápidas, pero siempre devuelve valores no nativos esperados. La forma más fácil que encontré es

(3.2+'').replace(/^[-\d]+\./, '')

Una buena opción es transformar el número en una cadena y luego dividirlo.

// Decimal number
let number = 3.2;

// Convert it into a string
let string = number.toString();

// Split the dot
let array = string.split('.');

// Get both numbers
// The '+' sign transforms the string into a number again
let firstNumber  = +array[0]; // 3
let secondNumber = +array[1]; // 2

En una línea de código

let [firstNumber, secondNumber] = [+number.toString().split('.')[0], +number.toString().split('.')[1]];

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

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

n = Math.floor(x);
remainder = x % 1;

Aunque llego muy tarde para responder esto, por favor eche un vistazo al código.

let floatValue = 3.267848;
let decimalDigits = floatValue.toString().split('.')[1];
let decimalPlaces = decimalDigits.length;
let decimalDivider = Math.pow(10, decimalPlaces);
let fractionValue = decimalDigits/decimalDivider;
let integerValue = floatValue - fractionValue;

console.log("Float value: "+floatValue);
console.log("Integer value: "+integerValue);
console.log("Fraction value: "+fractionValue)

El formato de número y signo decimal de coma flotante puede depender del país ( .,), por lo que la solución independiente, que conserva la parte de coma flotante, es:

getFloatDecimalPortion = function(x) {
    x = Math.abs(parseFloat(x));
    let n = parseInt(x);
    return Number((x - n).toFixed(Math.abs((""+x).length - (""+n).length - 1)));
}

- es una solución internacionalizada, en lugar de dependiente de la ubicación:

getFloatDecimalPortion = x => parseFloat("0." + ((x + "").split(".")[1]));

Descripción de la solución paso a paso:

1. parseFloat() para garantizar la corrección de entrada
2. Math.abs() para evitar problemas con números negativos
3. n = parseInt(x) para obtener la parte decimal
4. x - n para restar parte decimal
5. Ahora tenemos un número con cero partes decimales, pero JavaScript podría darnos dígitos de partes flotantes adicionales, que no queremos
6. Por lo tanto, limite los dígitos adicionales llamando toFixed()con el recuento de dígitos en la parte flotante del número flotante original x. El recuento se calcula como la diferencia entre la longitud del número original xy el número nen su representación de cadena.

Usa este:

function isNatural(n) {
    n = +n
    if (isNaN(n)) return 'NaN';
    return (n >= 0.0) && (Math.floor(n) === n) && n !== Infinity;
  }

Math.frac = function frac(x, m) {
    x = +x
    if (isNaN(x)) return NaN;
    if (isNatural(x) === true) return 0;
    m = +m || 1

      if (isNatural(x) === false && m === 1){
        var a = x.toString()
        var b = a.split('.')[1]
        var c = '0.' + b
        var d = +c
        return d;
      }

      if (isNatural(x) === false && m === 2){
        var a = x.toString()
        var b = a.split('.')[1]
        var c = +b
        return c;
      }

      if (isNatural(x) === false && m === 3){
        var a = x.toString()
        var b = a.split('.')[1]
        var c = '0.' + b
        var d = +c * 100
        return d;
      }    
  }

La Math.fracfunción aquí tiene 3 modos:

Math.frac(11.635) //0.635
Math.frac(11.635, 1) //0.635 - default mode is 1
Math.frac(11.635, 2) //635
Math.frac(11.635, 3) //63,5 (%)

Es sencillo :)

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