JavaScript Interview Questions

Primitive types: String, Number, BigInt, Boolean, Undefined, Symbol, and Null. Non-primitive (reference) type: Object (includes Arrays and Functions).

undefined means a variable is declared but entirely unassigned. null is a deliberate assignment representing 'no value' or an empty state.

== only compares values, performing automatic type coercion natively. === strictly compares both the value and the exact data type.

Hoisting is JS's native behavior of shifting variable and function declarations logically to the top of their scope before code execution starts.

A closure natively allows a function to remember and access its outer variables even after the outer function finishes. Example: Generating private module variables.

The period specifically between entering a block scope and the exact line where a let or const variable is officially declared, blocking early access.

call explicitly executes a function passing arguments individually. apply strictly requires an array of arguments. bind persistently returns a new locked function.

this strictly points to the object currently executing the function natively. Arrow functions permanently lock this to their immediate surrounding lexical scope.

Arrow functions natively lack their own this, arguments, and cannot be used as Constructors. They perfectly handle lexical scoping implicitly.

It cleanly unpacks values from arrays (const [a, b] = arr) or properties from objects (const { id } = obj) directly into distinct variables natively.

Promises represent the eventual completion or failure of an asynchronous operation, actively preventing callback hell by chaining cleanly via .then() and .catch().

It acts purely as syntactic sugar over Promises, gracefully allowing asynchronous, non-blocking code to natively read structurally identical to synchronous functions.

all perfectly awaits everything or fails instantly. race explicitly returns the fastest outcome natively. allSettled waits completely regardless of failures. any reliably returns the first success.

map structurally transforms every item individually. filter conditionally drops items. reduce powerfully accumulates the entire array down seamlessly into a single value.

flat() natively collapses nested multi-dimensional arrays cleanly. flatMap() uniquely maps elements first, then inherently flattens the result by one strict level.

Most accurately by using obj.hasOwnProperty('key') or the modern Object.hasOwn(obj, 'key'). The in operator implicitly checks prototype chains too.

It persistently coordinates asynchronous execution. It inherently checks if the Call Stack is empty, subsequently pushing pending Callbacks strictly from the Task Queue.

The Microtask Queue (handling strictly Promises and MutationObservers) natively holds supreme execution priority, definitively running completely before the standard Macrotask Queue.

It universally attaches one single smart event listener cleanly to a parent element natively specifically to handle interactions actively originating from dynamic child bubbled events.

Bubbling inherently flows actions upwards progressively from explicitly clicked child to parent. Capturing uniquely intercepts directly from document root downwards strictly to the target.

Debouncing essentially prevents a function from firing natively until a specified idle duration completes. Brilliant primarily for structurally throttling auto-save actions or search inputs.

Throttling unconditionally forces a function exclusively to execute exactly once per specified time interval continuously natively (like aggressively handling scroll/resize events).

ES6 class fundamentally acts completely purely as semantic syntactic sugar wrapped definitively over JS's native invisible prototypical inheritance functions explicitly identically.

It bizarrely returns 'object'. It is a widely documented historical JS specifically unfixable bug maintained strictly for absolute global backwards compatibility naturally.

Because fundamentally JavaScript structurally relies explicitly entirely on strictly IEEE 754 floating-point natively naturally causing microscopic rounding precision artifacts inherently predictably.