8.1 JavaScript Numbers & 64-Bit Float Architecture

Unlike languages with distinct integer (int, long) and decimal (float, double) types, JavaScript traditionally has only one number type: IEEE 754 double-precision 64-bit binary floating-point.

The Infamous Floating-Point Precision Quirk

Because computers count in base-2 (binary) rather than base-10 (decimal), fractions like 0.1 (1/10) and 0.2 (1/5) result in infinitely repeating binary fractions. When rounded to 53 significand bits, small rounding errors occur:

// 1. The classic surprise
console.log(0.1 + 0.2);            // 0.30000000000000004
console.log(0.1 + 0.2 === 0.3);    // false!

// 2. Safe equality check using Number.EPSILON (ES6)
// Number.EPSILON is the difference between 1 and the smallest floating point number > 1 (~2.22e-16)
function areEqual(a, b) {
  return Math.abs(a - b) < Number.EPSILON;
}
console.log(areEqual(0.1 + 0.2, 0.3)); // true!

// 3. Financial calculations best practice:
// Always multiply into whole cents/cents before calculating, then divide:
const totalCents = (10 + 20); // 30 cents
const dollars = totalCents / 100; // $0.30

Safe Integer Range & Special Numbers

Number.MAX_SAFE_INTEGER
// 9,007,199,254,740,991 (2^53 - 1)

Number.isSafeInteger(9007199254740991); // true
Number.isSafeInteger(9007199254740992); // false

console.log(1 / 0);           // Infinity
console.log(-1 / 0);          // -Infinity
console.log(0 / 0);           // NaN ("Not a Number")
console.log(typeof NaN);      // "number" (historic quirk!)
console.log(Number.isNaN(0/0)); // true

8.2 Number Formatting & Conversion Methods

JavaScript provides robust built-in methods on Number.prototype for formatting decimal places, exponential notation, radix conversions, and localized currency display.

// Technique 1: Number() constructor — strict, fails if any invalid char present
Number("42");        // 42
Number("42.5");      // 42.5
Number("42px");      // NaN (strict!)
Number("");          // 0

// Technique 2: Unary Plus (+) — fastest, equivalent to Number()
+"100";              // 100
+"3.14";             // 3.14
+"invalid";          // NaN

// Technique 3: parseInt(string, radix) — parses leading integer characters
parseInt("42px", 10);     // 42 (stops at 'p')
parseInt("11111111", 2);  // 255 (binary string to decimal number)
parseInt("0xFF", 16);     // 255 (hexadecimal)

// Technique 4: parseFloat(string) — parses leading floating-point decimals
parseFloat("3.14159rem"); // 3.14159

// Modern ES2021: Numeric Separators (syntactic sugar for human readability)
const budget = 1_000_000_000; // 1 billion
const hexMask = 0xFF_AA_00;

8.3 BigInt — Arbitrary Precision Integers

Introduced in ES2020, BigInt is a primitive numeric type that can represent whole numbers of arbitrary precision with no upper limit. It solves the $2^{53} - 1$ limitation for cryptographic tokens, database 64-bit snowflakes, and nanosecond timers.

// 1. Suffix with 'n'
const bigLiteral = 9007199254740995n;

// 2. Call BigInt() constructor
const fromStr = BigInt("9007199254740995");
const fromNum = BigInt(42);

console.log(typeof bigLiteral); // "bigint"

// 1. CANNOT mix BigInt with Number in math
// 10n + 5; // TypeError: Cannot mix BigInt and other types!
const safeSum = 10n + BigInt(5); // 15n

// 2. Math methods do NOT work on BigInt
// Math.max(10n, 20n); // TypeError!

// 3. Division truncates towards 0 (integer division)
console.log(5n / 2n); // 2n (NOT 2.5)

// Standard Number overflows beyond 2^53 - 1
console.log(9007199254740991 + 1); // 9007199254740992
console.log(9007199254740991 + 2); // 9007199254740992 (INCORRECT!)

// BigInt calculates exact values with infinite digits
console.log(9007199254740991n + 1n); // 9007199254740992n
console.log(9007199254740991n + 2n); // 9007199254740993n (EXACT!)

// Massive calculations
const factorial20 = 2432902008176640000n;
console.log(factorial20 * 21n); // 51090942171709440000n

8.4 The JavaScript Math Object

The Math object is a static built-in namespace. Unlike Date or RegExp, Math cannot be created with new Math(). All properties and methods are static.

