1. Doing Math in JavaScript

Unlike languages with separate int and float types, JavaScript uses a single primitive number type (64-bit double precision floating point) for both integers and decimal numbers.

2. Why It Matters

Beyond standard addition (+), subtraction (-), multiplication (*), and division (/), the modulo operator (%) is a fundamental tool for checking number divisibility, determining even/odd states, and cycling indices in round-robin loops.

3. The Modulo Operator (%)

The modulo operator returns the remainder left over when one integer is divided by another:

const remainder = 10 % 3;
console.log(remainder); // 1 (10 divided by 3 is 3, with 1 left over)

// Checking if a number is even or odd
function isEven(num) {
  return num % 2 === 0;
}

console.log(isEven(4)); // true
console.log(isEven(7)); // false

4. Useful Math Utility Functions

JavaScript provides a built-in Math object for common mathematical operations:

console.log(Math.round(4.7)); // 5 (Round to nearest integer)
console.log(Math.floor(4.9)); // 4 (Round down)
console.log(Math.ceil(4.1));  // 5 (Round up)
console.log(Math.max(10, 20, 5)); // 20
console.log(Math.min(10, 20, 5)); // 5

5. Common Mistakes

• Floating Point Precision Quirk (0.1 + 0.2): Because computers store numbers in binary (base-2), fractional decimals cannot always be represented with exact precision. In JavaScript, 0.1 + 0.2 evaluates to 0.30000000000000004. For monetary/currency calculations, always work in whole cents before converting to dollars!
• Not Checking for NaN: Operations like "hello" * 5 return NaN. NaN is the only value in JavaScript that is NOT equal to itself (NaN === NaN is false!). Use Number.isNaN(val) to check for invalid numbers.

6. Try It Yourself

Write it yourself. The tests below run against your code.

function isEven(num) {
  return false;
}

7. Next Steps

Use % whenever you need to check divisibility or cyclical limits. Next, let's explore how boolean logic drives application decision making!