How to practically and humorously perform an integer division, and separately get the remainder, in JavaScript?

The 'Integer Division and Remainders' toolbox 🧰

When handling integer division in JavaScript with finesse, you've got a range of tools at your disposal, crafted especially for both positive and negative numbers.

Positive numbers? Easy-peasy! 🍋

Got positive numbers on set? The truncate-whiz ~~(a / b) or (a / b) >> 0 can fancy you an integer in no time! Sleep easy knowing these tools work thanks to bitwise operations:

let jollyQuotient = ~~(10 / 3); // 3, as merry as Santa's Ho-Ho-Hos! 🎅
let alternativeQuot = (10 / 3) >> 0; // 3, Slide to the quotient, easy!


For quick truncation, a / b | 0 takes the cake:

let quickQuot = 10 / 3 | 0; // So fast you'll forget it was division. 😄


For both positive and negative numbers, you have good old Math.trunc(y/x). Incorporating fraction removal and a taste for numbers larger than 2^31:

let quotientPosNeg = Math.trunc(10 / 3), Math.trunc(-10 / 3); // -3, it loves numbers of all signs, akin to a numerical hippie 🌻.


Covering all number types, without the fear of overflowing 🏞️

Fear not large numbers! For numbers that look scarier than a horror movie, employ Math functions:

let jumboQuotient = Math.floor(2147483649 / 3); // 715827883, it's large and in charge! 💪


Having negative dividends? Well, Math.floor(a/b) has got you covered, rounding down to the nearest less negative number:

let quotientNeg = Math.floor(-10 / 3); // -4, comforts negative numbers by rounding them down. 🥺


Need both quotient and remainder, pronto?

Try the swift (a - a % b) / b. It first side-eyes the remainder, then runs to compute the integer quotient:

let quickCombine = (10 - (10 % 3)) / 3; // 3, quick on its feet, like a quota-enthusiast ninja 🐱‍👤


Pick your choice: fast/consistent 🐇/🐢

Choosing between functions like Math.floor and bitwise, you're choosing consistency across number ranges or performance within 32-bit range. Stylish ~~ operation is perfect for the latter:

let snappyQuotient = ~~(10 / 3); // 3, faster than a hare in a vegetable garden! 🥕


Remember, always design your performance testing to match the specifics of your use-case for foolproof results.

Modern JavaScript's Math.trunc love

ES6 introduced Math.trunc(). It's like your good old barber, but for numbers. A fraction trim, anyone?

let hipsterQuotient = Math.trunc(10 / 3); // 3, Trunc'd to perfection!


To pop out remainders, % is your classic, simple, and timeless choice:

let hipsterRemainder = 10 % 3; // 1, the 'mod(ern) op(erator)' enjoying the remainder of its day. 😎


Working around edge cases

When doing integer division and finding remainders, be aware of some gotchas.

Zero handling

Dividing by zero will give you Infinity or -Infinity, and modulo % by zero will result in NaN:

let zeroTrouble = 10 / 0; // Infinity, defying the laws of Maths! 🙃
let moduloZeroMishap = 10 % 0; // NaN, even JS is puzzled! 🤔


Floating-point blues

JS numbers are of type floating-point. So, sometimes, operations might give you rounding errors:

let failedFloat = Math.floor((0.1 + 0.2) / 0.1); // 2, Afloat in the sea of approximations 🌊


JS numbers' safe limits

Numbers can be safely represented between -(2^53 - 1) and 2^53 - 1. Beyond this, things might start to get inconsistent.

Decimal input handling

When your inputs are decimal numbers, using Math.floor() might not be your best bet. Instead, consider Math.trunc() or explicit rounding methods for a more contained output.