I have float numbers like `3.2`

and `1.6`

.

I need to separate the number into the integer and decimal part. For example, a value of `3.2`

would be split into two numbers, i.e. `3`

and `0.2`

Getting the integer portion is easy:

```
n = Math.floor(n);
```

But I am having trouble getting the decimal portion. I have tried this:

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

But it does not always work correctly.

The previous code has the following output:

```
n = 3.1 => remainer = 1.1
```

What I am missing here?

javascriptfloating-pointnumbersdecimalrounding answered 8 years ago Ignacio Vazquez-Abrams #1

Use `1`

, not `2`

.

```
js> 2.3 % 1
0.2999999999999998
```

answered 8 years ago greenimpala #2

```
var decimal = n - Math.floor(n)
```

Although this won't work for minus numbers so we might have to do

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

answered 8 years ago sdleihssirhc #3

You could convert to string, right?

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

answered 5 years ago gion_13 #4

You could convert it to a string and use the `replace`

method to replace the integer part with zero, then convert the result back to a number :

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

answered 5 years ago user2381223 #5

```
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
```

answered 4 years ago jomofrodo #6

How is 0.2999999999999998 an acceptable answer? If I were the asker I would want an answer of .3. What we have here is false precision, and my experiments with floor, %, etc indicate that Javascript is fond of false precision for these operations. So I think the answers that are using conversion to string are on the right track.

I would do this:

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

Specifically, I was using 100233.1 and I wanted the answer ".1".

answered 4 years ago David Sánchez #7

Depending the usage you will give afterwards, but this simple solution could also help you.

Im not saying its a good solution, but for some concrete cases works

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

But it will take longer than the proposed solution by @Brian M. Hunt

```
(2.3 % 1).toFixed(4)
```

answered 3 years ago cdmdotnet #8

The following works regardless of the regional settings for decimal separator... on the condition only one character is used for a separator.

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

It ain't pretty, but it's accurate.

answered 2 years ago Nurlan #9

Language independent way:

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

note that it correct only for numbers with one fractioanal lenght )

answered 2 years ago walpek #10

I had a case where I knew all the numbers in question would have only one decimal and wanted to get the decimal portion as an integer so I ended up using this kind of approach:

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

This works nicely also with integers, returning 0 in those cases.

answered 2 years ago Patrick #11

After looking at several of these, I am now using...

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

answered 2 years ago Booligoosh #12

A simple way of doing it is:

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

Unfortunately, that doesn't return the exact value. However, that is easily fixed:

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

You can use this if you don't know the number of decimal places:

```
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
```

answered 1 year ago Zantafio #13

Here's how I do it, which I think is the most straightforward way to do it:

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

answered 11 months ago Gabriel Hautclocq #14

If precision matters and you require consistent results, here are a few propositions that will return the decimal part of any number as a string, including the leading "0.". If you need it as a float, just add `var f = parseFloat( result )`

in the end.

If the decimal part equals zero, "0.0" will be returned. Null, NaN and undefined numbers are not tested.

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

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

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

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

Here is a jsPerf link: https://jsperf.com/decpart-of-number/

We can see that proposition #2 is the fastest.

answered 7 months ago DavidDunham #15

I am using:

```
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]);
}
```

Input: -556.123444444

Result: **123444444**

answered 5 months ago Sheki #16

You can use `parseInt()`

function to get the integer part than use that to extract the decimal part

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