Question 1

What are the differences between var, let, and const in JavaScript?

Accepted Answer

JavaScript provides three variable declaration keywords with different scoping and mutation rules:

| Feature | `var` | `let` | `const` |
|---|---|---|---|
| **Scope** | Function-scoped | Block-scoped (`{}`) | Block-scoped |
| **Hoisting** | Hoisted (initialized as `undefined`) | Hoisted (Temporal Dead Zone) | Hoisted (Temporal Dead Zone) |
| **Reassignment** | ✅ Yes | ✅ Yes | ❌ No |
| **Redeclaration** | ✅ Yes (same scope) | ❌ No | ❌ No |

### Temporal Dead Zone (TDZ):
`let` and `const` are hoisted but cannot be accessed before their declaration line. Accessing them throws a `ReferenceError`.

### Best Practice (2026):
Use `const` by default. Use `let` only when reassignment is required. Never use `var`.

Key Takeaway: Use const by default, let when reassignment is needed. Never use var in modern JavaScript.

Question 2

What are the JavaScript data types and the difference between primitives and objects?

Accepted Answer

JavaScript has **8 data types** divided into Primitives and Objects:

### 7 Primitive Types (immutable, stored by value):
1. `string` — text (`"hello"`)
2. `number` — integers and floats (`42`, `3.14`, `NaN`, `Infinity`)
3. `bigint` — arbitrary precision integers (`9007199254740993n`)
4. `boolean` — `true` / `false`
5. `undefined` — declared but unassigned variable
6. `null` — intentional absence of value
7. `symbol` — unique, immutable identifier (`Symbol('id')`)

### 1 Reference Type (mutable, stored by reference):
8. `object` — includes plain objects, arrays, functions, Date, RegExp, Map, Set, etc.

### typeof Quirk:
`typeof null` returns `"object"` — this is a legacy JavaScript bug from 1995 that cannot be fixed for backward compatibility.

Key Takeaway: Primitives are compared by value, objects by reference. Use Array.isArray() instead of typeof to check arrays.

Question 3

What is the difference between == (loose equality) and === (strict equality)?

Accepted Answer

### `==` (Loose Equality / Abstract Equality):
Performs **type coercion** before comparing. Converts operands to the same type, leading to unexpected results:
- `0 == ''` → `true` (both coerced to 0)
- `null == undefined` → `true` (special rule)
- `'1' == 1` → `true` (string converted to number)

### `===` (Strict Equality):
Compares **value AND type** without coercion:
- `0 === ''` → `false` (number vs string)
- `null === undefined` → `false` (different types)
- `'1' === 1` → `false`

### Best Practice:
Always use `===` and `!==`. The only valid `==` use case is `value == null` (checks both null and undefined).

Key Takeaway: Always use === for comparisons. Use == null as the only exception to check both null and undefined.

Question 4

What are the differences between function declarations, expressions, and arrow functions?

Accepted Answer

### Function Declaration:
Hoisted completely — can be called before the declaration line. Has its own `this` context.

### Function Expression:
Not hoisted (only the variable is hoisted if using `var`). Assigned to a variable.

### Arrow Function (`=>`):
Short syntax. **No own `this`** — inherits `this` from the enclosing lexical scope. No `arguments` object. Cannot be used as constructors (`new`).

Key Takeaway: Use arrow functions for callbacks and inline functions. Use function declarations for named, hoisted functions.

Question 5

How do template literals and string interpolation work in JavaScript?

Accepted Answer

