JavaScript Interview Questions

console.log("Hello, JavaScript!");

// Browser-specific
console.log(window.innerWidth);  // Browser runtime
document.getElementById("app");   // Browser runtime

// Node.js-specific
const fs = require("fs");        // Node.js runtime
console.log(process.version);     // Node.js runtime

// V8's pipeline: Source → Parser → AST → Ignition (interpreter) → Bytecode
//                ↓ (hot code)
//           Turbofan (optimizing compiler) → Optimized Machine Code

const global = "I'm global";  // Global Execution Context

function outer() {
  const x = 1;                // outer() Execution Context
  function inner() {
    const y = 2;              // inner() Execution Context
    console.log(x + y);       // Access via scope chain
  }
  inner();
}
outer();

// In browser, these are equivalent:
console.log(this === window); // true
console.log(Math === window.Math); // true

var globalVar = "accessible everywhere";
function globalFunc() { /* also global */ }

console.log(a); // undefined (memory creation: var a = undefined)
var a = 5;      // execution: a = 5

console.log(b); // ❌ ReferenceError (TDZ)
let b = 10;     // execution: b = 10

greet();        // "Hello!" — function fully hoisted
function greet() { console.log("Hello!"); }

function multiply(a, b) { return a * b; }
function square(n) { return multiply(n, n); }
function main() {
  const result = square(5);
  console.log(result);
}

main();

1. [main]              — main() called
2. [main, square]      — square() called
3. [main, square, multiply] — multiply() called
4. [main, square]      — multiply() returns
5. [main]              — square() returns
6. []                  — main() returns (empty)

let name = "Alice";            // Stack: stores value "Alice"
let age = 30;                  // Stack: stores value 30
let person = { name, age };    // Stack: stores reference → Heap: stores object
let hobbies = ["reading"];     // Stack: stores reference → Heap: stores array

// When person goes out of scope, the reference is removed from Stack
// The object remains in Heap until GC collects it

typeof null // "object" — this is a known bug from JS's first version

function example() {
  // var — function scoped
  if (true) { var x = 1; }
  console.log(x); // 1 — accessible outside block

  // let/const — block scoped
  if (true) { let y = 2; const z = 3; }
  console.log(y); // ❌ ReferenceError

  // const — cannot reassign
  const obj = { name: "Alice" };
  obj.name = "Bob";  // ✅ Allowed — const prevents reassignment, not mutation
  // obj = {};        // ❌ TypeError
}

const global = "global";                  // Global scope

function outer() {
  const outerVar = "outer";               // Function scope (outer)

  if (true) {
    let blockVar = "block";               // Block scope
    var functionVar = "function scoped";  // Function scope (outer, not block!)
  }

  console.log(outerVar);      // ✅ "outer"
  console.log(functionVar);   // ✅ "function scoped"
  console.log(blockVar);      // ❌ ReferenceError
}

// TDZ starts at beginning of scope
{
  // TDZ for name — accessing it throws ReferenceError
  // console.log(name); // ❌ ReferenceError: Cannot access 'name' before initialization

  const name = "Alice";  // TDZ ends here
  console.log(name);     // ✅ "Alice"
}

// var does NOT have TDZ — it's initialized with undefined
{
  console.log(age); // undefined (no TDZ)
  var age = 25;
}

let name = "Alice";

function greet() {
  let name = "Bob";  // Shadows the outer 'name'
  console.log(name); // "Bob"
}

greet();
console.log(name);   // "Alice" — outer is unaffected

let x = 1;
{
  var x = 2;  // ❌ SyntaxError: Identifier 'x' has already been declared
}

// But this works:
let y = 1;
function test() {
  var y = 2;  // ✅ Different scope (function ≠ block)
}

// 1. var — hoisted, initialized with undefined
console.log(a); // undefined (not error!)
var a = 5;

// 2. Function declaration — fully hoisted
greet(); // "Hello!" — the whole function is hoisted
function greet() { console.log("Hello!"); }

// 3. let/const — hoisted but in TDZ
console.log(b); // ❌ ReferenceError: Cannot access 'b' before initialization
let b = 10;

// 4. Function expression — only variable is hoisted (as undefined)
sayHi(); // ❌ TypeError: sayHi is not a function
var sayHi = function() { console.log("Hi!"); };

