Math Object in JavaScript: Complete Guide with Examples | JavaScript Tutorial | CodeWithMihir

Welcome back! 👋 In the previous lesson, you mastered the Date object. Now let's explore another incredibly useful built-in — the Math object!

The Math object gives you a collection of mathematical constants and functions — rounding, random numbers, powers, square roots, finding minimums and maximums, trigonometry, and more. You'll use it constantly in real projects — for pricing calculations, game logic, data visualization, animations, and UI layouts.

Unlike Date, you never use new Math() — it's a static object, meaning you call its methods directly: Math.round(), Math.random(), Math.max(), etc.

Let's master it completely!

What is the Math Object?

The Math object is a built-in JavaScript object that provides mathematical constants and functions. It is not a constructor — you use it directly without new.

console.log(Math.PI);         // 3.141592653589793
console.log(Math.round(4.7)); // 5
console.log(Math.sqrt(16));   // 4
console.log(Math.random());   // e.g. 0.7381924...

Math Constants

console.log(Math.PI);      // 3.141592653589793 — π (pi)
console.log(Math.E);       // 2.718281828459045 — Euler's number
console.log(Math.SQRT2);   // 1.4142135623730951 — √2
console.log(Math.LN2);     // 0.6931471805599453 — Natural log of 2
console.log(Math.LN10);    // 2.302585092994046  — Natural log of 10

// Most used in real projects
console.log(Math.PI);      // Circle calculations
console.log(Math.E);       // Compound interest, growth formulas

Rounding Methods

These four are the ones you'll use most often — and it's important to know the difference between them.

`Math.round()` — Round to Nearest Integer

console.log(Math.round(4.4)); // 4  (rounds down — < .5)
console.log(Math.round(4.5)); // 5  (rounds up   — >= .5)
console.log(Math.round(4.9)); // 5
console.log(Math.round(-4.5)); // -4 (rounds toward +infinity)

`Math.floor()` — Always Round Down

console.log(Math.floor(4.9)); // 4
console.log(Math.floor(4.1)); // 4
console.log(Math.floor(-4.1)); // -5 (floor goes more negative)
console.log(Math.floor(-4.9)); // -5

`Math.ceil()` — Always Round Up

console.log(Math.ceil(4.1)); // 5
console.log(Math.ceil(4.9)); // 5
console.log(Math.ceil(-4.9)); // -4 (ceil goes less negative)
console.log(Math.ceil(-4.1)); // -4

`Math.trunc()` — Remove Decimal (Truncate)

console.log(Math.trunc(4.9));  // 4  (just removes decimal)
console.log(Math.trunc(4.1));  // 4
console.log(Math.trunc(-4.9)); // -4 (removes decimal, keeps sign)
console.log(Math.trunc(-4.1)); // -4

Side by Side Comparison

let n = 4.7;

console.log(`round:  ${Math.round(n)}`);  // 5
console.log(`floor:  ${Math.floor(n)}`);  // 4
console.log(`ceil:   ${Math.ceil(n)}`);   // 5
console.log(`trunc:  ${Math.trunc(n)}`);  // 4

let neg = -4.7;

console.log(`round:  ${Math.round(neg)}`); // -5
console.log(`floor:  ${Math.floor(neg)}`); // -5
console.log(`ceil:   ${Math.ceil(neg)}`);  // -4
console.log(`trunc:  ${Math.trunc(neg)}`); // -4

When to Use Which

// Math.round()  — general rounding (ratings, averages)
let rating = Math.round(4.35); // 4

// Math.floor()  — pagination, array indexes, age from years
let page  = Math.floor(items / perPage);

// Math.ceil()   — total pages, pricing with partial units
let pages = Math.ceil(totalItems / perPage);

// Math.trunc()  — when you just want the integer part
let hours = Math.trunc(totalMinutes / 60);

`Math.random()` — Random Numbers

Math.random() returns a random decimal between 0 (inclusive) and 1 (exclusive).

