Question 1

What is JavaScript?

Accepted Answer

JavaScript is a lightweight, interpreted (or Just-In-Time compiled) programming language with first-class functions. It is most famously known as the scripting language for web pages, enabling dynamic content, interactive behaviors, and complex client-side applications. Modern JavaScript engines (like Chrome's V8) do not merely interpret source code line-by-line; they perform Just-In-Time (JIT) compilation, translating JS source code into native machine code immediately before execution for high performance. JavaScript is dynamically typed, supports multi-paradigm styles (object-oriented, imperative, and functional), and operates on a single-threaded concurrency model.

Question 2

Is JavaScript synchronous or asynchronous?

Accepted Answer

JavaScript is a single-threaded, synchronous language by default, meaning it executes code line by line in a blocking fashion. However, it supports asynchronous, non-blocking behaviors by offloading operations to the host environment (like the browser or Node.js) and resolving their results using callbacks, promises, and async/await via the Event Loop. At its core, JavaScript has only one Call Stack. It cannot execute two statements simultaneously. When you perform an asynchronous task (like a network fetch, a file write, or a timer), JavaScript offloads this task to Web APIs (provided by the browser) or C++ APIs (provided by Node). Once completed, the task's callback enters the callback queue and is pushed back onto the call stack by the Event Loop once the stack is empty.

Question 3

What are data types in JavaScript?

Accepted Answer

JavaScript has two main categories of data types: Primitive Data Types (stored by value, immutable) and Non-Primitive/Reference Data Types (stored by reference, mutable). Primitive data types include: `string`, `number`, `boolean`, `undefined`, `null`, `symbol` (introduced in ES6 for unique object keys), and `bigint` (introduced in ES2020 for arbitrary-precision integers). Non-primitive data types include `object` (which encompasses standard objects, arrays, and functions).

Question 4

What is the difference between var, let, and const?

Accepted Answer

The primary differences are scope and re-assignment: `var` is function-scoped and can be redeclared and reassigned; `let` and `const` are block-scoped; `let` can be reassigned but not redeclared; `const` can neither be reassigned nor redeclared. `var` declarations are hoisted and initialized to `undefined`, which can lead to bugs. `let` and `const` are also hoisted but reside in the Temporal Dead Zone (TDZ) until their declaration line is executed, preventing early access. `const` creates a read-only reference, meaning while you cannot reassign a `const` variable, you can still mutate the properties of a `const` object or array.

Question 5

What is hoisting?

Accepted Answer

Hoisting is a default JavaScript behavior where the compiler moves variable and function declarations to the top of their containing scope during the compilation phase, before execution begins. Only declarations are hoisted, not initializations. 
- **Function declarations**: Fully hoisted, meaning you can call a function before its declaration in the source code.
- **var declarations**: Hoisted and initialized to `undefined`.
- **let & const declarations**: Hoisted but are not initialized, leaving them in the Temporal Dead Zone (TDZ) where accessing them before their declaration line throws a `ReferenceError`.

Question 6

What is closure?

Accepted Answer

A closure is the combination of a function bundled together with references to its surrounding state (its lexical environment). In simpler terms, a closure gives an inner function access to the variables of its outer function, even after the outer function has finished executing. Closures are created automatically whenever a function is declared in JS. They are commonly used to create private state variables, implement currying, and maintain data states in asynchronous callbacks or event handlers.

Question 7

What is the 'this' keyword?

Accepted Answer

In JavaScript, the `this` keyword refers to the object that is currently executing the active function. Its value is not static; it is determined dynamically at runtime based on *how* and *where* the function is called. The value of `this` is resolved using four main binding rules:
1. **Implicit Binding**: When a method is called as a property of an object, `this` points to that object.
2. **Explicit Binding**: Using `call()`, `apply()`, or `bind()` to manually force `this` to point to a specific object.
3. **New Binding**: When a constructor function is invoked with the `new` keyword, `this` points to the brand-new object being instantiated.
4. **Default Binding**: If none of the above apply, `this` defaults to the global object (`window` in browsers), or `undefined` in strict mode.

Question 8

What is an arrow function?

Accepted Answer

An arrow function is a concise syntax for writing function expressions introduced in ES6. In addition to being shorter, arrow functions do not bind their own `this`, `arguments`, `super`, or `new.target` contexts; instead, they inherit them lexically from their enclosing scope. Arrow functions are ideal for short callbacks, array transformations (like `map` or `filter`), and maintaining the outer lexical context of `this` without needing to write `.bind(this)` or `var self = this;`.

Question 9

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

Accepted Answer

The operator `==` (abstract equality) checks for equality after performing type coercion if the operands are of different types. The operator `===` (strict equality) checks for equality of both value and type without performing type coercion. When using `==`, JavaScript converts the operands to a common type before comparing them. This can lead to unexpected, non-intuitive outcomes (e.g., `0 == false` resolves to true). The strict equality operator `===` bypasses coercion entirely, ensuring that both the value and the underlying data type must match exactly.

Question 10

What is a callback function?

Accepted Answer

A callback function is a function that is passed as an argument to another function, with the expectation that the outer function will invoke it (call it back) at a later time or once an asynchronous operation completes. Callbacks are foundational for managing asynchronous flows in JavaScript, such as handling DOM event triggers, network request completions, or processing array elements using iterators like `forEach` and `map`.

Question 11

What are promises?

Accepted Answer

A Promise is an object representing the eventual completion (or failure) of an asynchronous operation and its resulting value. It acts as a placeholder for a value that is not necessarily known when the promise is created. A Promise exists in one of three mutually exclusive states:
1. **Pending**: Initial state, neither fulfilled nor rejected.
2. **Fulfilled**: The operation completed successfully, and `resolve()` was triggered.
3. **Rejected**: The operation failed, and `reject()` was triggered.
Promises enable clean, chainable asynchronous sequences using `.then()`, `.catch()`, and `.finally()` blocks, resolving the nested indentation problem known as Callback Hell.

Question 12

What is async/await?

Accepted Answer

Async/await is a syntactic sugar introduced in ES2017 (ES8) built on top of Promises. It allows developers to write asynchronous, non-blocking code that looks and behaves like synchronous, sequential code, significantly improving readability. Marking a function with the `async` keyword forces it to automatically return a Promise. The `await` keyword can only be used inside an `async` function; it pauses function execution until the targeted Promise resolves or rejects, returning the resolved value inline without blocking the main browser UI thread.

Question 13

What is event bubbling?

Accepted Answer

Event bubbling is a phase of event propagation in the HTML DOM where an event triggered on a specific target element 'bubbles up' or propagates upwards through its parent elements in the nesting hierarchy (target -> parent -> body -> html -> document) until it reaches the root. By default, almost all standard browser events bubble. This means if you click a button nested inside a `div` which is inside a `form`, and all three have click listeners, the button's listener fires first, followed by the `div`'s listener, and finally the `form`'s listener. You can halt this upward propagation by calling `event.stopPropagation()`.

Question 14

What is event capturing?

Accepted Answer

Event capturing (also known as trickling) is the initial phase of event propagation where the event starts at the top-level root element of the DOM (document) and travels downwards through the nested parent elements until it reaches the specific target element that triggered the event. By default, `addEventListener` registers listeners for the bubbling phase. To register a listener for the capturing phase instead, you must pass `true` (or `{ capture: true }`) as the optional third parameter to the `addEventListener` method. During event execution, the capturing phase occurs first, followed by the target phase, and finally the bubbling phase.

Question 15

What is the DOM?

Accepted Answer

The DOM (Document Object Model) is a programming interface for HTML and XML documents. It represents the structure of a web document as a hierarchical tree of objects, allowing programming languages (like JavaScript) to access, manipulate, and update the document's structure, style, and content dynamically. When a browser loads a web page, it parses the HTML and creates a tree-like object structure representing it. Each HTML tag, attribute, and text snippet becomes a Node object in this tree. JavaScript uses DOM methods (like `querySelector`, `createElement`, `appendChild`) to select and modify these nodes dynamically at runtime.

JavaScript Core Interview Prep Portal

What is JavaScript?

Is JavaScript synchronous or asynchronous?

What are data types in JavaScript?

What is the difference between var, let, and const?

What is hoisting?

What is closure?

What is the 'this' keyword?

What is an arrow function?

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

What is a callback function?

What are promises?

What is async/await?

What is event bubbling?

What is event capturing?

What is the DOM?

What is the difference between null and undefined?

What is NaN?

What is the spread operator?

What is the rest operator?

What is destructuring?

What is an IIFE?

What are JavaScript arrays?

What is the difference between map, filter, and reduce?

What is a prototype?

What is prototype chaining?

What is a memory leak?

What is setTimeout?

What is setInterval?

What is JSON?

What is the difference between call, apply, and bind?

What is currying?

What is debouncing?

What is throttling?

What is strict mode?

What is lexical scope?

What is an object?

What is the difference between shallow and deep copy?

What is localStorage?

What is sessionStorage?

What is event delegation?

What is a module?

What is typeof operator?

What is garbage collection?

What is the temporal dead zone?

What is optional chaining?

What is a promise chain?

What is the event loop?

What are higher-order functions?

What is memoization?

What is a JavaScript engine?

JavaScript Core
Interview Prep Portal