typeof 42            // "number"
typeof "hello"       // "string"
typeof true          // "boolean"
typeof undefined     // "undefined"
typeof null          // "object"  ← QUIRK: this is a bug from JS v1
typeof {}            // "object"
typeof []            // "object"  ← use Array.isArray() instead
typeof function(){}  // "function"
typeof Symbol()      // "symbol"
typeof 42n           // "bigint"
typeof NaN           // "number"  — NaN is a number type
typeof undeclaredVar // "undefined" — doesn't throw (useful for checking existence)

0 / 0          // NaN
parseInt("abc") // NaN
Math.sqrt(-1)  // NaN
undefined + 1  // NaN
"abc" * 2      // NaN

NaN === NaN  // false — NEVER use === to check for NaN
NaN == NaN   // false

Number.isNaN(NaN)     // true ✅ — does NOT coerce
Number.isNaN("abc")   // false ✅ — doesn't coerce strings

isNaN(NaN)            // true — but coerces first!
isNaN("abc")          // true ← BUG: coerce "abc" to Number → NaN
isNaN(undefined)      // true ← BUG

// == with coercion
1 == "1"        // true ("1" coerced to number)
0 == false      // true (false → 0)
"" == false     // true (both coerce to 0)
null == undefined // true
[] == false     // true ([] → "" → 0, false → 0)
[1] == 1        // true ([1] → "1" → 1)

// === without coercion
1 === "1"       // false (number ≠ string)
0 === false     // false (number ≠ boolean)
null === undefined // false (different types)

Object.is(NaN, NaN)       // true ✅ (different from ===)
Object.is(0, -0)          // false ✅ (different from ===)
Object.is("hello", "hello") // true (same as ===)

// undefined
let a;
console.log(a);          // undefined
function foo() {}
console.log(foo());      // undefined
const obj = {};
console.log(obj.x);      // undefined

// null
let b = null;            // explicitly empty
const user = getUser();
if (user === null) {     // no user found
  showLogin();
}

// Comparison
null == undefined   // true
null === undefined  // false

const sym1 = Symbol("id");
const sym2 = Symbol("id");
console.log(sym1 === sym2); // false — always unique, even with same description

// Use as object keys (avoids property collision)
const specialKey = Symbol("secret");
const obj = {
  [specialKey]: "hidden value",
  name: "visible"
};
obj[specialKey];     // "hidden value"
Object.keys(obj);    // ["name"] — symbol keys excluded
JSON.stringify(obj); // '{"name":"visible"}' — symbols excluded

// Well-known symbols (used by JavaScript internally)
Symbol.iterator      // Makes objects iterable
Symbol.toPrimitive   // Controls type coercion
Symbol.hasInstance   // Custom instanceof behavior
Symbol.species       // Controls derived objects

// Global symbol registry (shared across realms)
const globalSym = Symbol.for("app.key");
const sameSym = Symbol.for("app.key");
console.log(globalSym === sameSym); // true

// Create BigInt
const big1 = 9007199254740991n;  // n suffix
const big2 = BigInt("9007199254740991123456");

// Operations (with BigInts only)
const sum = big1 + 100n;
const product = big1 * 2n;

// ❌ Cannot mix with regular numbers
big1 + 1;  // TypeError: Cannot mix BigInt and other types

// ✅ Convert first
big1 + BigInt(1);  // okay
Number(big1) + 1;  // okay (may lose precision)

// Operations that work: +, -, *, /, %, **, comparison
// Division truncates toward zero
5n / 2n;  // 2n (not 2.5n)

// Comparison with Number works
1n === 1;   // false (different types)
1n == 1;    // true

false, 0, -0, 0n, "", '', ``, null, undefined, NaN

"0"          // truthy (non-empty string)
"false"      // truthy (non-empty string)
[]           // truthy (empty array)
{}           // truthy (empty object)
-1           // truthy (non-zero number)
Infinity     // truthy

if (-1) console.log("truthy");      // ✅ prints
if ([]) console.log("truthy");      // ✅ prints
if ({}) console.log("truthy");      // ✅ prints
if ("") console.log("truthy");      // ❌ falsy
if (null) console.log("truthy");    // ❌ falsy

// Object.is() — SameValueZero algorithm
Object.is(NaN, NaN)   // true
Object.is(0, -0)      // false
Object.is("hello", "hello") // true

const user = { profile: { name: "Alice" } };

// Without optional chaining
user.address.city;   // ❌ TypeError: Cannot read properties of undefined

// With optional chaining
user?.address?.city;  // undefined ✅ — no error

// With methods
const result = obj?.method?.();  // undefined if method doesn't exist

// With arrays
const first = arr?.[0];  // undefined if arr is null/undefined