console.log(Math.random()); // e.g. 0.7381924806352847
console.log(Math.random()); // e.g. 0.1204958370192384

Random Integer Between 0 and N

// 0 to 9
let rand = Math.floor(Math.random() * 10);
console.log(rand); // 0, 1, 2, ... 9

Random Integer Between Min and Max (Inclusive)

function randomInt(min, max) {
  return Math.floor(Math.random() * (max - min + 1)) + min;
}

console.log(randomInt(1, 6));   // Dice roll: 1–6
console.log(randomInt(1, 100)); // 1–100
console.log(randomInt(18, 65)); // Random age range

Random Float Between Min and Max

function randomFloat(min, max) {
  return Math.random() * (max - min) + min;
}

console.log(randomFloat(0, 1).toFixed(2));    // 0.00–1.00
console.log(randomFloat(1.5, 4.5).toFixed(1)); // e.g. 3.2

Random Item from Array

function randomItem(array) {
  return array[Math.floor(Math.random() * array.length)];
}

let fruits  = ["Apple", "Banana", "Mango", "Orange", "Grapes"];
let colors  = ["Red", "Green", "Blue", "Yellow"];

console.log(randomItem(fruits)); // e.g. "Mango"
console.log(randomItem(colors)); // e.g. "Blue"

Shuffle an Array (Fisher-Yates)

function shuffle(array) {
  let arr = [...array]; // copy — don't mutate original
  for (let i = arr.length - 1; i > 0; i--) {
    let j = Math.floor(Math.random() * (i + 1));
    [arr[i], arr[j]] = [arr[j], arr[i]]; // swap
  }
  return arr;
}

let deck = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
console.log(shuffle(deck)); // e.g. [4, 9, 2, 7, 1, 6, 10, 3, 8, 5]

Min and Max

`Math.min()` — Smallest Value

console.log(Math.min(3, 1, 4, 1, 5, 9)); // 1
console.log(Math.min(10, 20, 5, 8));      // 5

// With an array — use spread
let scores = [85, 92, 78, 60, 95, 55];
console.log(Math.min(...scores)); // 55

`Math.max()` — Largest Value

console.log(Math.max(3, 1, 4, 1, 5, 9)); // 9
console.log(Math.max(10, 20, 5, 8));      // 20

// With an array — use spread
let scores = [85, 92, 78, 60, 95, 55];
console.log(Math.max(...scores)); // 95

Clamp a Value Between Min and Max

function clamp(value, min, max) {
  return Math.min(Math.max(value, min), max);
}

console.log(clamp(15, 0, 10));  // 10 (too high — clamped to max)
console.log(clamp(-5, 0, 10));  // 0  (too low  — clamped to min)
console.log(clamp(7,  0, 10));  // 7  (within range — unchanged)

Power and Roots

`Math.pow(base, exponent)` — Power

console.log(Math.pow(2, 10));  // 1024
console.log(Math.pow(3, 3));   // 27
console.log(Math.pow(9, 0.5)); // 3  (square root)

// ✅ Modern alternative — exponentiation operator **
console.log(2 ** 10); // 1024
console.log(3 ** 3);  // 27

`Math.sqrt()` — Square Root

console.log(Math.sqrt(25));  // 5
console.log(Math.sqrt(2));   // 1.4142135623730951
console.log(Math.sqrt(144)); // 12

`Math.cbrt()` — Cube Root

console.log(Math.cbrt(27));  // 3
console.log(Math.cbrt(125)); // 5
console.log(Math.cbrt(8));   // 2

`Math.hypot()` — Hypotenuse (Distance Formula)

// Distance between two points (x1,y1) and (x2,y2)
function distance(x1, y1, x2, y2) {
  return Math.hypot(x2 - x1, y2 - y1);
}

console.log(distance(0, 0, 3, 4).toFixed(2)); // 5.00
console.log(distance(1, 1, 4, 5).toFixed(2)); // 5.00

Absolute Value and Sign

`Math.abs()` — Absolute Value

