JavaScript Numbers: Numeric Values, Methods, and Special Cases

const age = 25;
// integer-looking ✅
const price = 99.99;
// decimal ✅
const temp = -5;
// negative ✅
const big = 1_000_000;
// 💡 numeric separators (2021) — underscores for readability!
const hex = 0xFF;
// 255 — hexadecimal
const binary = 0b1010;
// 10 — binary
const octal = 0o17;
// 15 — octal (strict-mode safe, Lesson 36!)

const price = 19.995;
console.log(price.toFixed(2));
// "19.99" — hmm, rounds as expected hereconsole.log((0.1 + 0.2).toFixed(2)); // "0.30" — the Lesson 12 fix! ✅console.log((42).toFixed(2));     // "42.00" — padding zeros too

const n = 255;
console.log(n.toString());
// "255"
console.log(n.toString(2));
// "11111111" — binary
console.log(n.toString(16));
// "ff" — hexadecimal (CSS colors! 🎨)
// The gotcha — literal numbers need parentheses or double dots:
(255).toString(16);
// "ff" ✅
255..toString(16);
// "ff" ✅ (weird but legal!)

const pi = 3.14159;
console.log(pi.toPrecision(3));
// "3.14"
console.log((1234.5).toPrecision(2));
// "1.2e+3" — scientific notation surprise! 😮

const bad = "hello" * 2;
// NaN
console.log(bad === NaN);
// false 😱 — never works!
console.log(Number.isNaN(bad));
// true ✅ — the correct check
console.log(Number.isNaN(42));
// false

isNaN("hello");
// true 😱 — "hello" converted to NaN first!
isNaN("123");
// false — "123" converts to 123 fine
Number.isNaN("hello");
// false ✅ — "hello" is a STRING, not NaN
Number.isNaN(NaN);
// true ✅ — only true NaN passes

Number.isInteger(42);
// true ✅
Number.isInteger(42.0);
// true — 42.0 IS an integer value!
Number.isInteger(42.5);
// false
Number.isInteger("42");
// false — strings don't count ✅
Number.isFinite(42);
// true
Number.isFinite(Infinity);
// false — infinity is not finite! ♾️
Number.isFinite(NaN);
// false

console.log("hello" * 2);
// NaN
console.log(Math.sqrt(-1));
// NaN (real math says no)
console.log(parseInt("abc"));
// NaN (Lesson 9's converter giving up)
console.log(typeof NaN);
// "number" 🤡 — yes, really
console.log(NaN === NaN);
// false — the rebel that equals nothing

console.log(NaN + 5);
// NaN — any math with NaN → NaN
console.log(NaN * 0);
// NaN — even this!
// One NaN poisons a whole pipeline:
const total =[10, 20, NaN, 30].reduce((sum, n) => sum + n, 0);
console.log(total);
// NaN 💀 — the entire sum is lost

console.log(1 / 0);
// Infinity — no crash, just… infinity
console.log(-1 / 0);
// -Infinity
console.log(Number.MAX_VALUE * 2);
// Infinity — overflow goes here
console.log(Infinity > 999999999);
// true
console.log(Infinity === Infinity);
// true ✅ (unlike NaN, Infinity behaves)

console.log(-0);
// -0
console.log(-0 === 0);
// true — they compare equal
console.log(1 / -0);
// -Infinity 😮 — but division reveals it!
console.log(1 / 0);
// Infinity
// The rare detection (direction of approach matters in animations/physics):
console.log(Object.is(-0, 0));
// false — Object.is sees the difference

console.log(Number.MAX_SAFE_INTEGER);
// 9007199254740991 (about 9 quadrillion)
console.log(Number.MIN_SAFE_INTEGER);
// -9007199254740991
// Beyond the limit — precision silently breaks:
const big = Number.MAX_SAFE_INTEGER + 1;
const bigger = Number.MAX_SAFE_INTEGER + 2;
console.log(big === bigger);
// true 😱 — two different numbers became equal!

const hugeId = 9007199254740993n;
// the n suffix = BigInt
console.log(hugeId + 1n);
// 9007199254740994n — exact! ✅
console.log(typeof hugeId);
// "bigint"
// ⚠️ BigInt and Number don't mix:
console.log(1n + 2n);
// 3n ✅
console.log(1n + 2);
// ❌ TypeError — convert explicitly first!

// 🧼 Number Sanitizer — every lesson skill in one function
function sanitizeNumber(input, {
  min = -Infinity, max = Infinity, integer = false
} = {
}) {
  // ① Convert (Lesson 9):
  const num = Number(input);
  // ② Reject NaN properly (this lesson!):
  if (Number.isNaN(num)) {
    return {
      ok: false, error: `"${input}" isn't a number ❌`
    };
  } // ③ Reject non-finite:
  if (!Number.isFinite(num)) {
    return {
      ok: false, error: "Value must be finite ♾️🚫"
    };
  } // ④ Enforce integers when required:
  if (integer && !Number.isInteger(num)) {
    return {
      ok: false, error: "Whole numbers only 🔢"
    };
  } // ⑤ Clamp into range (Lesson 37's clamp idea!):
  const clamped = Math.min(Math.max(num, min), max);
  if (clamped !== num) {
    console.log(`⚠️ ${num} adjusted to ${clamped} (range ${min}–${max})`);
  } return {
    ok: true, value: clamped
  };
}console.log(sanitizeNumber("42"));
// { ok: true, value: 42 } ✅
console.log(sanitizeNumber("hello"));
// { ok: false, error: …isn't a number }
console.log(sanitizeNumber(1 / 0));
// { ok: false, error: must be finite }
console.log(sanitizeNumber(3.7, {
  integer: true
}));
// { ok: false, error: whole numbers }
console.log(sanitizeNumber(150, {
  min: 0, max: 100
}));
// adjusted to 100 ⚠️