// Dynamic properties
const key = "name";
const value = user?.[key];

// ✅ Use with nullish coalescing for defaults
const city = user?.address?.city ?? "Unknown";

// ?? vs ||
null ?? "default"      // "default"
undefined ?? "default" // "default"
0 ?? "default"         // 0  (0 is NOT null/undefined)
"" ?? "default"        // "" ("" is NOT null/undefined)
false ?? "default"     // false

// || triggers on ANY falsy value
0 || "default"         // "default"  (0 is falsy)
"" || "default"        // "default"  ("" is falsy)
false || "default"     // "default"

// Use ?? for: setting defaults for potentially null/undefined values
const config = {
  timeout: serverTimeout ?? 5000,  // use 5000 only if serverTimeout is null/undefined
  retries: 0 ?? 3,                 // 0 — 0 is a valid value!
};

// Cannot combine with && or || without parentheses
null || undefined ?? "foo";   // ❌ SyntaxError
(null || undefined) ?? "foo"; // ✅ "foo"

// Array
const arr1 = [1, 2, 3];
const arr2 = [...arr1, 4, 5];   // [1, 2, 3, 4, 5]
const copy = [...arr1];          // shallow copy

// Object
const obj1 = { a: 1, b: 2 };
const obj2 = { ...obj1, c: 3 }; // { a: 1, b: 2, c: 3 }

// Function call
const nums = [1, 2, 3];
Math.max(...nums);  // 3

// Function parameters
function sum(...nums) {
  return nums.reduce((a, b) => a + b, 0);
}
sum(1, 2, 3, 4);  // 10

// Destructuring
const [head, ...tail] = [1, 2, 3, 4];
// head = 1, tail = [2, 3, 4]

const { name, ...rest } = { name: "Alice", age: 30, city: "NYC" };
// name = "Alice", rest = { age: 30, city: "NYC" }

const age = 20;
const status = age >= 18 ? "Adult" : "Minor";
// "Adult"

// Can be chained (use sparingly)
const score = 85;
const grade = score >= 90 ? "A"
            : score >= 75 ? "B"
            : score >= 60 ? "C"
            : "F";
// "B"

// Use when: returning a value based on a condition
// Avoid when: doing complex side effects
const canVote = isCitizen && age >= 18 ? "Yes" : "No";

false && "hello"   // false
0 && "hello"       // 0
true && "hello"    // "hello" (last truthy)
true && true       // true

false || "hello"   // "hello" (first truthy)
0 || "hello"       // "hello"
true || "hello"    // true (first truthy)
false || 0         // 0 (last falsy)

null ?? "default"   // "default"
0 ?? "default"      // 0 (not null/undefined)

// API call only happens if user is defined
user && fetchUserData(user.id);

// Default only if value is null/undefined
const name = input ?? "Guest";

// Conditional execution
isValid && saveData();  // saveData() only runs if isValid is true

// Declaration — hoisted
greet(); // ✅ "Hello!"
function greet() { console.log("Hello!"); }

// Expression — NOT hoisted
sayHi(); // ❌ TypeError (sayHi is undefined — var hoisting)
var sayHi = function() { console.log("Hi!"); };

// Named function expression
const factorial = function calc(n) {
  return n <= 1 ? 1 : n * calc(n - 1);  // calc() is visible inside
};
// calc is NOT accessible outside

// Regular function
function add(a, b) { return a + b; }

// Arrow function
const add = (a, b) => a + b;
const square = x => x * x;     // Single param — no parentheses
const empty = () => {};        // No params — parentheses required
const returning = () => ({     // Return object literal
  name: "Alice"
});

const obj = {
  name: "Alice",
  regular: function() { console.log(this.name); }, // "Alice"
  arrow: () => console.log(this.name)              // undefined (this = outer scope)
};

obj.regular(); // "Alice"
obj.arrow();   // undefined — arrow inherits this from enclosing scope

// Classic IIFE
(function() {
  const private = "I am private";
  console.log(private);
})();

// Arrow IIFE
(() => {
  console.log("Arrow IIFE");
})();

// With parameters
((name) => {
  console.log(`Hello, ${name}!`);
})("World");

// Named IIFE
(function init() {
  console.log("Runs once");
})();

const counter = (function() {
  let count = 0;
  return {
    increment: () => ++count,
    decrement: () => --count,
    getCount: () => count
  };
})();

counter.increment(); // 1
counter.increment(); // 2

// Synchronous callback
function greet(name, callback) {
  console.log(callback(name));
}

