JavaScript Interview Questions & Answers for Freshers (2026)

var is function-scoped and hoisted (initialised as undefined); let and const are block-scoped and not usable before declaration (temporal dead zone). const cannot be reassigned (though objects it points to can still mutate). Prefer const, then let; avoid var.

== compares after type coercion (so "5" == 5 is true), while === compares value and type with no coercion (so "5" === 5 is false). Prefer === to avoid surprising bugs.

A closure is a function that remembers variables from the scope where it was created, even after that scope has returned. Closures power data privacy, function factories and callbacks. Example: a counter function that keeps a private count variable.

undefined means a variable has been declared but not assigned (the default). null is an intentional "no value" you assign yourself. typeof undefined is "undefined"; typeof null is "object" (a historical quirk).

Hoisting moves declarations to the top of their scope at compile time. Function declarations are fully hoisted; var declarations are hoisted but initialised as undefined; let/const are hoisted but stay in the temporal dead zone until declared.

JavaScript is single-threaded. The event loop runs synchronous code on the call stack, then processes the microtask queue (promises) and macrotask queue (setTimeout, events). This lets async work complete without blocking the main thread.

A promise represents a future value (pending → fulfilled/rejected). async/await is syntax sugar over promises: await pauses an async function until a promise settles, making async code read like synchronous code. Use try/catch for errors.

forEach runs a function per element and returns undefined (side effects). map returns a new array of transformed values. filter returns a new array of elements that pass a test. map and filter are pure and chainable.

"this" refers to the object that called the function. In a method it is the object; alone or in a regular function it is the global object (or undefined in strict mode); arrow functions do not bind their own this — they inherit it from the enclosing scope.

Arrow functions are shorter, do not have their own this/arguments (they inherit this lexically), and cannot be used as constructors. Regular functions have their own this determined by how they are called.

Instead of adding listeners to many child elements, you add one listener to a common parent and use event.target to detect which child was clicked. It improves performance and works for dynamically-added elements.