console.log(Math.abs(-5));   // 5
console.log(Math.abs(5));    // 5
console.log(Math.abs(-3.7)); // 3.7

// Practical: distance between two numbers
function diff(a, b) {
  return Math.abs(a - b);
}

console.log(diff(10, 25)); // 15
console.log(diff(25, 10)); // 15

`Math.sign()` — Is it Positive, Negative, or Zero?

console.log(Math.sign(10));  //  1 (positive)
console.log(Math.sign(-5));  // -1 (negative)
console.log(Math.sign(0));   //  0 (zero)

// Practical: direction of movement
function direction(value) {
  return ["Decreasing", "Zero", "Increasing"][Math.sign(value) + 1];
}

console.log(direction(5));  // "Increasing"
console.log(direction(-3)); // "Decreasing"
console.log(direction(0));  // "Zero"

Logarithms

console.log(Math.log(Math.E));  // 1   — natural log
console.log(Math.log2(8));      // 3   — log base 2
console.log(Math.log10(1000));  // 3   — log base 10

// Practical: how many digits in a number?
function digitCount(n) {
  return Math.floor(Math.log10(Math.abs(n))) + 1;
}

console.log(digitCount(5));       // 1
console.log(digitCount(99));      // 2
console.log(digitCount(1000));    // 4
console.log(digitCount(1000000)); // 7

Real-World Examples

Example 1: Price Calculator with Rounding

function calculateOrder(items, taxRate = 0.18, discount = 0) {
  let subtotal = items.reduce((sum, item) => sum + item.price * item.qty, 0);
  let discountAmt = Math.round(subtotal * discount);
  let afterDiscount = subtotal - discountAmt;
  let tax = Math.round(afterDiscount * taxRate);
  let total = afterDiscount + tax;

  return {
    subtotal:  subtotal,
    discount:  discountAmt,
    tax:       tax,
    total:     total,
    perItem:   Math.ceil(total / items.reduce((s, i) => s + i.qty, 0)),
  };
}

let order = calculateOrder([
  { name: "Laptop",  price: 55000, qty: 1 },
  { name: "Mouse",   price: 800,   qty: 2 },
  { name: "Bag",     price: 1200,  qty: 1 },
], 0.18, 0.10);

console.log("=== 🧾 Order Summary ===");
console.log(`Subtotal:  ₹${order.subtotal.toLocaleString()}`);
console.log(`Discount:  ₹${order.discount.toLocaleString()}`);
console.log(`Tax (18%): ₹${order.tax.toLocaleString()}`);
console.log(`TOTAL:     ₹${order.total.toLocaleString()}`);
console.log(`Per Item:  ₹${order.perItem.toLocaleString()}`);

Example 2: Statistics Calculator

function calcStats(numbers) {
  let n      = numbers.length;
  let sum    = numbers.reduce((s, n) => s + n, 0);
  let mean   = sum / n;
  let sorted = [...numbers].sort((a, b) => a - b);
  let median = n % 2 === 0
    ? (sorted[n/2 - 1] + sorted[n/2]) / 2
    : sorted[Math.floor(n/2)];

  // Standard deviation
  let variance = numbers.reduce((s, x) => s + Math.pow(x - mean, 2), 0) / n;
  let stdDev   = Math.sqrt(variance);

  return {
    min:    Math.min(...numbers),
    max:    Math.max(...numbers),
    sum:    sum,
    mean:   Math.round(mean * 100) / 100,
    median: median,
    range:  Math.max(...numbers) - Math.min(...numbers),
    stdDev: Math.round(stdDev * 100) / 100,
  };
}

let scores = [85, 92, 78, 60, 95, 72, 88, 55, 90, 76];
let stats = calcStats(scores);

console.log("=== 📊 Statistics ===");
for (let [key, val] of Object.entries(stats)) {
  console.log(`  ${key.padEnd(8)}: ${val}`);
}
// Output:
// min     : 55
// max     : 95
// sum     : 791
// mean    : 79.1
// median  : 82
// range   : 40
// stdDev  : 12.72