greet("Alice", function(name) {
  return `Hello, ${name}!`;
});

// Asynchronous callback
function fetchData(callback) {
  setTimeout(() => {
    callback("Data received");
  }, 1000);
}

fetchData(data => console.log(data));

// Callback hell
getUser(id, (user) => {
  getPosts(user.id, (posts) => {
    getComments(posts[0].id, (comments) => {
      // Deep nesting continues...
    });
  });
});

// Takes a function as argument
[1, 2, 3].map(n => n * 2);       // map, filter, reduce are HOFs
[1, 2, 3].filter(n => n > 1);
[1, 2, 3].reduce((a, b) => a + b, 0);

// Returns a function
function multiply(factor) {
  return function(value) {
    return value * factor;
  };
}

const double = multiply(2);
const triple = multiply(3);

double(5);  // 10
triple(5);  // 15

// Both — the core of functional programming
function createLogger(prefix) {
  return function(message) {
    console.log(`[${prefix}] ${message}`);
  };
}

// All demonstrate first-class functions
const greet = (name) => `Hello ${name}`;     // assigned to variable

function callTwice(fn) {                     // passed as argument
  fn(); fn();
}

function createCounter() {                   // returned from function
  let count = 0;
  return () => ++count;
}

const handlers = {                           // stored in object
  success: (data) => console.log(data),
  error: (err) => console.error(err),
};

const name = "Alice";
const age = 30;

// Interpolation
console.log(`My name is ${name} and I am ${age}.`);

// Expressions
console.log(`2 + 2 = ${2 + 2}`); // "2 + 2 = 4"

// Multi-line
const html = `
  <div>
    <h1>${name}</h1>
  </div>
`;

function highlight(strings, ...values) {
  return strings.reduce((result, str, i) =>
    result + str + (values[i] ? `<mark>${values[i]}</mark>` : ""), ""
  );
}

const name = "Alice", score = 95;
highlight`Player ${name} scored ${score} points!`;
// "Player <mark>Alice</mark> scored <mark>95</mark> points!"

// Used by: styled-components (css``), GraphQL (gql``), SQL libraries

// Array destructuring
const [a, b, c] = [1, 2, 3];
const [first, , third] = [10, 20, 30]; // skip: first=10, third=30
const [head, ...tail] = [1, 2, 3, 4];  // rest: head=1, tail=[2,3,4]
const [x = 0, y = 0] = [5];            // default: x=5, y=0

// Swap variables
[a, b] = [b, a];

// Object destructuring
const { name, age } = { name: "Alice", age: 30 };
const { name: userName } = { name: "Bob" };  // rename
const { x = 10 } = { x: 5 };                 // default
const { address: { city } } = { address: { city: "Mumbai" } }; // nested

// Function parameters
function greet({ name, age = 0 }) {
  return `${name} is ${age} years old`;
}

const arr = [1, 2, 3, 4, 5];

// slice — non-mutating
const sliced = arr.slice(1, 3);   // [2, 3]
const fromEnd = arr.slice(-2);    // [4, 5]
const copy = arr.slice();         // shallow copy
// arr is still [1, 2, 3, 4, 5]

// splice — MUTATING
const removed = arr.splice(1, 2);  // removes 2 elements at index 1 → [2, 3]
// arr is now [1, 4, 5]

arr.splice(1, 0, 10, 20);          // insert at index 1
// arr is now [1, 10, 20, 4, 5]

arr.splice(2, 1, 99);             // replace
// arr is now [1, 10, 99, 4, 5]

// ES2023: non-mutating alternatives
arr.toSpliced(1, 2);              // [1, 4, 5] — original unchanged!

[1,2,3].map(n => n * 2);       // [2,4,6] — transform each element
[1,2,3].filter(n => n > 1);    // [2,3] — keep matching
[1,2,3].flat();                 // flatten nested
[1,2,3].flatMap(n => [n, n]);  // map + flat
[3,1,2].toSorted();             // [1,2,3] — ES2023, non-mutating
[1,2,3].toReversed();           // [3,2,1] — ES2023, non-mutating

[1,2,3].find(n => n > 1);       // 2 — first match
[1,2,3].findIndex(n => n > 1);  // 1 — first match index
[1,2,3].findLast(n => n > 1);   // 3 — ES2023, last match
[1,2,3].some(n => n > 2);       // true — any match?
[1,2,3].every(n => n > 0);      // true — all match?
[1,2,3].includes(2);            // true
[1,2,3].indexOf(2);             // 1