The 4 Rounding Functions: Crucial Differences

// 1. Math.random() returns floating-point in range [0, 1) — 0 inclusive, 1 exclusive
console.log(Math.random()); // e.g. 0.49281729182

// 2. Generating random integer between min and max (inclusive)
function getRandomInt(min, max) {
  min = Math.ceil(min);
  max = Math.floor(max);
  return Math.floor(Math.random() * (max - min + 1)) + min;
}
console.log(getRandomInt(1, 6)); // Dice roll: 1, 2, 3, 4, 5, or 6

// 3. Powers, Roots, and Absolute Values
Math.pow(2, 8);   // 256 (same as 2 ** 8)
Math.sqrt(64);    // 8
Math.cbrt(27);    // 3 (cube root)
Math.abs(-42);    // 42

// 4. Min / Max across array using spread (...)
const scores = [88, 95, 72, 99, 81];
console.log(Math.min(...scores)); // 72
console.log(Math.max(...scores)); // 99

8.5 Regular Expressions (RegExp) Fundamentals

A Regular Expression (RegExp) is an object describing a pattern of characters used to execute text search, validation, and find-and-replace operations with unmatched speed and flexibility.

const regex = /pattern/flags;
const re = /javascript/i;

const query = "hello";
const re = new RegExp(query, "i");

The 6 Essential RegExp Flags

8.6 Regex Syntax: Classes, Quantifiers & Anchors

Every regular expression is constructed using character classes, sets, quantifiers, and boundaries.

8.7 RegExp Methods in Action

JavaScript RegExp operates through dedicated methods on both the RegExp object and the String prototype.

// 1. RegExp.prototype.test(str) → Returns true / false (Fastest for validation)
const hasDigits = /\d+/.test("User123"); // true
const isClean = /^[a-z]+$/i.test("Hello World"); // false (has space)

// 2. String.prototype.match(regex) → Returns match array or null
const text = "Contact us at support@aicodelab.tech or sales@aicodelab.tech";
const emails = text.match(/[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-z]{2,}/g);
console.log(emails); 
// ["support@aicodelab.tech", "sales@aicodelab.tech"]

// 3. String.prototype.replace(regex, replacement) with capture groups ($1, $2)
const dateStr = "2026-09-13";
const usDate = dateStr.replace(/(\d{4})-(\d{2})-(\d{2})/, "$2/$3/$1");
console.log(usDate); // "09/13/2026"

// 4. String.prototype.split(regex)
const csv = "Apple, Banana; Orange | Mango";
const fruits = csv.split(/[,;|]\s*/);
console.log(fruits); // ["Apple", "Banana", "Orange", "Mango"]

8.8 Interactive Mini-Labs

Experiment with live JavaScript calculations and regex testing right inside this page.

8.9 Coding Challenge: Input Sanitizer & Formatter

Put your knowledge of Numbers, Math, and RegExp together to build a robust data processor.

// 1. Password Validator with Positive Lookahead Assertions
function validatePassword(pass) {
  // (?=.*[a-z]) : at least one lowercase
  // (?=.*[A-Z]) : at least one uppercase
  // (?=.*\d)     : at least one digit
  // (?=.*[!@#$%^&*]) : at least one special char
  // .{8,}       : at least 8 characters long
  const regex = /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[!@#$%^&*]).{8,}$/;
  return regex.test(pass);
}

// 2. Credit Card Formatter
function formatCreditCard(numStr) {
  const digitsOnly = numStr.replace(/\D/g, ""); // Strip non-digits
  return digitsOnly.replace(/(\d{4})(?=\d)/g, "$1 "); // Group in 4s
}

// 3. Compound Interest Calculator
function calculateCompoundInterest(principal, ratePercent, years, timesCompoundedPerYear) {
  const r = ratePercent / 100;
  const amount = principal * Math.pow(1 + (r / timesCompoundedPerYear), timesCompoundedPerYear * years);
  return amount.toFixed(2);
}

// Verification Tests
console.log(validatePassword("P@ssw0rd123")); // true
console.log(validatePassword("simple123"));   // false (no uppercase, no special)
console.log(formatCreditCard("4532-8921-7643-9821")); // "4532 8921 7643 9821"
console.log(calculateCompoundInterest(1000, 5, 10, 12)); // "1647.01"

8.10 Chapter Summary & Key Takeaways