Example 3: Random Quiz Generator

let questions = [
  { q: "What is the capital of India?",      a: "New Delhi"   },
  { q: "What is 15 × 15?",                   a: "225"         },
  { q: "Who invented JavaScript?",           a: "Brendan Eich"},
  { q: "What does HTML stand for?",          a: "HyperText Markup Language" },
  { q: "What is the square root of 144?",    a: "12"          },
  { q: "Which planet is closest to the Sun?", a: "Mercury"    },
];

function generateQuiz(allQuestions, count = 3) {
  // Shuffle and take first 'count' questions
  let shuffled = [...allQuestions]
    .sort(() => Math.random() - 0.5)
    .slice(0, count);

  console.log("=== 🎯 Random Quiz ===");
  shuffled.forEach(({ q, a }, i) => {
    console.log(`Q${i + 1}: ${q}`);
    console.log(`     Answer: ${a}\n`);
  });
}

generateQuiz(questions, 3);

Example 4: Color Generator

function randomHexColor() {
  let r = Math.floor(Math.random() * 256);
  let g = Math.floor(Math.random() * 256);
  let b = Math.floor(Math.random() * 256);
  return `#${r.toString(16).padStart(2,"0")}${g.toString(16).padStart(2,"0")}${b.toString(16).padStart(2,"0")}`;
}

function randomRGBA(alpha = 1) {
  let r = randomInt(0, 255);
  let g = randomInt(0, 255);
  let b = randomInt(0, 255);
  let a = Math.round(alpha * 100) / 100;
  return `rgba(${r}, ${g}, ${b}, ${a})`;
}

function randomInt(min, max) {
  return Math.floor(Math.random() * (max - min + 1)) + min;
}

console.log("=== 🎨 Random Colors ===");
for (let i = 0; i < 5; i++) {
  console.log(`HEX:  ${randomHexColor()}`);
  console.log(`RGBA: ${randomRGBA(0.8)}\n`);
}

Example 5: Pagination Calculator

function paginate(totalItems, currentPage, perPage = 10) {
  let totalPages  = Math.ceil(totalItems / perPage);
  let startItem   = (currentPage - 1) * perPage + 1;
  let endItem     = Math.min(currentPage * perPage, totalItems);
  let hasPrev     = currentPage > 1;
  let hasNext     = currentPage < totalPages;

  return { totalPages, startItem, endItem, hasPrev, hasNext };
}

let { totalPages, startItem, endItem, hasPrev, hasNext } = paginate(237, 3, 10);

console.log(`Total Pages : ${totalPages}`);
console.log(`Showing     : Items ${startItem}–${endItem}`);
console.log(`Prev Page   : ${hasPrev ? "✅" : "❌"}`);
console.log(`Next Page   : ${hasNext ? "✅" : "❌"}`);
// Output:
// Total Pages : 24
// Showing     : Items 21–30
// Prev Page   : ✅
// Next Page   : ✅

Math Methods Cheat Sheet

Method	What it does	Example
`Math.round(n)`	Round to nearest	`Math.round(4.5)` → `5`
`Math.floor(n)`	Round down	`Math.floor(4.9)` → `4`
`Math.ceil(n)`	Round up	`Math.ceil(4.1)` → `5`
`Math.trunc(n)`	Remove decimal	`Math.trunc(4.9)` → `4`
`Math.random()`	`0` to `<1` random	`Math.random()` → `0.732...`
`Math.min(...n)`	Smallest value	`Math.min(3,1,4)` → `1`
`Math.max(...n)`	Largest value	`Math.max(3,1,4)` → `4`
`Math.abs(n)`	Absolute value	`Math.abs(-5)` → `5`
`Math.pow(b,e)`	Power	`Math.pow(2,8)` → `256`
`Math.sqrt(n)`	Square root	`Math.sqrt(25)` → `5`
`Math.cbrt(n)`	Cube root	`Math.cbrt(27)` → `3`
`Math.hypot(a,b)`	Hypotenuse	`Math.hypot(3,4)` → `5`
`Math.sign(n)`	-1, 0, or 1	`Math.sign(-5)` → `-1`
`Math.log10(n)`	Log base 10	`Math.log10(1000)` → `3`
`Math.log2(n)`	Log base 2	`Math.log2(8)` → `3`
`Math.PI`	π	`3.14159...`
`Math.E`	Euler's number	`2.71828...`