[1,2,3].reduce((acc, n) => acc + n, 0);  // 6
[1,2,3].reduceRight((acc, n) => acc + n, 0);  // right-to-left

push(4), pop(), unshift(0), shift(), splice(1,1), sort(), reverse(), fill(0)

Array.from("123");               // ["1","2","3"]
Array.from({length:3}, (_,i)=>i); // [0,1,2]
Array.of(1, 2, 3);              // [1,2,3] — like new Array but without the length quirk
Array.isArray([]);              // true

const nums = [1, 2, 3, 4, 5];

// map — transform EVERY element, output length = input length
const doubled = nums.map(n => n * 2);     // [2, 4, 6, 8, 10]

// filter — KEEP elements matching condition, output length ≤ input length
const evens = nums.filter(n => n % 2 === 0);  // [2, 4]

// reduce — accumulate to SINGLE value
const sum = nums.reduce((acc, n) => acc + n, 0);   // 15 — with initial value
const product = nums.reduce((acc, n) => acc * n);   // 120 — without init (first element as acc)

// Chaining
const result = nums
  .filter(n => n % 2 === 0)   // [2, 4]
  .map(n => n * 10)           // [20, 40]
  .reduce((a, b) => a + b);   // 60

const nums = [1, 2, 3];

// forEach — side effects
nums.forEach(n => console.log(n)); // logs 1, 2, 3
// returns undefined

// map — transformation
const doubled = nums.map(n => n * 2); // [2, 4, 6]
// returns new array

// Chaining works with map, not forEach
nums
  .map(n => n * 2)
  .filter(n => n > 3)
  .forEach(n => console.log(n)); // 4, 6

const str = "  Hello, World!  ";

str.trim();                // "Hello, World!"
str.trimStart();           // "Hello, World!  "
str.trimEnd();             // "  Hello, World!"
str.toLowerCase();         // "  hello, world!  "
str.toUpperCase();         // "  HELLO, WORLD!  "

str.includes("World");     // true
str.startsWith("Hello");   // false (spaces)
str.endsWith("!");         // false (spaces)

str.indexOf("o");          // 4
str.lastIndexOf("o");      // 9
str.search(/world/i);      // 8 (regex)

str.slice(2, 7);           // "Hello"
str.substring(2, 7);       // "Hello"
str.substr(2, 5);          // "Hello" (deprecated)

str.replace("World", "JS");      // "  Hello, JS!  " — first match
str.replaceAll("l", "L");         // "  HeLLo, WorLd!  " — all matches
str.replace(/world/i, "JS");      // case-insensitive regex

str.split(", ");                 // ["  Hello", "World!  "]
str.concat(" How are you?");     // "  Hello, World!  How are you?"
str.repeat(2);                   // "  Hello, World!   Hello, World!  "
str.padStart(20, "*");           // "***  Hello, World!  " (to length 20)
str.padEnd(20, "*");             // "  Hello, World!  ***"
str.charAt(2);                   // "H"
str.at(-1);                      // " " (ES2022, supports negative)

"abc123".match(/\d+/);           // ["123"]
"abc123".matchAll(/\d/g);        // iterator of all matches

const obj = { a: 1, b: 2, c: 3 };

Object.keys(obj);     // ["a", "b", "c"]
Object.values(obj);   // [1, 2, 3]
Object.entries(obj);  // [["a", 1], ["b", 2], ["c", 3]]

// Iterate object
for (const [key, value] of Object.entries(obj)) {
  console.log(`${key}: ${value}`);
}

// Convert back from entries
Object.fromEntries([["a", 1], ["b", 2]]);  // { a: 1, b: 2 }

// Combine with array methods
Object.entries(obj)
  .filter(([_, v]) => v > 1)
  .map(([k, v]) => ({ [k]: v }));
// [{ b: 2 }, { c: 3 }]

const obj = { name: "Alice", age: 30, active: true, scores: [1, 2] };

// Object → JSON string
const json = JSON.stringify(obj);
// '{"name":"Alice","age":30,"active":true,"scores":[1,2]}'

// Pretty-print
JSON.stringify(obj, null, 2);
// {
//   "name": "Alice",
//   "age": 30,
//   "active": true,
//   "scores": [1, 2]
// }

// With replacer (filter/transform)
JSON.stringify(obj, ["name", "age"]);  // only "name" and "age"
JSON.stringify(obj, (key, val) => typeof val === "number" ? val * 2 : val);

