## How can I remove the decimal part from JavaScript number?

I have the results of a division and I wish to discard the decimal portion of the resultant number.

How can I do this?

## Solutions/Answers:

### Solution 1:

You could use…

`Math.trunc()`

(truncate fractional part, also see below)`Math.floor()`

(round down)`Math.ceil()`

(round up)`Math.round()`

(round to nearest integer)

…dependent on how you wanted to remove the decimal.

`Math.trunc()`

isn’t supported on all platforms yet (namely IE), but you could easily use a polyfill in the meantime.

Another method of truncating the fractional portion with excellent platform support is by using a bitwise operator (.e.g `|0`

). The side-effect of using a bitwise operator on a number is it will treat its operand as a signed 32bit integer, therefore removing the fractional component. Keep in mind this will also mangle numbers larger than 32 bits.

You may also be talking about the inaccuracy of decimal rounding with floating point arithmetic.

Required Reading – What Every Computer Scientist Should Know About Floating-Point Arithmetic.

### Solution 2:

You could also do

```
parseInt(a/b)
```

### Solution 3:

You can also use bitwise operators to truncate the decimal.

e.g.

```
var x = 9 / 2;
console.log(x); // 4.5
x = ~~x;
console.log(x); // 4
x = -3.7
console.log(~~x) // -3
console.log(x | 0) // -3
console.log(x << 0) // -3
```

Bitwise operations are considerably more efficient than the Math functions. The double not bitwise operator also seems to slightly outperform the `x | 0`

and `x << 0`

bitwise operations by a negligible amount.

```
// 952 milliseconds
for (var i = 0; i < 1000000; i++) {
(i * 0.5) | 0;
}
// 1150 milliseconds
for (var i = 0; i < 1000000; i++) {
(i * 0.5) << 0;
}
// 1284 milliseconds
for (var i = 0; i < 1000000; i++) {
Math.trunc(i * 0.5);
}
// 939 milliseconds
for (var i = 0; i < 1000000; i++) {
~~(i * 0.5);
}
```

Also worth noting is that the bitwise not operator takes precedence over arithmetic operations, so you may need to surround calculations with parentheses to have the intended result:

```
x = -3.7
console.log(~~x * 2) // -6
console.log(x * 2 | 0) // -7
console.log(x * 2 << 0) // -7
console.log(~~(x * 2)) // -7
console.log(x * 2 | 0) // -7
console.log(x * 2 << 0) // -7
```

More info about the double bitwise not operator can be found at Double bitwise NOT (~~)

### Solution 4:

u can also show a certain number of digit after decimal point(here 2 digits) using following code :

```
var num = (15.46974).toFixed(2)
console.log(num) // 15.47
console.log(typeof num) // string
```

### Solution 5:

Use `Math.round()`

.

(Alex’s answer is better; I made an assumption ðŸ™‚

### Solution 6:

Use `Math.round()`

function.

```
Math.round(65.98) // will return 66
Math.round(65.28) // will return 65
```