Data Types in JavaScript

Data Types
├── Primitives (stored by VALUE)
│   ├── String
│   ├── Number
│   ├── BigInt
│   ├── Boolean
│   ├── Undefined
│   ├── Null
│   └── Symbol
│
└── Non-Primitives (stored by REFERENCE)
    ├── Object
    ├── Array
    ├── Function
    ├── Date
    ├── Map / Set
    ├── WeakMap / WeakSet
    └── RegExp

const single = 'hello';
const double = "hello";
const template = `Hello, ${name}!`; // template literal (ES6)

// Strings are IMMUTABLE
const str = "hello";
str[0] = "H"; // Does nothing — no error, but doesn't change
console.log(str); // "hello"

const age = 25;          // integer
const price = 19.99;     // decimal
const negative = -10;
const infinity = Infinity;
const notANumber = NaN;  // "Not a Number" — but typeof NaN is "number" 🤯

// Safe integer range
console.log(Number.MAX_SAFE_INTEGER); // 9007199254740991 (2^53 - 1)
console.log(Number.MIN_SAFE_INTEGER); // -9007199254740991

const big = 9007199254740991n; // Note the 'n' suffix
const huge = BigInt("123456789012345678901234567890");

// Cannot mix BigInt and Number
big + 1;  // ❌ TypeError
big + 1n; // ✅ 9007199254740992n

const isActive = true;
const isDeleted = false;

let x;
console.log(x); // undefined

function greet(name) {
  console.log(name);
}
greet(); // undefined (no argument passed)

let user = null; // "there is no user right now"

// Later...
user = { name: "Shiva" }; // now there's a user

const id1 = Symbol("id");
const id2 = Symbol("id");
console.log(id1 === id2); // false — always unique

// Primary use: object property keys that won't collide
const SECRET = Symbol("secret");
const obj = {
  [SECRET]: "hidden value",
  name: "visible"
};

console.log(obj[SECRET]); // "hidden value"
console.log(Object.keys(obj)); // ["name"] — Symbol keys are hidden

const user = {
  name: "Shiva",
  age: 25,
  address: {
    city: "Mumbai",
    country: "India"
  }
};

const colors = ["red", "green", "blue"];
console.log(typeof colors); // "object" — not "array"!
console.log(Array.isArray(colors)); // true — correct way to check

function greet() {
  return "hello";
}
console.log(typeof greet); // "function" — special typeof case

let a = 10;
let b = a;    // b gets a COPY of 10
b = 20;
console.log(a); // 10 — unchanged

const obj1 = { name: "Shiva" };
const obj2 = obj1;       // obj2 points to the SAME object
obj2.name = "Alex";
console.log(obj1.name);  // "Alex" — BOTH changed!

Primitives:          Objects:
a → [10]             obj1 → ┐
b → [20]             obj2 → ┤→ { name: "Alex" }
(separate boxes)     (same box)

// Shallow copy (1 level deep)
const copy1 = { ...obj1 };
const copy2 = Object.assign({}, obj1);

// Deep copy (all levels)
const deepCopy = structuredClone(obj1); // Modern — use this!
const jsonCopy = JSON.parse(JSON.stringify(obj1)); // Old way — loses functions, dates, undefined

typeof "hello"      // "string"
typeof 42           // "number"
typeof 42n          // "bigint"
typeof true         // "boolean"
typeof undefined    // "undefined"
typeof Symbol()     // "symbol"
typeof {}           // "object"
typeof []           // "object"  ← gotcha!
typeof function(){} // "function"
typeof null         // "object"  ← FAMOUS BUG
typeof NaN          // "number"  ← confusing!

// Check for null
value === null

// Check for undefined
value === undefined
// or
typeof value === "undefined"

// Check for null OR undefined
value == null  // true for both null and undefined (one of the few good uses of ==)

// Check for array
Array.isArray(value)

// Check for NaN
Number.isNaN(value)  // ✅ Use this
isNaN(value)         // ❌ Avoid — isNaN("hello") returns true (coerces first)

// Check for plain object
typeof value === "object" && value !== null && !Array.isArray(value)

// Check instance type
value instanceof Date
value instanceof RegExp
value instanceof Map

false
0
-0
0n        // BigInt zero
""        // empty string
null
undefined
NaN

"0"       // truthy (non-empty string)
" "       // truthy (space is a character)
[]        // truthy (empty array)
{}        // truthy (empty object)
function(){} // truthy

// Using truthy/falsy for defaults
const username = inputValue || "Anonymous";

// Better: nullish coalescing (handles 0 and "" correctly)
const count = inputCount ?? 0;
// inputCount = 0   → count = 0 (preserves 0)
// inputCount = null → count = 0 (falls back)

console.log(NaN === NaN); // false

// Correct way to check for NaN
Number.isNaN(NaN);   // true
Number.isNaN("abc"); // false (doesn't coerce)