Template literals use backticks (`) instead of quotes and support:

1. **String Interpolation**: Embed expressions with `${expression}`.
2. **Multi-line Strings**: Line breaks are preserved without 
 escape characters.
3. **Expression Evaluation**: Any valid JS expression can be embedded: function calls, ternaries, arithmetic.
4. **Tagged Templates**: Custom function processes the template (used in styled-components, GraphQL, SQL sanitization).

Key Takeaway: Use template literals for string concatenation. Tagged templates enable custom string processing like SQL injection prevention.

Question 6

How does destructuring assignment work for objects and arrays in JavaScript?

Accepted Answer

Destructuring extracts values from arrays or properties from objects into distinct variables with a clean syntax:

### Object Destructuring:
Extracts by **property name**:
- Default values: `const { role = 'user' } = person;`
- Renaming: `const { name: userName } = person;`
- Nested: `const { location: { city } } = person;`

### Array Destructuring:
Extracts by **position / index**:
- Skipping items: `const [first, , third] = items;`
- Rest pattern: `const [head, ...tail] = numbers;`
- Variable swapping: `[a, b] = [b, a];`

Key Takeaway: Object destructuring matches keys by name; array destructuring matches items by position. Both support default values.

Question 7

What are rest parameters and the spread operator in JavaScript?

Accepted Answer

The `...` syntax has two distinct uses based on context:

### 1. Rest Parameters (Function parameter definition):
Collects remaining function arguments into a true Array instance. Replaces the legacy `arguments` object.
- Syntax: `function fn(a, b, ...rest) {}`
- Must be the **last parameter** in the function signature.

### 2. Spread Operator (Array/Object literals & call sites):
Unpacks elements of an iterable (array/string) or properties of an object into individual elements/keys.
- Shallow copies arrays and objects: `const copy = { ...original };`
- Combines arrays: `const merged = [...arr1, ...arr2];`

Key Takeaway: Rest collects multiple elements into an array; spread expands an array or object into individual elements.

Question 8

How do default parameter values work in JavaScript functions?

Accepted Answer

Default function parameters allow named parameters to be initialized with default values if **no value** or **`undefined`** is passed.

### Key Rules:
1. **Trigger Condition**: Defaults only apply when the argument is `undefined` or missing.
2. **`null` does NOT trigger defaults**: Passing `null` sets the parameter to `null`!
3. **Lazy Evaluation**: Default expressions are evaluated at call time, not when the function is declared.
4. **Earlier Parameters Scope**: Later parameters can use the values of preceding parameters: `function f(a, b = a * 2)`.

Key Takeaway: Default parameters only evaluate when arguments are undefined or omitted. Explicit null bypasses defaults.

Question 9

What are truthy and falsy values in JavaScript?

Accepted Answer

In JavaScript, a value is considered **truthy** or **falsy** when evaluated in a boolean context (like an `if` statement).

### Exactly 8 Falsy Values in JavaScript:
1. `false`
2. `0` (and `-0`, `0n` BigInt zero)
3. `""` (empty string)
4. `null`
5. `undefined`
6. `NaN`
7. `document.all` (browser legacy quirk)

**EVERYTHING ELSE IS TRUTHY**, including:
- Empty arrays `[]`
- Empty objects `{}`
- String `"false"` or `"0"`
- Functions

Key Takeaway: Only 8 values are falsy in JS. Empty arrays [] and empty objects {} are truthy!

Question 10

How do short-circuit evaluation and logical operators (&&, ||, ??) work?

Accepted Answer

Logical operators in JavaScript do **not** return boolean `true`/`false` by default; they return the value of one of their operands:

### 1. Logical AND (`&&`):
Evaluates left to right. Returns the **first falsy value** encountered, or the last operand if all are truthy.
- Short-circuit: If left is falsy, right is never evaluated.

### 2. Logical OR (`||`):
Evaluates left to right. Returns the **first truthy value** encountered, or the last operand if all are falsy.
- Short-circuit: If left is truthy, right is never evaluated.

### 3. Nullish Coalescing (`??`):
Returns right-hand operand only when left is **`null` or `undefined`** (ignores falsy `0` or `""`).

Key Takeaway: && returns the first falsy operand; || returns the first truthy operand. Neither returns a boolean unless operands are booleans.

Question 11

What is the optional chaining operator (?.) and how does it prevent errors?

Accepted Answer

The optional chaining operator (`?.`) reads nested object properties without throwing a `TypeError` if an intermediate reference is `null` or `undefined`.

### Behavior:
If the object before `?.` is `null` or `undefined`, evaluation **short-circuits** and returns `undefined` immediately instead of throwing an error.

### Three Forms:
1. Property access: `obj?.prop`
2. Bracket notation: `obj?.[key]`
3. Function/method call: `obj.method?.()`

Key Takeaway: Use ?. to safely access deeply nested properties and call optional methods without runtime TypeError crashes.

Question 12

What is the nullish coalescing operator (??) vs Logical OR (||)?

Accepted Answer

Both `??` and `||` provide fallback values, but trigger on different conditions:

### Logical OR (`||`):
Triggers fallback for **ANY falsy value**: `false`, `0`, `""`, `null`, `undefined`, `NaN`.
- **Problem**: Overwrites valid falsy values like `0` (valid count) or `""` (valid empty string).

### Nullish Coalescing (`??`):
Triggers fallback **ONLY for nullish values**: `null` and `undefined`.
- Preserves `0`, `false`, and `""`.

Key Takeaway: Use ?? when setting default values for numbers, booleans, or strings where 0, false, or "" are valid.

Question 13

What are common array iteration methods (map, filter, reduce, forEach, find)?

Accepted Answer

JavaScript provides functional higher-order array methods that process elements immutably:

| Method | Returns | Description |
|---|---|---|
| `map()` | New Array | Transforms each element into a new item |
| `filter()` | New Array | Returns elements that satisfy a condition |
| `reduce()` | Single Value | Accumulates items into an object/number/array |
| `forEach()` | `undefined` | Runs a side-effect function for each item |
| `find()` | Element / `undefined` | Returns first element matching condition |
| `some()` | Boolean | Checks if **at least one** item matches condition |
| `every()` | Boolean | Checks if **all** items match condition |

Key Takeaway: map transforms arrays, filter selects items, reduce aggregates data, and forEach runs side effects.

Question 14

What is the difference between Array.prototype.slice() and Array.prototype.splice()?

Accepted Answer

Despite their similar names, `slice()` and `splice()` have opposite mutability rules:

### `slice(start, end)`:
- **Pure (Immutable)**: Does NOT modify the original array.
- Returns a new array containing a shallow copy of elements from `start` index up to (but not including) `end` index.

### `splice(start, deleteCount, item1, item2, ...)`:
- **Impure (Mutating)**: Modifies the original array directly.
- Deletes `deleteCount` items starting at `start` index and optionally inserts new items in their place.
- Returns an array containing the **deleted elements**.

Key Takeaway: slice() is immutable and returns a shallow copy section; splice() mutates the array by deleting or inserting items.

Question 15

How do JavaScript Object static methods (keys, values, entries, freeze, seal) work?

Accepted Answer

JavaScript provides static `Object` utility methods for reflection and immutability:

### Inspection Methods:
- **`Object.keys(obj)`**: Returns an array of an object's own enumerable property names (keys).
- **`Object.values(obj)`**: Returns an array of an object's own enumerable property values.
- **`Object.entries(obj)`**: Returns an array of `[key, value]` pairs (useful for `Map` or `for...of` loops).

### Immutability Methods:
- **`Object.seal(obj)`**: Prevents adding or deleting properties. Existing properties can still be modified.
- **`Object.freeze(obj)`**: Highest protection. Prevents adding, deleting, OR modifying any properties (shallow freeze).

Key Takeaway: Object.entries converts objects into iterable tuples. Object.freeze prevents all modifications; Object.seal allows property edits but no additions/deletions.

Question 16

What is hoisting in JavaScript and how does it affect functions and variables?

Accepted Answer

**Hoisting** is JavaScript's default behavior of moving variable and function declarations to the top of their containing scope during the compilation/creation phase before execution.

### How Different Declarations Hoist:
1. **Function Declarations**: Completely hoisted with implementation intact. Can be invoked before declaration.
2. **`var` variables**: Hoisted and initialized with `undefined`. Accessing before declaration returns `undefined`.
3. **`let` and `const` variables**: Hoisted into the **Temporal Dead Zone (TDZ)** but NOT initialized. Accessing before declaration throws a `ReferenceError`.
4. **Function Expressions / Arrow functions**: Variable declaration hoists, but function assignment does not.

Key Takeaway: Function declarations can be called before definition. var hoists as undefined; let and const hoist into the Temporal Dead Zone.

Question 17

What is scope in JavaScript (global, function, block, and lexical scope)?

Accepted Answer

**Scope** determines the accessibility and visibility of variables and functions in different parts of your code.

### Types of Scope:
1. **Global Scope**: Default scope for variables declared outside any function or block. Accessible everywhere.
2. **Function (Local) Scope**: Variables declared with `var`, `let`, or `const` inside a function are accessible only within that function.
3. **Block Scope**: Variables declared with `let` and `const` inside curly braces `{}` (if statements, loops) cannot be accessed outside the block.
4. **Lexical Scope**: Inner functions have access to variables declared in their outer parent scope based on where code is written.

Key Takeaway: Lexical scoping means variable access is determined by where functions are written in source code.

Question 18

What is the basic syntax and purpose of JavaScript Promises?

Accepted Answer

A **Promise** is an object representing the eventual completion (or failure) of an asynchronous operation and its resulting value.

### Three States:
1. **Pending**: Initial state, neither fulfilled nor rejected.
2. **Fulfilled**: Operation completed successfully (`resolve(value)` was called).
3. **Rejected**: Operation failed (`reject(error)` was called).

### Instance Handlers:
- **`.then(onFulfilled)`**: Executed when resolved. Returns a new promise for chaining.
- **`.catch(onRejected)`**: Handles any error thrown anywhere in the promise chain.
- **`.finally(onSettled)`**: Executes cleanup logic regardless of success or failure.

Key Takeaway: Promises simplify asynchronous code and eliminate callback hell using .then(), .catch(), and .finally().

Question 19

How does async/await work for handling asynchronous JavaScript code?

Accepted Answer

`async/await` is syntactic sugar built on top of ES6 Promises, allowing asynchronous code to be written and read like synchronous imperative code.

### Key Syntax Rules:
1. **`async` functions**: Declaring a function `async` ensures it automatically returns a Promise (wrapping non-promise returns).
2. **`await` keyword**: Can only be used inside `async` functions (or top-level ES modules). Pauses function execution until the promise settles.
3. **Error Handling**: Uses standard `try...catch` blocks instead of `.catch()` callbacks.

Key Takeaway: async/await makes asynchronous code read synchronously. Use try/catch blocks to handle promise rejections.

Question 20

What is JSON and how do JSON.stringify() and JSON.parse() work?

Accepted Answer

**JSON (JavaScript Object Notation)** is a lightweight data-interchange format.

### Key Methods:
- **`JSON.stringify(value, replacer, space)`**: Serializes a JS object/array into a JSON string.
- **`JSON.parse(text, reviver)`**: Parses a JSON string back into a JS object/array.

### Serialization Limitations:
1. `undefined`, functions, and Symbols are **omitted** from plain objects, or converted to `null` in arrays.
2. `Date` objects become ISO strings.
3. **Circular references** throw a `TypeError: Converting circular structure to JSON`.

Key Takeaway: JSON.stringify converts JS objects to JSON strings (dropping functions/undefined); JSON.parse reconstructs JS values from JSON strings.

Question 21

What is the difference between primitive values passed by value and objects passed by reference?

Accepted Answer

In JavaScript, variable assignment and function parameter passing behave differently depending on the data type:

### Primitive Types (Passed by Value):
Primitives (numbers, strings, booleans, etc.) are copied directly. Modifying a function parameter does NOT affect the original variable outside.

### Object Types (Passed by Reference Copy):
Objects, arrays, and functions store a reference (memory address). When passed to a function, the **reference copy** is passed:
- Modifying object properties mutates the original object!
- **Reassigning** the parameter variable breaks the reference link without mutating the original object.

Key Takeaway: Primitives are passed by value (copied). Objects are passed by reference value (mutating properties affects the caller, reassigning parameter does not).

Question 22

How do JavaScript ES6 classes work (constructor, methods, extends, super)?

Accepted Answer

ES6 classes provide cleaner, standard syntactic sugar over JavaScript's existing prototype-based inheritance model.

### Key Components:
- **`constructor()`**: Special method invoked when instantiating via `new ClassName()`.
- **Instance Methods**: Defined directly in the class body; placed on `ClassName.prototype`.
- **Static Methods**: Defined with `static` keyword; called directly on the class (`ClassName.method()`), not instances.
- **Inheritance (`extends` & `super`)**: Child classes inherit from parent classes. Child constructors must call `super()` before accessing `this`.

Key Takeaway: Classes are syntactic sugar over prototypal inheritance. Subclasses must invoke super() in constructors before using this.

Question 23

What is the typeof operator and how do you reliably check data types in JavaScript?

Accepted Answer

The `typeof` operator returns a string indicating the type of an unevaluated operand.

### `typeof` Output Mapping:
- `number`, `string`, `boolean`, `undefined`, `symbol`, `bigint`, `function`
- **Quirk**: `typeof null === 'object'`
- **Quirk**: `typeof [] === 'object'` (cannot distinguish Arrays from Objects)

### Reliable Type Checking Techniques:
1. **Arrays**: Use `Array.isArray(val)`.
2. **Null**: Use `val === null`.
3. **Exact Type (Universal)**: Use `Object.prototype.toString.call(val)` (e.g. `"[object Date]"`).
4. **Class Instances**: Use `instanceof ClassName`.

Key Takeaway: Use Array.isArray() for arrays and Object.prototype.toString.call() for robust cross-frame type checking.

Question 24

What is NaN, how is it checked, and why does NaN !== NaN?

Accepted Answer

`NaN` stands for **"Not-a-Number"**, representing an unrepresentable or undefined numerical calculation result (e.g., `0 / 0` or `Math.sqrt(-1)`).

### The NaN Paradox (`NaN !== NaN`):
Per the IEEE 754 floating-point specification, `NaN` is the **only value in JavaScript that is not equal to itself**:
- `NaN === NaN` returns `false`!

### Checking for NaN:
- ❌ Global `isNaN(val)`: Performs type coercion first! `isNaN('hello')` returns `true` (string coerced to NaN).
- ✅ `Number.isNaN(val)`: Checks if the value is **strictly NaN** without coercion.
- ✅ `Object.is(val, NaN)`: Returns `true`.

Key Takeaway: NaN is never equal to anything, including itself. Always use Number.isNaN() instead of global isNaN().

Question 25

What are JavaScript Set and Map objects and how do they differ from Arrays and Objects?

Accepted Answer

ES6 introduced `Set` and `Map` collections designed for specific data manipulation needs:

### 1. `Set` (Unique Value Collection):
- Stores **unique values** of any type (duplicates automatically ignored).
- Fast element lookup via `.has(value)` in O(1) time vs Array `.includes()` in O(N) time.

### 2. `Map` (Key-Value Dictionary):
- Keys can be **any type** (objects, functions, primitives) unlike Plain Objects (where keys are coerced to strings).
- Remembers insertion order during iteration.
- Built-in `.size` property (no need for `Object.keys().length`).

Key Takeaway: Use Set for unique collections and fast lookups. Use Map when keys are non-strings or entry counts must be tracked.

Question 26

How do setTimeout and setInterval work and how do you clear them?

Accepted Answer

Timers in JavaScript schedule code to run asynchronously after a specified delay:

### 1. `setTimeout(callback, delayMs, ...args)`:
Executes `callback` once after `delayMs` milliseconds.
- Cancel with `clearTimeout(timerId)`.

### 2. `setInterval(callback, intervalMs, ...args)`:
Executes `callback` repeatedly every `intervalMs` milliseconds until canceled.
- Cancel with `clearInterval(intervalId)`.

### Key Warning:
Timers are non-blocking macrotasks. The delay specifies the **minimum time** before execution, not exact timing, because long synchronous tasks on the Call Stack block execution.

Key Takeaway: Timers return a numeric ID used with clearTimeout/clearInterval to cancel execution before memory leaks occur.

Question 27

What is TypeScript and how does static typing differ from dynamic typing?

Accepted Answer

**TypeScript** is a typed syntactic superset of JavaScript that compiles down to plain JavaScript.

### Dynamic (JavaScript) vs Static (TypeScript) Typing:
- **Dynamic Typing (JS)**: Types are associated with **values**, not variables. Type errors occur at **runtime** when code executes in production.
- **Static Typing (TS)**: Types are verified at **compile-time**. Type mismatches and missing properties trigger immediate compiler errors in your editor.

### Key Benefits:
1. Catches bugs early (null checks, typo properties, invalid arguments).
2. Supercharges IDE autocomplete, refactoring, and inline documentation.
3. Serves as self-documenting code contracts across teams.

Key Takeaway: TypeScript adds compile-time static type checking to JavaScript, catching errors before code runs in production.

Question 28

What are basic TypeScript types (primitive, tuple, enum, any, unknown, void, never)?

Accepted Answer

TypeScript adds explicit annotations for JavaScript primitives plus special types:

### Special Type Distinctions:
- **`any`**: Disables type checking completely. Allows any operation without safety.
- **`unknown`**: Type-safe counterpart of `any`. Must perform type checking/narrowing before operating on the value!
- **`void`**: Indicates a function does NOT return a value.
- **`never`**: Indicates a function **never returns** (e.g. throws an infinite loop or unconditional exception).
- **`Tuple`**: Fixed-length array with specific element types at specified indices (`[string, number]`).

Key Takeaway: Prefer unknown over any for untyped data. Use never for unreachable execution paths or throwing functions.

Question 29

What is the difference between type aliases and interfaces in TypeScript?

Accepted Answer

Both `type` and `interface` define shapes for objects and data, but have distinct capabilities:

### Interface (`interface Person {}`):
- Designed for **object shapes and OOP contracts**.
- Supports **Declaration Merging**: multiple interfaces with the same name in the same scope merge automatically.
- Extends via `extends` keyword (`interface Child extends Parent`).

### Type Alias (`type Person = {}`):
- Can alias **primitives, unions, tuples, mapped types, and functions** (`type ID = string | number;`).
- Cannot be declaration-merged!
- Combines via intersection operators (`type Child = Parent & { extra: boolean }`).

Key Takeaway: Use interface for object shapes and library public APIs (enabling declaration merging). Use type for unions and primitives.

Question 30

What are TypeScript type assertions (as, angle brackets) and non-null assertion operator (!)?

Accepted Answer

Type assertions inform the TypeScript compiler that you know more about a value's type than the automatic inference system does.

### Syntax Forms:
1. **`as Type`**: `const input = element as HTMLInputElement;` (Recommended).
2. **`!` (Non-null Assertion Operator)**: Postfix operator stating that a value is **definitely not `null` or `undefined`**.

### ⚠️ Critical Caution:
Assertions do **NOT perform runtime checks or data conversions**. If you assert incorrectly, TypeScript won't catch it, and runtime crashes will occur!

Key Takeaway: Type assertions bypass compiler type checks without runtime validation. Use runtime guard clauses whenever possible.

Question 31

What are closures in JavaScript and how do they capture variables?

Accepted Answer

A **closure** is a function that retains access to variables from its outer (enclosing) scope even after the outer function has finished executing.

### How It Works:
1. JavaScript uses **lexical scoping**: a function's scope is determined by where it is **defined**, not where it is **called**.
2. When an inner function references variables from an outer function, those variables are "closed over" — kept alive in memory.

### Common Patterns:
- **Data privacy**: Encapsulate state in closures instead of global variables.
- **Function factories**: Create specialized functions from a general template.
- **Memoization**: Cache results using a closure-enclosed Map.

Key Takeaway: Closures enable data privacy and function factories by retaining access to outer scope variables after execution.

Question 32

Explain the JavaScript Event Loop, microtasks, and macrotasks.

Accepted Answer

JavaScript is **single-threaded** with an **event loop** that processes tasks from multiple queues:

### Execution Order:
1. Execute current synchronous code on the **Call Stack**.
2. Process ALL pending **Microtasks** (Promise.then, queueMicrotask, MutationObserver).
3. Perform **Rendering** (layout, paint) if needed.
4. Pick ONE **Macrotask** (setTimeout, setInterval, I/O callbacks, UI events) and execute it.
5. Repeat from step 2.

### Key Insight:
Microtasks always run **before** the next macrotask. If you keep queueing microtasks, macrotasks and rendering are starved.

Key Takeaway: Microtasks (Promises) always execute before macrotasks (setTimeout) and before the next rendering frame.

Question 33

How does the this keyword work in JavaScript in different contexts?

Accepted Answer

The `this` keyword is determined dynamically by **how a function is called**, not where it is declared (except for arrow functions):

### 4 Binding Rules (in order of priority):
1. **`new` Binding**: `new Foo()` binds `this` to the newly instantiated object.
2. **Explicit Binding**: `fn.call(ctx)`, `fn.apply(ctx)`, or `fn.bind(ctx)` explicitly sets `this`.
3. **Implicit Binding**: Calling a method on an object (`obj.fn()`) binds `this` to `obj`.
4. **Default Binding**: Standalone function call (`fn()`) defaults to global object (or `undefined` in strict mode).

### Arrow Function Exception:
Arrow functions do NOT have their own `this`; they lexically inherit `this` from their outer scope.

Key Takeaway: this is determined dynamically at call-time by invocation context, except in arrow functions which use lexical scope.

Question 34

What are call(), apply(), and bind() and how do they change function execution context?

Accepted Answer

These three methods explicitly set the `this` context when executing functions:

### 1. `fn.call(thisArg, arg1, arg2, ...)`:
Invokes the function **immediately** with `thisArg` and individual arguments listed sequentially.

### 2. `fn.apply(thisArg, [arg1, arg2, ...])`:
Invokes the function **immediately** with `thisArg` and arguments passed as an **array**.

### 3. `fn.bind(thisArg, arg1, arg2, ...)`:
Does NOT execute immediately. Returns a **new bound function** permanently tied to `thisArg` and optional pre-filled arguments (partial application).

Key Takeaway: call passes args individually, apply passes args as an array, and bind returns a new bound function for deferred execution.

Question 35

How do Promise.all(), Promise.race(), Promise.allSettled(), and Promise.any() work?

Accepted Answer

### Promise Combinators:

1. **`Promise.all(promises)`**: Waits for ALL promises to fulfill. Rejects immediately if ANY one rejects.
2. **`Promise.allSettled(promises)`**: Waits for ALL promises to settle (fulfill or reject). Never short-circuits. Returns status and value/reason for each.
3. **`Promise.race(promises)`**: Returns the result of the FIRST promise to settle (fulfill or reject).
4. **`Promise.any(promises)`**: Returns the FIRST fulfilled promise. Ignores rejections unless ALL reject (throws AggregateError).

Key Takeaway: Use Promise.all for parallel dependent requests. Use Promise.allSettled when partial failure is acceptable.

Question 36

What is debouncing vs throttling for performance optimization?

Accepted Answer

### Debounce (Wait until silence):
Delays function execution until after a specified period of inactivity. If the event fires again before the timer ends, the timer resets.
- **Use case**: Search bar autocomplete, window resizing.

### Throttle (Fixed rate execution):
Limits function execution to at most once every N milliseconds, regardless of how many times the event fires.
- **Use case**: Scroll listeners, button click spam prevention, mouse movement tracking.

Key Takeaway: Debounce groups rapid events into a single execution after silence; throttle ensures steady execution at a fixed interval.

Question 37

How do WeakMap, WeakSet, and WeakRef prevent memory leaks?

Accepted Answer

In a standard `Map` or `Set`, stored object keys/values are held with a **strong reference**, preventing the garbage collector from freeing them even if all other references in the app are deleted.

### WeakMap & WeakSet:
- Hold **weak references** to object keys.
- Keys must be objects (or non-registered Symbols), never primitives.
- If there are no other references to a key object outside the WeakMap/WeakSet, the object is automatically **garbage collected** and removed from the collection.
- Not iterable (no `.keys()`, `.values()`, or `forEach`) because GC timing is non-deterministic.

Key Takeaway: Use WeakMap to attach metadata to objects without preventing garbage collection.

Question 38

What is JavaScript prototype inheritance and the prototype chain?

Accepted Answer

JavaScript objects inherit properties directly from other objects via a delegation mechanism called the **Prototype Chain**.

### Key Mechanisms:
1. Every object has an internal hidden link (`[[Prototype]]`, exposed via `Object.getPrototypeOf()`).
2. When accessing a property on an object:
   - JS checks if the property exists on the **instance object itself**.
   - If missing, JS looks up the **prototype object**, continuing up the chain until reaching `Object.prototype` and finally `null`.
3. Constructor functions have a `.prototype` property that becomes the `[[Prototype]]` for instances created with `new`.

Key Takeaway: Objects inherit methods via prototype delegation. Shared methods belong on constructor.prototype to avoid duplication.

Question 39

How do JavaScript Generators (function*) and Iterators work (Symbol.iterator)?

Accepted Answer

**Generators** are special functions declared with `function*` that can pause execution (`yield`) and resume later, maintaining state between invocations.

### Iterator Protocol:
An object is an iterator if it implements a `.next()` method returning `{ value: any, done: boolean }`.

### Iterable Protocol:
An object is iterable if it implements `[Symbol.iterator]()` returning an iterator. Enables `for...of` loops and spread operator.

Key Takeaway: Generators pause with yield and resume with next(). Implementing Symbol.iterator makes objects compatible with for...of loops.

Question 40

What is Event Bubbling, Event Capturing, and Event Delegation in JavaScript?

Accepted Answer

DOM events propagate through the document tree in **3 distinct phases**:

1. **Capturing Phase**: Event travels down from `window` to the target element.
2. **Target Phase**: Event arrives at the actual target element.
3. **Bubbling Phase**: Event bubbles back up from the target element to `window`.

### Event Delegation Pattern:
Instead of attaching individual event listeners to hundreds of child elements (e.g. list items), attach **ONE listener to a common parent**. Use `e.target` to identify which child triggered the event.

Key Takeaway: Event delegation handles clicks on dynamic or numerous child elements using a single parent listener via event bubbling.

Question 41

What are JavaScript ES6 Modules (import/export, default vs named, dynamic imports)?

Accepted Answer

ES6 Modules (ESM) provide official, standardized module support in modern JavaScript environments:

### Export Types:
- **Named Exports**: Multiple allowed per module (`export const foo = 1;`). Must be imported using exact matching names inside `{ foo }`.
- **Default Export**: Only one allowed per module (`export default App;`). Imported without curly braces using any local variable name.

### Dynamic `import(path)`:
Asynchronous function returning a Promise that resolves to the module. Enables **code-splitting** and lazy loading on demand.

Key Takeaway: Prefer named exports for clear imports. Use dynamic import() to lazy load code and reduce initial bundle size.

Question 42

How does deep cloning vs shallow cloning work in JavaScript (structuredClone, spread, JSON)?

Accepted Answer

### Shallow Copy (`{ ...obj }` / `Object.assign()`):
Copies top-level properties. Nested objects/arrays still share the **same reference memory**, so modifying nested properties mutates the original object!

### Deep Copy (Independent Clone):
Recursively copies all levels of objects and arrays.

### Deep Copy Options:
1. **`structuredClone(obj)`** (Modern Standard): Native browser API. Handles circular references, Date, Map, Set, ArrayBuffer.
2. **`JSON.parse(JSON.stringify(obj))`**: Legacy fallback. Fails on functions, undefined, Symbols, and circular references.

Key Takeaway: Use structuredClone() for deep copies of complex nested objects. Spread syntax only creates shallow copies.

Question 43

What is the difference between Symbol and string keys in JavaScript objects?

Accepted Answer

**Symbol** is a primitive data type that returns a guaranteed **unique and immutable** value.

### Key Use Cases:
1. **Non-Colliding Object Keys**: Avoid property name collisions when extending external library objects or mixing in traits.
2. **Hidden Properties**: Symbol keys are ignored by `Object.keys()`, `JSON.stringify()`, and `for...in` loops. (Retrieved via `Object.getOwnPropertySymbols()`).
3. **Well-Known Symbols**: Metaprogramming hooks built into JS (`Symbol.iterator`, `Symbol.hasInstance`, `Symbol.toPrimitive`).

Key Takeaway: Symbols create collision-proof unique object keys that are hidden from standard iteration methods.

Question 44

How do JavaScript Proxy and Reflect API enable meta-programming and object interception?

Accepted Answer

The **`Proxy`** object wraps another object (target) and intercepts low-level operations (property access, assignment, function invocation).

### Key Components:
- **Target**: The underlying object being proxied.
- **Handler**: An object containing "traps" (methods like `get`, `set`, `has`, `deleteProperty`).
- **`Reflect`**: Built-in object providing default internal methods to forward operations cleanly to the target.

### Applications:
Vue 3 reactivity engine, data validation, logging, negative array indexing, defaulting missing keys.

Key Takeaway: Proxy intercepts and modifies low-level object operations. Reflect forwards default operations safely.

Question 45

What is the Temporal Dead Zone (TDZ) in detail and how does the JS engine handle declarations?

Accepted Answer

The **Temporal Dead Zone (TDZ)** is the time window between entering a block scope and the line where a `let` or `const` variable is formally declared and initialized.

### Execution Engine Mechanics:
1. **Creation Phase**: When entering a block, the JS engine scans for `let`/`const` declarations and allocates memory bindings, but marks them as **uninitialized**.
2. **TDZ Window**: Accessing the variable before its declaration line triggers a `ReferenceError`.
3. **Initialization Line**: Once the execution reaches the declaration line, the variable exits TDZ and becomes accessible.

Key Takeaway: Variables declared with let and const exist in the Temporal Dead Zone from block entry until their explicit initialization line.

Question 46

How do async generators and for await...of loops work in JavaScript?

Accepted Answer

**Async Generators** combine generator functions (`function*`) with async/await, yielding Promises sequentially over time.

### Key Syntax:
- **Declaration**: `async function* generateStream()`.
- **Yielding**: `yield await fetchChunk()`.
- **Consumption**: Consumed using the `for await (const chunk of stream)` loop.

### Use Cases:
Streaming paginated API responses, processing large data files in chunks, WebSocket message feeds.

Key Takeaway: Use async generators and for await...of to stream asynchronous data chunks sequentially without loading everything into memory.

Question 47

What is the Web API vs JavaScript runtime engine (V8, JavaScriptCore)?

Accepted Answer

A JavaScript environment consists of two distinct components working together:

### 1. JavaScript Engine (V8, JavaScriptCore, SpiderMonkey):
Executes ECMAScript standard code. Contains:
- **Memory Heap**: Allocates memory for objects and variables.
- **Call Stack**: Single-threaded call stack that executes synchronous code instructions.

### 2. Host Environment Web APIs (Browser / Node.js APIs):
Capabilities provided by the runtime environment outside the JS engine standard:
- DOM Manipulation, `fetch()`, `setTimeout`, `console.log`, LocalStorage, WebSockets.
- Web APIs run tasks off the main thread and push callbacks into task queues when finished.

Key Takeaway: The JS engine executes core ECMAScript logic; host Web APIs supply async capabilities like fetch, timers, and DOM manipulation.

Question 48

How does error handling work in async JavaScript (try/catch, Promise .catch, global unhandledrejection)?

Accepted Answer

Error handling in asynchronous code requires dedicated patterns because async errors occur outside the call stack of the initiating function:

### Error Propagation Rules:
1. **Promises**: Uncaught errors inside a Promise executor automatically trigger the `.catch()` handler.
2. **`async/await`**: Rejections throw an exception that must be caught using `try...catch`.
3. **Global Safety Net**: Uncaught promise rejections trigger the `unhandledrejection` window event in browsers or process event in Node.js.

Key Takeaway: Always handle promise rejections with try/catch or .catch(). Register unhandledrejection listeners as a global safety net.

Question 49

What are JavaScript getters and setters in objects and classes?

Accepted Answer

**Getters (`get`)** and **Setters (`set`)** bind an object property to a function that executes when the property is read or written.

### Benefits:
1. **Encapsulation**: Perform data validation or transformations on property updates without changing external caller syntax.
2. **Computed Properties**: Expose dynamic computed values as standard object properties.
3. **Property Descriptors**: Configurable via `Object.defineProperty(obj, prop, descriptor)` to set `enumerable`, `configurable`, `writable`.

Key Takeaway: Getters and setters wrap property access with custom logic, allowing validation and computed values without modifying call syntax.

Question 50

How does JavaScript handle decimal precision issues (0.1 + 0.2 !== 0.3) and BigInt?

Accepted Answer

JavaScript numbers are double-precision 64-bit binary format IEEE 754 values:

### Floating Point Precision Issue:
Fractions like `0.1` cannot be represented exactly in binary floating-point.
- `0.1 + 0.2` evaluates to `0.30000000000000004`.
- Fix equality checks using `Math.abs(a - b) < Number.EPSILON`.

### Large Integers (`BigInt`):
Standard `Number` loses integer precision beyond `Number.MAX_SAFE_INTEGER` (`2^53 - 1` = `9007199254740991`).
- Use `BigInt` (`100n` or `BigInt("9007199254740993")`) for arbitrary precision integers.

Key Takeaway: Use Number.EPSILON to compare float calculations safely. Use BigInt for integers exceeding Number.MAX_SAFE_INTEGER.

Question 51

What are TypeScript Union and Intersection types and how do type guards work?

Accepted Answer

### Union Types (`A | B`):
A value that can be **either type A OR type B**. TypeScript only allows accessing properties shared by ALL members of the union until narrowed.

### Intersection Types (`A & B`):
Combines multiple types into one, requiring the value to satisfy **ALL features of type A AND type B simultaneously**.

### Type Narrowing (Type Guards):
Techniques to narrow down a broad union to a specific concrete type inside a conditional block:
1. `typeof val === 'string'`
2. `val instanceof Date`
3. `'key' in obj`

Key Takeaway: Unions represent OR types requiring narrowing; intersections represent AND types combining multiple interface contracts.

Question 52

How do TypeScript generics work in functions, interfaces, and classes?

Accepted Answer

**Generics** allow creating reusable components that work over a variety of types rather than a single fixed type, maintaining full static type safety. ### Generic Patterns: 1. **Generic Functions**: `function identity(arg: T): T {}` 2. **Generic Interfaces**: `interface ApiResponse { data: Data; status: number; }` 3. **Generic Constraints**: Restrict allowed generic types using `extends`: ``. Key Takeaway: Generics capture and enforce relationships between parameters and return types without resorting to any.

Question 53

What is TypeScript strict mode and what compiler flags are essential?

Accepted Answer

Enabling `"strict": true` in `tsconfig.json` turns on a suite of strict type-checking compiler behaviors that maximize type safety.

### Core Strict Compiler Flags:
1. **`strictNullChecks`**: `null` and `undefined` are not assignable to other types unless explicitly unioned (`string | null`). Prevents "cannot read property of null" runtime bugs!
2. **`noImplicitAny`**: Triggers an error whenever TypeScript cannot infer a type and defaults to `any`.
3. **`strictPropertyInitialization`**: Ensures class properties are initialized in the constructor or assigned default values.
4. **`strictFunctionTypes`**: Enforces strict bivariance checks on function parameters.

Key Takeaway: Always enable "strict": true in tsconfig.json to prevent runtime null pointer exceptions and implicit any fallbacks.

Question 54

What are TypeScript utility types (Partial, Required, Readonly, Record, Pick, Omit, Exclude, Extract)?

Accepted Answer

TypeScript includes built-in generic utility types that facilitate type transformations: | Utility Type | Description | |---|---| | `Partial` | Makes all properties of `T` optional. | | `Required` | Makes all properties of `T` mandatory. | | `Readonly` | Makes all properties of `T` read-only (immutable). | | `Record` | Constructs an object type with keys `K` and value types `T`. | | `Pick` | Selects a subset of properties `K` from `T`. | | `Omit` | Removes properties `K` from `T`. | | `Exclude` | Excludes types in `U` from union `T`. | | `Extract` | Extracts types in `U` from union `T`. | Key Takeaway: Use built-in utility types like Partial, Pick, Omit, and Record to avoid duplicating object type definitions.

Question 55

What are TypeScript Enums (numeric vs string vs const enums) and why prefer union types?

Accepted Answer

**Enums** allow defining a set of named constants:

### Enum Varieties:
1. **Numeric Enums**: Auto-incrementing numbers starting at 0 (`enum Direction { Up, Down }`). Generates reverse mapping objects in compiled JS.
2. **String Enums**: Values explicitly assigned strings (`enum Status { Active = 'ACTIVE' }`).
3. **Const Enums**: Inlined directly at compile-time (`const enum Color { Red }`); generates zero runtime JavaScript code object!

### Modern Best Practice (Unions vs Enums):
String literal union types (`type Status = 'active' | 'inactive';`) are usually preferred over Enums because they generate zero JS runtime code and interact cleanly with standard JS string literals.

Key Takeaway: Const enums inline values for zero JS output. String literal union types are often cleaner and simpler than traditional Enums.

Question 56

How do TypeScript custom Type Guards (is keyword) and Assertion Functions work?

Accepted Answer

Custom **Type Guards** are functions returning a boolean that instruct the TypeScript compiler to narrow a variable's type when the function returns `true`.

### 1. Type Predicate (`val is Type`):
Function return type signature stating: "If this function returns true, `val` is of type `Type`".

### 2. Assertion Signature (`asserts val is Type`):
Function signature stating: "If this function finishes executing without throwing an error, `val` is of type `Type`".

Key Takeaway: Custom type guards using "arg is Type" allow custom domain logic to narrow complex types across your application.

Question 57

What is index signature and record type in TypeScript?

Accepted Answer

When object property names are unknown in advance, **Index Signatures** define allowed key and value types:

### Syntax:
`interface Dictionary { [key: string]: number; }`

### `noUncheckedIndexedAccess` Compiler Flag:
By default, TS assumes index signature lookups always return values of type `T`. Enabling `noUncheckedIndexedAccess: true` in `tsconfig` forces indexed lookups to return `T | undefined`, protecting against accessing non-existent keys!

Key Takeaway: Use Record<K, T> or index signatures for dynamic dictionaries. Enable noUncheckedIndexedAccess for safe lookup types.

Question 58

How does declaration merging work in TypeScript interfaces?

Accepted Answer

**Declaration Merging** occurs when the TypeScript compiler automatically combines two or more separate declarations declared with the **same name** in the same scope into a single unified type definition.

### Characteristics:
- **Interfaces**: Properties from subsequent declarations merge into the original interface.
- **Namespaces**: Merge with classes or functions to attach static methods.
- **Global Module Augmentation**: Used to add custom properties to third-party or global interfaces (like `Window` or `Express.Request`).

Key Takeaway: Declaration merging allows extending existing interfaces across files, essential for augmenting global and library types.

Question 59

What are keyof and typeof type operators in TypeScript?

Accepted Answer

TypeScript includes two powerful type operators for querying shapes and keys:

### 1. `keyof` (Type Operator):
Takes an object type and produces a string or number **literal union of its property keys**.
- `type UserKeys = keyof User;` → `"id" | "name" | "email"`

### 2. `typeof` (In Type Position):
Refers to the **type** of a JavaScript variable or object instance within type annotations (distinct from JS runtime `typeof`).

Key Takeaway: typeof extracts the TypeScript type from a runtime value; keyof extracts a literal union of object keys.

Question 60

How do conditional types (T extends U ? X : Y) work in TypeScript?

Accepted Answer

Conditional types select one of two possible types based on a condition expressed as a type relationship test: ### Syntax: `type IsString = T extends string ? true : false;` ### Distributive Conditional Types: When conditional types act on a **naked generic type parameter** `T`, given a union type, the condition automatically **distributes over the union members**: - `IsString` resolves to `IsString | IsString` → `true | false`. Key Takeaway: Conditional types perform ternary checks at the type level. Naked generic unions automatically distribute across conditions.

Question 61

What is template literal types in TypeScript?

Accepted Answer

**Template Literal Types** build on string literal types, allowing type-level string manipulation and pattern matching using backtick template literal syntax. ### Key Capabilities: 1. **Union Expansion**: Combines multiple string literal unions into all possible permutations (`` ${Event}_${State} ``). 2. **Intrinsic String Helpers**: Built-in utilities: `Uppercase`, `Lowercase`, `Capitalize`, `Uncapitalize`. 3. **Pattern Matching**: Extracts substrings using conditional infer statements. Key Takeaway: Template literal types enable powerful type-level string permutations and domain-specific string format validation.

Question 62

What is the infer keyword in TypeScript conditional types?

Accepted Answer

The **`infer`** keyword can only be used inside the true/extends condition of a conditional type to **declare a temporary type variable** that TypeScript automatically infers from surrounding structure. ### Use Cases: - Extracting return types from functions (`ReturnType`). - Unwrapping resolved Promise values (`Awaited`). - Extracting array element types (`UnpackArray`). Key Takeaway: Use infer within conditional types to extract and unwrap nested type variables like Promise return types.

Question 63

What are indexed access types (T[K]) in TypeScript?

Accepted Answer

**Indexed Access Types** (or Lookup Types) allow looking up the specific type of a property on another type using bracket notation:

### Syntax:
`type Age = User['age'];`

### Features:
1. Lookup property types dynamically based on interface keys.
2. Look up union property types using union keys: `User['id' | 'name']`.
3. Look up array element types using number indexing: `MyArray[number]`.

Key Takeaway: Indexed access types (T[K] and Array[number]) extract child property types without creating redundant interfaces.

Question 64

How does satisfies operator work in TypeScript 4.9+?

Accepted Answer

Introduced in TypeScript 4.9, the **`satisfies`** operator validates that an expression matches a target type **without mutating or widening the inferred type** of the expression.

### The Problem With Type Annotations (`const obj: Type`):
Annotating an object widens properties to the general interface, losing specific literal types or missing optional key autocomplete.

### The `satisfies` Solution (`const obj = { ... } satisfies Type`):
Validates structure against `Type`, but retains the exact specific inferred literal types and property types of the object!

Key Takeaway: Use satisfies operator to validate that an object matches a contract while preserving exact property type inference.

Take JavaScript & TypeScript Skill Assessment Quiz

Showing 100 Questions

1. What are the differences between var, let, and const in JavaScript?

Temporal Dead Zone (TDZ):

Best Practice (2026):

2. What are the JavaScript data types and the difference between primitives and objects?

3. What is the difference between == (loose equality) and === (strict equality)?

4. What are the differences between function declarations, expressions, and arrow functions?

5. How do template literals and string interpolation work in JavaScript?

6. How does destructuring assignment work for objects and arrays in JavaScript?

7. What are rest parameters and the spread operator in JavaScript?

8. How do default parameter values work in JavaScript functions?

9. What are truthy and falsy values in JavaScript?

10. How do short-circuit evaluation and logical operators (&&, ||, ??) work?

11. What is the optional chaining operator (?.) and how does it prevent errors?

12. What is the nullish coalescing operator (??) vs Logical OR (||)?

13. What are common array iteration methods (map, filter, reduce, forEach, find)?

14. What is the difference between Array.prototype.slice() and Array.prototype.splice()?

15. How do JavaScript Object static methods (keys, values, entries, freeze, seal) work?

16. What is hoisting in JavaScript and how does it affect functions and variables?

17. What is scope in JavaScript (global, function, block, and lexical scope)?

18. What is the basic syntax and purpose of JavaScript Promises?

19. How does async/await work for handling asynchronous JavaScript code?

20. What is JSON and how do JSON.stringify() and JSON.parse() work?

21. What is the difference between primitive values passed by value and objects passed by reference?

22. How do JavaScript ES6 classes work (constructor, methods, extends, super)?

23. What is the typeof operator and how do you reliably check data types in JavaScript?

24. What is NaN, how is it checked, and why does NaN !== NaN?

25. What are JavaScript Set and Map objects and how do they differ from Arrays and Objects?

26. How do setTimeout and setInterval work and how do you clear them?

27. What is TypeScript and how does static typing differ from dynamic typing?

28. What are basic TypeScript types (primitive, tuple, enum, any, unknown, void, never)?

29. What is the difference between type aliases and interfaces in TypeScript?

30. What are TypeScript type assertions (as, angle brackets) and non-null assertion operator (!)?

31. What are closures in JavaScript and how do they capture variables?

32. Explain the JavaScript Event Loop, microtasks, and macrotasks.

33. How does the this keyword work in JavaScript in different contexts?

34. What are call(), apply(), and bind() and how do they change function execution context?

35. How do Promise.all(), Promise.race(), Promise.allSettled(), and Promise.any() work?

36. What is debouncing vs throttling for performance optimization?

37. How do WeakMap, WeakSet, and WeakRef prevent memory leaks?

38. What is JavaScript prototype inheritance and the prototype chain?

39. How do JavaScript Generators (function*) and Iterators work (Symbol.iterator)?

40. What is Event Bubbling, Event Capturing, and Event Delegation in JavaScript?

41. What are JavaScript ES6 Modules (import/export, default vs named, dynamic imports)?

42. How does deep cloning vs shallow cloning work in JavaScript (structuredClone, spread, JSON)?

43. What is the difference between Symbol and string keys in JavaScript objects?

44. How do JavaScript Proxy and Reflect API enable meta-programming and object interception?

45. What is the Temporal Dead Zone (TDZ) in detail and how does the JS engine handle declarations?

46. How do async generators and for await...of loops work in JavaScript?

47. What is the Web API vs JavaScript runtime engine (V8, JavaScriptCore)?

48. How does error handling work in async JavaScript (try/catch, Promise .catch, global unhandledrejection)?

49. What are JavaScript getters and setters in objects and classes?

50. How does JavaScript handle decimal precision issues (0.1 + 0.2 !== 0.3) and BigInt?

51. What are TypeScript Union and Intersection types and how do type guards work?

52. How do TypeScript generics work in functions, interfaces, and classes?

53. What is TypeScript strict mode and what compiler flags are essential?

54. What are TypeScript utility types (Partial, Required, Readonly, Record, Pick, Omit, Exclude, Extract)?

55. What are TypeScript Enums (numeric vs string vs const enums) and why prefer union types?

56. How do TypeScript custom Type Guards (is keyword) and Assertion Functions work?

57. What is index signature and record type in TypeScript?

58. How does declaration merging work in TypeScript interfaces?

59. What are keyof and typeof type operators in TypeScript?

60. How do conditional types (T extends U ? X : Y) work in TypeScript?

61. What is template literal types in TypeScript?

62. What is the infer keyword in TypeScript conditional types?

63. What are indexed access types (T[K]) in TypeScript?

64. How does satisfies operator work in TypeScript 4.9+?

65. What are mapped types with key remapping in TypeScript (as clause in mapped types)?

66. How do private class fields (#field) in ES2022 differ from TypeScript private access modifiers?

67. What is the override keyword and abstract classes in TypeScript?

68. How does module resolution (NodeNext, Bundler) work in TypeScript configuration?

69. What are Ambient Declarations (.d.ts) and declare global in TypeScript?

70. What are Type Narrowing strategies in TypeScript (in, instanceof, typeof, equality, discriminated unions)?

71. What are common JavaScript memory leaks and how do you detect them?

72. How do TypeScript generics, conditional types, and mapped types work?

73. What are TypeScript discriminated unions and exhaustive type checks?

74. How does JavaScript garbage collection work (mark-and-sweep, generational GC)?

75. What is the V8 engine compilation pipeline (Ignition, TurboFan, hidden classes)?

76. How do Web Workers and SharedArrayBuffer enable multi-threaded parallel execution in JavaScript?