JavaScript Data Types and Type System

// Immutability: primitives are immutable
let str = "hello";
str[0] = "H"; // No effect, strings are immutable
console.log(str); // "hello"

// Primitive vs Wrapper auto-boxing
let num = 42;
console.log(num.toString()); // "42" - temporary wrapper created

// Special number values
console.log(1 / 0);        // Infinity
console.log(-1 / 0);       // -Infinity
console.log(0 / 0);        // NaN
console.log(Number.MAX_SAFE_INTEGER); // 9007199254740991

// Symbols are unique
const sym1 = Symbol("desc");
const sym2 = Symbol("desc");
console.log(sym1 === sym2); // false (each is unique)

// BigInt for large integers
const bigNum = 9007199254740991n + 1n;
console.log(bigNum); // 9007199254740992n

// Primitives: value copied
let a = 5;
let b = a; // Copy value
b = 10;
console.log(a); // 5 (unchanged)

// References: pointer copied
let obj1 = { x: 5 };
let obj2 = obj1; // Copy reference
obj2.x = 10;
console.log(obj1.x); // 10 (both point to same object)

// Comparison
let str1 = "hello";
let str2 = "hello";
console.log(str1 === str2); // true (value comparison)

let arr1 = [1, 2, 3];
let arr2 = [1, 2, 3];
console.log(arr1 === arr2); // false (different references)
console.log(arr1 === arr1); // true (same reference)

// Function parameter behavior
function modifyPrimitive(x) {
    x = 100; // Local copy modified
}
let num = 5;
modifyPrimitive(num);
console.log(num); // 5 (original unchanged)

function modifyObject(obj) {
    obj.value = 100; // Original object modified
}
let data = { value: 5 };
modifyObject(data);
console.log(data.value); // 100 (original changed)

// String coercion (+ with string)
console.log("5" + 3);      // "53" (number to string)
console.log("5" + true);   // "5true"

// Numeric coercion (other operators)
console.log("5" - 3);      // 2 (string to number)
console.log("5" * "2");    // 10
console.log(true + 1);     // 2 (true → 1)
console.log(false + 1);    // 1 (false → 0)

// Boolean coercion
console.log(Boolean(""));    // false
console.log(Boolean(0));     // false
console.log(Boolean(NaN));   // false
console.log(Boolean(null));  // false
console.log(Boolean(undefined)); // false
console.log(Boolean([]));    // true (object)
console.log(Boolean({}));    // true (object)

// Explicit conversions
console.log(Number("123"));     // 123
console.log(Number("12.5"));    // 12.5
console.log(Number("abc"));     // NaN
console.log(parseInt("123px")); // 123 (parses until non-digit)
console.log(String(123));       // "123"
console.log(+"42");             // 42 (unary +)

// Falsy values (6 total)
if (!undefined || !null || !0 || !NaN || !"" || !false) {
    console.log("All falsy values");
}

// typeof: basic primitive checking
console.log(typeof 42);           // "number"
console.log(typeof "hello");      // "string"
console.log(typeof true);         // "boolean"
console.log(typeof undefined);    // "undefined"
console.log(typeof Symbol());     // "symbol"
console.log(typeof 42n);          // "bigint"
console.log(typeof null);         // "object" ⚠️ (legacy bug)
console.log(typeof []);           // "object"
console.log(typeof {});           // "object"
console.log(typeof function(){}); // "function"

// instanceof: prototype chain checking
console.log([] instanceof Array);       // true
console.log({} instanceof Object);      // true
console.log(new Date() instanceof Date); // true
console.log(42 instanceof Number);      // false (primitive)

// Array.isArray: reliable array detection
console.log(Array.isArray([]));         // true
console.log(Array.isArray({}));         // false
console.log(Array.isArray("array"));    // false

