JavaScript is essential for both frontend and backend development. This guide covers the core concepts and advanced features you need to master for any JavaScript interview.

Core JavaScript Concepts

A closure is a function that has access to variables from its outer scope even after the outer function has returned. Closures enable data privacy, function factories, and maintaining state.

function counter() {
  let count = 0; // Private variable
  return {
    increment: () => ++count,
    decrement: () => --count,
    getCount: () => count
  };
}
const myCounter = counter();
myCounter.increment(); // 1
myCounter.increment(); // 2

The event loop handles async operations in JavaScript. It continuously checks the call stack and callback queues. Microtasks (Promises) have priority over macrotasks (setTimeout). Understanding this is crucial for predicting code execution order.

JavaScript uses prototypal inheritance - objects inherit directly from other objects through the prototype chain. Every object has a [[Prototype]] that references another object. Methods and properties are looked up the prototype chain.

ES6+ Features

Promises represent future values with three states: pending, fulfilled, rejected. async/await is syntactic sugar making async code look synchronous. Use try/catch for error handling with async/await.

Advanced JavaScript

Debounce delays execution until after a pause in events (e.g., search input). Throttle limits execution to once per time interval (e.g., scroll events). Both optimize performance for frequent events.

// Debounce implementation
function debounce(fn, delay) {
  let timeoutId;
  return (...args) => {
    clearTimeout(timeoutId);
    timeoutId = setTimeout(() => fn(...args), delay);
  };
}

// Throttle implementation
function throttle(fn, limit) {
  let inThrottle;
  return (...args) => {
    if (!inThrottle) {
      fn(...args);
      inThrottle = true;
      setTimeout(() => inThrottle = false, limit);
    }
  };
}