JavaScript

How JavaScript keeps track of function execution.

Strict Equality (== vs ===)

Why you should never use double equals.

Execution Context

The environment where JavaScript evaluates and executes code.

Hoisting

Why variables and functions seem to move to the top.

Lexical Scope

How the physical location of code dictates access.

null vs undefined

Understanding the two empty states in JavaScript.

Primitive vs Reference Types

How memory determines variable assignment.

Scope

The rules for finding variables.

Strict Mode

Opting into a safer JavaScript engine.

Temporal Dead Zone (TDZ)

Why let and const are safer than var.

Truthy and Falsy

How JavaScript evaluates non-booleans in conditional statements.

Type Coercion

JavaScript's automatic data type conversion.

2. Functions

Arrow Functions

A shorter syntax and lexical `this` binding.

call, apply, and bind

Manually manipulating the `this` keyword.

Closures

Functions remembering where they were born.

Currying

Transforming multiple arguments into a sequence of functions.

Function Declarations vs Expressions

The two ways to create functions and their hoisting behaviors.

Higher-Order Functions

Treating functions as data.

Immediately Invoked Function Expressions (IIFE)

Functions that run the moment they are created.

The 'this' Keyword

The most confusing keyword in JavaScript.

3. Objects

Prototypes

How JavaScript objects inherit features.

The Prototype Chain

The mechanism for property lookup and inheritance.

Classes

Syntactic sugar over prototypal inheritance.

Object Copying (Shallow vs Deep)

How to properly duplicate data structures.

Property Descriptors

The hidden configuration behind every object property.

4. Async

The Event Loop

How single-threaded JavaScript handles concurrency.

Promises

The modern object for managing asynchronous success and failure.

Microtasks vs Tasks (Macrotasks)

The priority lanes of the Event Loop.

Async / Await

Syntactic sugar that makes Promises look synchronous.

Promise Combinators

Handling multiple Promises simultaneously.

5. Runtime

Memory Management (Stack vs Heap)

Where JavaScript stores your variables.

Garbage Collection

How JavaScript automatically cleans up memory.

JavaScript Performance

How V8 optimizes JavaScript and how to avoid de-optimizations.

6. Modern JS

Modules (ESM vs CommonJS)

How JavaScript breaks code into reusable files.

Iterators and Iterables

The protocol behind `for...of` loops and the Spread Operator.

Generators

Functions that can pause and resume their execution.

Symbols

Creating guaranteed unique identifiers.

7. Coding Interviews

Debounce

Delaying execution until the user stops acting.

Throttle

Enforcing a strict execution speed limit.

Deep Clone

Implementing a recursive object copier.

Implement Promise.all

Rebuilding the core async combinator from scratch.

Concurrency Limiter

Executing massive promise arrays without crashing the server.

8. Output Based

Output: Closures

Tricky outputs designed to test Closure mechanics.

Output: Hoisting

Tricky outputs designed to test execution phases.

Output: The 'this' Keyword

Tricky outputs designed to test execution context binding.

Output: Event Loop

Tricky outputs testing Macrotasks vs Microtasks.

9. Senior

Senior JavaScript Interview Questions

High-level concepts designed to test deep runtime understanding.