// Object.prototype.toString: most reliable
const toString = Object.prototype.toString;
console.log(toString.call([]));         // "[object Array]"
console.log(toString.call({}));         // "[object Object]"
console.log(toString.call(null));       // "[object Null]"
console.log(toString.call(undefined));  // "[object Undefined]"
console.log(toString.call(new Date())); // "[object Date]"
console.log(toString.call(/regex/));    // "[object RegExp]"

// Utility type checking function
function getType(value) {
    if (value === null) return 'null';
    if (Array.isArray(value)) return 'array';
    return typeof value;
}
console.log(getType(null));  // "null"
console.log(getType([]));    // "array"
console.log(getType(42));    // "number"

// Basic symbol creation (each is unique)
const sym1 = Symbol("id");
const sym2 = Symbol("id");
console.log(sym1 === sym2); // false (unique)

// Symbols as object properties
const id = Symbol("id");
const user = {
    name: "John",
    [id]: 123 // Symbol as computed property
};
console.log(user[id]); // 123
console.log(Object.keys(user)); // ["name"] (symbol hidden)

// Symbol registry (shared across realm)
const globalSym1 = Symbol.for("app.id");
const globalSym2 = Symbol.for("app.id");
console.log(globalSym1 === globalSym2); // true (same symbol)
console.log(Symbol.keyFor(globalSym1)); // "app.id"

// Well-known symbols: Symbol.iterator
const iterable = {
    data: [1, 2, 3],
    [Symbol.iterator]() {
        let index = 0;
        return {
            next: () => ({
                value: this.data[index],
                done: index++ >= this.data.length
            })
        };
    }
};
console.log([...iterable]); // [1, 2, 3]

// Symbol.toStringTag
class CustomClass {
    get [Symbol.toStringTag]() {
        return "CustomClass";
    }
}
const obj = new CustomClass();
console.log(Object.prototype.toString.call(obj)); // "[object CustomClass]"

// Symbol.toPrimitive
const obj2 = {
    [Symbol.toPrimitive](hint) {
        if (hint === "number") return 42;
        if (hint === "string") return "hello";
        return true;
    }
};
console.log(+obj2);     // 42 (number hint)
console.log(`${obj2}`); // "hello" (string hint)
console.log(obj2 + ""); // "true" (default hint)

// Creating BigInts
const big1 = 9007199254740991n;
const big2 = BigInt("9007199254740991");
const big3 = BigInt(Number.MAX_SAFE_INTEGER);

// Arithmetic operations
console.log(100n + 50n);   // 150n
console.log(100n - 50n);   // 50n
console.log(100n * 2n);    // 200n
console.log(100n / 3n);    // 33n (integer division, truncates)
console.log(100n % 3n);    // 1n
console.log(2n ** 100n);   // Very large number (2^100)

// Comparison
console.log(10n === 10);   // false (strict equality)
console.log(10n == 10);    // true (loose equality with coercion)
console.log(10n < 20n);    // true
console.log(5n > 3);       // true (coercion in comparison)

// Limitations
// console.log(10n + 5);   // ❌ TypeError: Cannot mix BigInt and Number
console.log(10n + BigInt(5)); // ✓ 15n (explicit conversion)
console.log(Number(10n) + 5); // ✓ 15 (convert to Number)

// console.log(+10n);      // ❌ TypeError: Cannot convert BigInt
console.log(Number(10n));  // ✓ 10 (explicit conversion)

// Bitwise operations
console.log(5n & 3n);     // 1n (binary AND)
console.log(5n | 3n);     // 7n (binary OR)
console.log(5n ^ 3n);     // 6n (binary XOR)
console.log(5n << 2n);    // 20n (left shift)

// Use case: Precise large integer calculations
const largeNumber = 9007199254740992n; // Beyond Number.MAX_SAFE_INTEGER
console.log(largeNumber + 1n); // 9007199254740993n (exact)
console.log(Number.MAX_SAFE_INTEGER + 1); // 9007199254740992 (precision lost)