Full Stack Developer interview questions

var is function-scoped and hoisted, while let and const are block-scoped.

• var: hoisted to the top of its function and accessible before its declaration line
• let and const: block-scoped and not accessible before declaration
• let allows reassignment, const does not, though const objects can still be mutated
• Default to const, use let only when reassignment is genuinely needed

A closure is a function that keeps access to its outer scope variables after that function returns.

• Retains outer lexical scope variables even after the outer function returns
• Example: a counter factory returns an inner function that increments a private count
• Each call to the factory creates an independent counter
• Foundation of memoization, module patterns, and stateful event handlers

Node.js runs JavaScript on a single thread but offloads I/O so it never blocks.

• Delegates I/O like file reads and network requests to the OS or libuv's thread pool
• A completed async operation puts its callback in the event loop queue
• The event loop runs that callback once the call stack is empty
• Lets Node.js handle thousands of concurrent connections without blocking

== compares after type coercion, while === checks value and type without coercion.

• == coerces types first, so 0 == false is true
• === checks both value and type, so 0 === false is false
• Prefer === in production to avoid bugs from implicit conversion

A Promise represents the eventual result of an asynchronous operation.

• Has three states: pending, fulfilled, or rejected
• You chain .then() and .catch() to handle the outcome
• async/await is sugar over Promises that reads like synchronous code
• Errors are handled with try/catch instead of chained handlers

A higher-order function takes a function as an argument, returns one, or both.

• map, filter, and reduce are common examples
• map takes a callback and applies it to every element, returning a new array of the same length
• Enables composable, reusable logic
• Central to functional programming patterns in JavaScript

undefined means a value was never set, while null is an intentional empty value.

• undefined: default for a declared but unassigned variable or a missing function parameter
• null: a deliberate assignment marking the absence of a value
• Both are falsy
• typeof undefined is 'undefined' but typeof null is 'object', a historical quirk

Destructuring extracts array values or object properties into separate variables concisely.

• Works on both arrays and objects, pulling fields into distinct variables
• Example: const { name, age } = user pulls fields directly without separate accesses
• Reduces repetitive property access
• Especially handy with function parameters, API responses, and React props

An interface describes an object's shape, while a type alias can describe any type.

• Interfaces can be extended or implemented by classes, and same-name interfaces merge automatically
• Type aliases cover unions, primitives, and tuples, not just objects, with no declaration merging
• Prefer interfaces for extendable object shapes
• Prefer type aliases for union and computed types

TypeScript infers a variable's type from its initial value.

• const count = 0 is typed number without an explicit annotation
• Inference also covers function return types and generic parameters
• It applies to destructured values too
• Reduces annotation boilerplate while keeping full type safety

Spread expands an iterable into individual elements, while rest collects arguments into an array.

• Spread combines arrays with [...arr1, ...arr2] or clones objects with { ...original, key: newValue }
• Rest uses the same syntax in function definitions, like function sum(...numbers)
• Both appear constantly in React state updates and utility function signatures

Every JavaScript object links to a prototype object, forming a chain.

• Accessing a property walks up the prototype chain until found or it reaches null
• ES6 classes are syntactic sugar over this prototype chain
• They do not add a traditional class-based model like Java or C#

Synchronous code blocks the thread until each operation finishes, asynchronous code does not.

• Synchronous runs line by line, which can freeze the UI or server on long tasks
• Asynchronous starts an operation and keeps running other code while waiting
• Results arrive via a callback, Promise, or async/await
• Nearly all I/O like database queries and HTTP calls must be async to avoid blocking

CommonJS uses require and runs synchronously, while ES Modules use import and support tree shaking.

• CommonJS: require() and module.exports, synchronous, the legacy Node.js default
• ES Modules: import and export, static analysis and tree shaking, the current standard
• The module format affects how imports resolve and how unused code is eliminated when bundling

A callback is a function passed to another function to run when an async operation finishes.

• Passed as an argument and called once the operation completes
• Nesting callbacks several levels deep creates callback hell that is hard to read and maintain
• Promises and async/await flatten this nesting and restore a readable sequential flow

Generics let you write reusable code that works with different types while keeping type safety.

• Example: identity<T>(value: T): T accepts any type and returns the same type
• No type information is lost in the process
• Common in utility types, data fetching wrappers, and reusable React component APIs
• Useful when the exact type is unknown at the time of writing

map transforms, filter selects, and reduce accumulates.

• map transforms every element and returns a new array of the same length
• filter returns only elements that pass a predicate, possibly shorter than the original
• reduce accumulates all elements into a single value like a sum, object, or array

Optional chaining safely reads nested properties, and nullish coalescing supplies defaults only for null or undefined.

• ?. returns undefined instead of throwing when an intermediate value is null or undefined, like user?.address?.city
• ?? returns the right side only when the left is null or undefined, unlike || which also triggers on 0 or empty strings
• Combined, user?.name ?? 'Anonymous' gives clean and safe default logic

The virtual DOM is a lightweight JavaScript object tree mirroring the real DOM.

• On state change, React builds a new virtual tree and diffs it against the previous snapshot
• It then applies only the minimal set of real DOM mutations needed
• Faster than touching the real DOM on every change, since DOM operations are costly
• Frees developers from manually tracking which elements need updating

A controlled component keeps its value in React state, an uncontrolled one keeps it in the DOM.

• Controlled: React is the single source of truth, every keystroke triggers a state update and re-render
• Uncontrolled: the value lives in the DOM, read via a ref when needed, without React state
• Controlled components give predictable behavior and easier validation
• Uncontrolled components are simpler for cases like file inputs