// JSON string → Object
const parsed = JSON.parse(json);
// { name: "Alice", age: 30, active: true, scores: [1, 2] }

// With reviver (transform values)
JSON.parse(json, (key, val) => typeof val === "number" ? val * 2 : val);

// Limitations — what gets dropped:
JSON.stringify({ a: undefined, b: function() {}, c: Symbol() });
// '{}' — functions, undefined, symbols are OMITTED

JSON.stringify({ a: NaN, b: Infinity });
// '{"a":null,"b":null}' — NaN, Infinity become null

JSON.stringify(new Date());
// '"2024-01-15T..."' — Date becomes string (no automatic parse back)

let str = "Hello";
str[0] = "J";          // ❌ silently fails (no effect)
console.log(str);      // "Hello" — unchanged!

str.toUpperCase();     // Returns "HELLO" — new string
console.log(str);      // "Hello" — original unchanged!

str = str.toUpperCase(); // Must reassign to update
console.log(str);      // "HELLO"

// All string methods return new strings:
const s = "  hello  ";
const trimmed = s.trim();    // new string
const upper = trimmed.toUpperCase();  // new string
// s is still "  hello  "

// Performance: string concatenation in loops creates many objects
let result = "";
for (let i = 0; i < 1000; i++) {
  result += i;  // Creates new string each iteration
}

// Merge
const target = { a: 1 };
const source = { b: 2, c: 3 };
Object.assign(target, source);
// target → { a: 1, b: 2, c: 3 }

// Clone
const clone = Object.assign({}, target);

// Merge multiple
const merged = Object.assign({}, obj1, obj2, obj3);

// Later properties overwrite earlier ones
Object.assign({ a: 1 }, { a: 2, b: 3 }, { b: 4 });
// { a: 2, b: 4 }

// ⚠️ SHALLOW COPY only!
const original = { a: { x: 1 } };
const copy = Object.assign({}, original);
copy.a.x = 99;
console.log(original.a.x); // 99 — nested reference is shared!

// ⚠️ Getters/setters are NOT preserved
const obj = { get name() { return "Alice"; } };
Object.assign({}, obj); // { name: "Alice" } — getter becomes value

// 1. Default binding — global object (or undefined in strict mode)
function show() { console.log(this); }
show(); // Window (browser) or undefined (strict)

// 2. Implicit binding — object before the dot
const obj = { name: "Alice", greet() { console.log(this.name); } };
obj.greet(); // "Alice"

// 3. Explicit binding — call/apply/bind
function greet() { console.log(`Hello, ${this.name}`); }
greet.call({ name: "Bob" });   // "Hello, Bob"
greet.apply({ name: "Bob" });  // "Hello, Bob"

// 4. new binding — creates new object as this
function Person(name) { this.name = name; }
new Person("Alice");  // this → new instance

// Arrow functions: ignore all 4 rules — use lexical this
const obj2 = {
  name: "Oops",
  greet: () => console.log(this.name)  // undefined — this is from outer scope
};

// Priority: new > explicit > implicit > default

// setTimeout — runs ONCE after delay
const timerId = setTimeout(() => {
  console.log("Runs after 2 seconds");
}, 2000);
clearTimeout(timerId);  // cancel

// setInterval — runs REPEATEDLY
const intervalId = setInterval(() => {
  console.log("Every 1 second");
}, 1000);
clearInterval(intervalId);  // stop

// Important: timer delays are MINIMUM delays, not guaranteed
setTimeout(() => console.log("Delayed"), 0);
// Will run AFTER current synchronous code and microtasks complete

console.log("1");
setTimeout(() => console.log("2"), 0);
Promise.resolve().then(() => console.log("3"));
console.log("4");
// Output: 1 → 4 → 3 → 2

try {
  // Code that might throw
  const result = JSON.parse("invalid json");
} catch (error) {
  // Handle the error
  console.error("Error:", error.message);
} finally {
  // Always runs (whether error or not)
  console.log("Cleanup");
}

// Throw custom errors
function divide(a, b) {
  if (b === 0) throw new Error("Division by zero");
  return a / b;
}

try {
  divide(10, 0);
} catch (e) {
  console.log(e.name);    // "Error"
  console.log(e.message); // "Division by zero"
  console.log(e.stack);   // Stack trace
}

// Multiple error types
try {
  // some code
} catch (e) {
  if (e instanceof TypeError) { /* ... */ }
  else if (e instanceof RangeError) { /* ... */ }
  else throw e;  // re-throw
}