Common Mistakes

Mistake 1: Using `Math.round()` for Currency (Use Banker's Rounding Instead)

// ❌ Floating point + rounding can give wrong results
console.log(Math.round(1.005 * 100) / 100); // 1 instead of 1.01!

// ✅ Use toFixed then parseFloat for currency
let price = 1.005;
console.log(parseFloat(price.toFixed(2))); // 1.01 ✅

// ✅ Or work in paise/cents (integers) to avoid float issues entirely
let priceInPaise = 10050; // ₹100.50 stored as 10050 paise

Mistake 2: `Math.random()` is Not Truly Random

// ⚠️ Math.random() is pseudorandom — NOT cryptographically secure
// ❌ Don't use for security-sensitive things like tokens or OTPs
let otp = Math.floor(Math.random() * 900000) + 100000; // insecure!

// ✅ For security, use the Web Crypto API
let secureRandom = crypto.getRandomValues(new Uint32Array(1))[0];

Mistake 3: Forgetting Spread for `Math.min/max` with Arrays

let scores = [85, 92, 78, 60, 95];

// ❌ Passing array directly — returns NaN
console.log(Math.max(scores)); // NaN ❌

// ✅ Spread the array
console.log(Math.max(...scores)); // 95 ✅

// ✅ Or use reduce
console.log(scores.reduce((max, n) => n > max ? n : max, scores[0])); // 95 ✅

Mistake 4: `Math.round()` vs `toFixed()` — Different Results

let n = 4.567;

// Math.round — returns an integer
console.log(Math.round(n));     // 5 (integer)

// toFixed — returns a string with fixed decimals
console.log(n.toFixed(2));      // "4.57" (string!)
console.log(typeof n.toFixed(2)); // "string"

// ✅ When you need a rounded number with decimals
console.log(Math.round(n * 100) / 100); // 4.57 (number) ✅
console.log(parseFloat(n.toFixed(2)));  // 4.57 (number) ✅

Practical Exercise

Create a file called math-object.js:

// 🎯 Math Object Practice

// 1. Rounding explorer
console.log("=== 🔢 Rounding Methods ===");
let values = [1.1, 1.5, 1.9, -1.1, -1.5, -1.9];

console.log("Value   round  floor  ceil   trunc");
console.log("─".repeat(40));
values.forEach(n => {
  console.log(
    `${String(n).padEnd(8)}` +
    `${String(Math.round(n)).padEnd(7)}` +
    `${String(Math.floor(n)).padEnd(7)}` +
    `${String(Math.ceil(n)).padEnd(7)}` +
    `${Math.trunc(n)}`
  );
});


// 2. Random game — number guessing (single round simulation)
console.log("\n=== 🎲 Random Utilities ===");
function randomInt(min, max) {
  return Math.floor(Math.random() * (max - min + 1)) + min;
}

// Dice roll simulator
let rolls = Array.from({ length: 10 }, () => randomInt(1, 6));
console.log(`10 dice rolls: ${rolls.join(", ")}`);
console.log(`Sum: ${rolls.reduce((s, n) => s + n, 0)}`);
console.log(`Max: ${Math.max(...rolls)} | Min: ${Math.min(...rolls)}`);

// Random OTP
let otp = Array.from({ length: 6 }, () => randomInt(0, 9)).join("");
console.log(`Random OTP: ${otp}`);

// Random team splitter
let team = ["Mihir", "Priya", "Rahul", "Sara", "Arjun", "Neha"];
let shuffled = [...team].sort(() => Math.random() - 0.5);
let teamA = shuffled.slice(0, 3);
let teamB = shuffled.slice(3);
console.log(`Team A: ${teamA.join(", ")}`);
console.log(`Team B: ${teamB.join(", ")}`);


// 3. Geometry calculator
console.log("\n=== 📐 Geometry ===");
function circle(radius) {
  return {
    area:        Math.round(Math.PI * radius ** 2 * 100) / 100,
    circumference: Math.round(2 * Math.PI * radius * 100) / 100,
  };
}

function rectangle(w, h) {
  return {
    area:      w * h,
    perimeter: 2 * (w + h),
    diagonal:  Math.round(Math.hypot(w, h) * 100) / 100,
  };
}

function triangle(a, b, c) {
  let s    = (a + b + c) / 2;
  let area = Math.round(Math.sqrt(s * (s-a) * (s-b) * (s-c)) * 100) / 100;
  return { area, perimeter: a + b + c };
}

let c = circle(7);
console.log(`Circle (r=7):     Area=${c.area}, Circumference=${c.circumference}`);

let r = rectangle(10, 6);
console.log(`Rectangle 10×6:   Area=${r.area}, Perimeter=${r.perimeter}, Diagonal=${r.diagonal}`);

let t = triangle(3, 4, 5);
console.log(`Triangle 3-4-5:   Area=${t.area}, Perimeter=${t.perimeter}`);

Run it:

node math-object.js

Expected Output:

=== 🔢 Rounding Methods ===
Value   round  floor  ceil   trunc
────────────────────────────────────────
1.1     1      1      2      1
1.5     2      1      2      1
1.9     2      1      2      1
-1.1    -1     -2     -1     -1
-1.5    -1     -2     -1     -1
-1.9    -2     -2     -1     -1

=== 🎲 Random Utilities ===
10 dice rolls: 3, 6, 1, 4, 2, 5, 3, 6, 1, 4
Sum: 35
Max: 6 | Min: 1
Random OTP: 847291
Team A: Priya, Arjun, Mihir
Team B: Sara, Rahul, Neha

=== 📐 Geometry ===
Circle (r=7):     Area=153.94, Circumference=43.98
Rectangle 10×6:   Area=60, Perimeter=32, Diagonal=11.66
Triangle 3-4-5:   Area=6, Perimeter=12

Key Takeaways

Congratulations! 🎉 You now have a complete toolkit for mathematical operations in JavaScript.

✅ Math is static — never use new Math(). Call methods directly: Math.round(), Math.max(), etc.

✅ 4 rounding methods:

Math.round() — nearest integer (≥.5 rounds up)
Math.floor() — always down
Math.ceil() — always up
Math.trunc() — just removes decimal

✅ Math.random() — returns 0 to <1. Use Math.floor(Math.random() * n) for integers.

✅ Math.min(...arr) / Math.max(...arr) — always spread arrays!

✅ Math.abs() — absolute value, perfect for differences.

✅ Math.pow(b, e) or b ** e — exponentiation. Math.sqrt() for square root.

✅ Math.PI — π for all circle/arc calculations.

Best Practices

✅ Use Math.floor(Math.random() * (max - min + 1)) + min — the standard random integer formula
✅ Always spread arrays when using Math.min() / Math.max() — never pass array directly
✅ Use ** (exponentiation operator) instead of Math.pow() — cleaner in modern JS
✅ For currency rounding, use Math.round(n * 100) / 100 — avoids float issues
✅ Use Math.abs() for unsigned differences — order of subtraction doesn't matter
✅ Use Math.ceil() for total pages and similar "round up" scenarios
✅ Use Math.floor() for array indexes, ages, and anything that should never overshoot
✅ Never use Math.random() for security-sensitive operations — use crypto.getRandomValues()

What's Next?

Great work! 🎉 You now have a complete understanding of JavaScript's Math object.

Next up, let's explore the Number built-in object:

Number → — JavaScript's Number object, number formatting, precision, isNaN, isFinite, parseInt, parseFloat, toFixed, and everything about how numbers work under the hood!

Let's keep going! 💪