I am making a function that receives a positive number and then rounds the number to the closest integer bellow it.
I have been using Math.floor
, but recently I discovered Math.trunc
.
I am aware that both will return the same value, given a positive number, and that they work in completely different ways. I am interested in exploring this behavior.
Math. trunc rounds down a number to an integer towards 0 while Math. floor rounds down a number to an integer towards -Infinity . As illustrated with the following number line, the direction will be the same for a positive number while for a negative number, the directions will be the opposite.
Definition of floor R function: The floor function rounds a numeric input down to the next lower integer. Definition of trunc R function: The trunc function truncates (i.e. cuts off) the decimal places of a numeric input.
The Math. trunc() method returns the integer part of a number. The Math. trunc() method removes the decimals (does NOT round the number).
“javascript opposite of floor” Code Answer'sceil(x); //This equals the next whole number after x.
Actually, there is much more alternative ways to remove the decimals from a number. But it's a tradeoff of readability and speed.
Choosing the right one depends on what you need. If you just need to just remove decimals, always use trunc()
or bitwise operators.
The floor()
, ceil()
and round()
are conceptually very different from trunc()
.
You already know these. Always use them in a standard, non-critical code.
var v = 3.14; [Math.trunc(v), Math.round(v), Math.floor(v), Math.ceil(v)] // prints results
for different input values you get these results
v t r f c 3.87 : [ 3, 4, 3, 4] 3.14 : [ 3, 3, 3, 4] -3.14 : [-3, -3, -4, -3] -3.87 : [-3, -4, -4, -3]
Math.trunc()
cuts away (truncates) the decimal places.Math.round()
rounds towards closest integer number.Math.floor()
rounds towards closest lower integer number. 3.5 -> 3
-3.5 -> -4
Math.ceil()
rounds towards closest higher integer number. 3.5 -> 4
-3.5 -> -3
But this is more fun :)
If you look at them in the code, it might not be apparent from the first glance what they do, so don't use them in normal code. Though in some cases, they might be useful. For example calculating coordinates in a <canvas/>
. They are much faster, but come with limitations.
ATTENTION:
Numbers with more than 32 bits get their most significant (leftmost) bits discarded and the leftmost bit becomes the new sign bit.[ 0b011100110111110100000000000000110000000000001, // 15872588537857 ~~0b011100110111110100000000000000110000000000001, // -1610588159 ~~0b10100000000000000110000000000001, // -1610588159 ]
value
to be shifted and a number
of bit positions to shift the value
by.However, when truncating, we always use a 0
, zero, a false
as a second operand, that doesn't do anything to the original value, except for converting to integer, in these cases:
~
NOT ~~v
|
OR v | 0
<<
Left shift v << 0
>>
Signed right shift v >> 0
>>>
Zero-fill right shift v >>> 0
var v = 3.78; [ ~~v , v | 0 , v << 0 , v >> 0 , v >>> 0 ] // prints these results 3.78 : [ 3, 3, 3, 3, 3] 3.14 : [ 3, 3, 3, 3, 3] -3.74 : [-3, -3, -3, -3, 4294967293] -3.14 : [-3, -3, -3, -3, 4294967293]
https://jsperf.com/number-truncating-methods/1
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With