A closure is a function that retains access to variables from its outer (enclosing) scope, even after the outer function has finished executing. Closures are created every time a function is created in JavaScript and are commonly used for data privacy and creating factory functions.

Hoisting is JavaScript's behavior of moving variable and function declarations to the top of their scope during compilation. Function declarations are fully hoisted, var declarations are hoisted but not their values, and let/const are hoisted but remain in a temporal dead zone.

A Promise is an object representing the eventual completion or failure of an asynchronous operation. It can be in one of three states: pending, fulfilled, or rejected. Promises provide cleaner async code than callbacks through .then(), .catch(), and .finally() methods.

What is the difference between null and undefined?

undefined means a variable has been declared but not assigned a value - it's the default state. null is an intentional assignment indicating 'no value' or 'empty'. typeof undefined returns 'undefined', while typeof null returns 'object' (a known JavaScript quirk).

async/await is syntactic sugar over Promises that makes asynchronous code look synchronous. An async function always returns a Promise, and await pauses execution until the Promise resolves. It simplifies error handling with try/catch blocks.

What is the difference between call() and apply()?

Both methods invoke a function with a specified 'this' context. The difference is in how arguments are passed: call() accepts arguments individually (fn.call(context, arg1, arg2)), while apply() accepts them as an array (fn.apply(context, [arg1, arg2])).

Scope determines the accessibility of variables in JavaScript. There are three types: global scope (accessible everywhere), function scope (accessible within a function), and block scope (accessible within curly braces, for let/const). Scope controls variable lifetime and prevents naming conflicts.

CORS (Cross-Origin Resource Sharing) is a security mechanism that allows or restricts web pages from making requests to a different domain than the one serving the page. Servers must include specific headers (Access-Control-Allow-Origin) to permit cross-origin requests.

JavaScript Interview Questions

Q: What is the difference between == and ===?

== (loose equality) performs type coercion before comparison, converting operands to the same type. === (strict equality) compares both value and type without conversion. Always prefer === to avoid unexpected type coercion bugs.

Q: What is the Event Loop?

The Event Loop is JavaScript's mechanism for handling asynchronous operations. It continuously monitors the call stack and callback queue, pushing queued callbacks to the stack when it's empty. This enables non-blocking behavior in single-threaded JavaScript.

Q: What is the Difference Between let and var?

var is function-scoped and hoisted to the top of its scope, while let is block-scoped and exists in a temporal dead zone until declared. let prevents accidental redeclaration and is preferred in modern JavaScript.

Q: What is prototypal inheritance?

Prototypal inheritance is JavaScript's mechanism where objects can inherit properties and methods from other objects through the prototype chain. Every object has an internal link to a prototype object, from which it can access inherited properties.

Q: What is Event Bubbling?

Event bubbling is the propagation pattern where an event triggered on a nested element 'bubbles up' through its ancestors in the DOM tree. When you click a button inside a div, the click event fires on the button first, then the div, then each parent element up to the document.