You might not have thought of:

• Math.floor(NaN) == NaN (ok, not really, but Math.floor(NaN) is NaN)
• Math.floor(NaN) | 0 == 0

Also relevant for Infinity

As pointed out by @apsillers, this is probabably to eliminate Infinitys:

var x = 1;
console.log(Math.floor(1 / x));      // 1
console.log(Math.floor(1 / x) | 0);  // 1
x = 0;
console.log(Math.floor(1 / x));      // Infinity
console.log(Math.floor(1 / x) | 0);  // 0

Small correction to Britton's answer, Math.random() returns a floating number in the range [0,1). That is including zero and anything up to 1, but not 1 itself. This is where the confusion lies. Source. (https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/random) What you're thinking... Suppose random did return "numbers between 0 and 1". That is any number from 0 to 1, including 0 and 1. Let's try plugging in these values into the dice roll using ceil and see what happens. Using the lowest number: 0 = Math.ceil(Math.Random() * 6) + 1 = Math.ceil(0 * 6) + 1 = Math.ceil(0) + 1 = 0 + 1 = 1 Using the highest number: 1 = Math.ceil(Math.Random() * 6) + 1 = Math.ceil(1 * 6) + 1 = Math.ceil(6) + 1 = 6 + 1 = 7 By these methods plugging random numbers between 0 and 1 into the dice roll returns: {1, 2, 3, 4, 5, 6, 7}. Notice the extra number: 7. Since at both extremes you're dealing with whole numbers, ceil and floor would give the same result. We're going to ignore these results because once again, random returns [0,1). Let's try this number range and see how ceil would work. What really happens... Using the lowest number: 0 = Math.ceil(Math.Random() * 6) + 1 = Math.ceil(0 * 6) + 1 = Math.ceil(0) + 1 = 0 + 1 = 1 Using a high number: 0.99999 = Math.ceil(Math.Random() * 6) + 1 = Math.ceil(0.99999 * 6) + 1 = Math.ceil(5.99994) + 1 = 6 + 1 = 7 Once again we received 7 possible outputs. The problem was with the upper end and this is where floor and ceil differ. Because we are dealing with 0.999 instead of 1, floor will return 5 and ceil will return 6. That's why we need floor here. What works... Using the lowest number: 0 = Math.floor(Math.Random() * 6) + 1 = Math.floor(0 * 6) + 1 = Math.floor(0) + 1 = 0 + 1 = 1 Using a high number: 0.99999 = Math.floor(Math.Random() * 6) + 1 = Math.floor(0.99999 * 6) + 1 = Math.floor(5.99994) + 1 = 5 + 1 = 6 Here we get {1,2,3,4,5,6}. This is what we wanted. Bingo!

var sec = Math.floor((duration / 1000) % 60);

(217 / 1000) % 60 = 0.217

The floor value of 0.217 is 0.

Here's your function:

function slipFloor(num){
  let f = Math.floor(num);
  if(num-f < 0.5){
    return f;
  }
  return f+0.5;
}
console.log(slipFloor(10.55));
console.log(slipFloor(10.99));
console.log(slipFloor(10.2));

The +.5 helps to round it to the nearest whole number. For argument’s sake, let’s say we want to round 9.2 to the nearest integer. We can add 0.5 to it, which will give 9.7. When we use math.floor on it, which will round down, we will get 9. Now, say we want to round 9.9 to the nearest integer, we …

No, in fact this line of code outputs 0:

 Math.floor(0.9);

Math.floor always rounds to the nearest whole number that is smaller than your input. You might confuse it with Math.round, that rounds to nearest whole number.

This is why this code always outputs 1 or 0, since input never gets to 2 or bigger:

Math.floor(Math.random()*2)

There's actually three different rounding functions in JavaScript: Math.floor, its opposite Math.ceil and the "usual" Math.round.

These work like this:

Math.floor(0.1); // Outputs 0
Math.ceil(0.1); // Outputs 1
Math.round(0.1); // Outputs 0

Math.floor(0.9); // Outputs 0
Math.ceil(0.9); // Outputs 1
Math.round(0.9); // Outputs 1

Math.floor(0.5); // Outputs 0
Math.ceil(0.5); // Outputs 1
Math.round(0.5); // Outputs 1