JavaScript interview questions covering callbacks, Promises, async and await, Promise combinators, Fetch API, HTTP handling, modules and modern asynchronous JavaScript.
Open a question for the full answer, code and interview guidance.
A callback is a function passed to another function so it can be executed later or as part of that function's operation. Callbacks are fundamental to JavaScript APIs such as event handling, timers, array methods, and asynchronous operations.
Callback hell describes deeply nested callback-based asynchronous code that becomes difficult to read, maintain, test, and handle errors in. It often appears when each asynchronous operation depends on the result of the previous operation.
A Promise is an object representing the eventual completion or failure of an asynchronous operation. It allows code to register handlers for a future result instead of nesting callbacks.
A Promise starts as pending. It becomes fulfilled when the operation succeeds and resolve is used, or rejected when the operation fails and reject is used.
then registers handlers for successful Promise results and returns a new Promise, enabling chaining. catch registers a rejection handler and is effectively a convenient way to handle errors from the preceding chain.
Promise chaining connects asynchronous operations by returning a value or another Promise from a then callback. Each subsequent then receives the resolved result of the previous stage.
async/await is syntax built on top of Promises that allows asynchronous code to be written in a more sequential style. An async function always returns a Promise.
Yes. Calling an async function always returns a Promise. If the function returns an ordinary value, JavaScript fulfills the returned Promise with that value.
Use try/catch around awaited operations when the function should handle a rejection locally. The catch block receives the thrown rejection reason, which is commonly an Error object.
Sequential code waits for one independent operation to finish before starting the next, increasing total latency. Parallel initiation starts independent operations before waiting for their combined results.
Promise.all accepts an iterable of values or Promises and returns a Promise that fulfills when all inputs fulfill. The fulfilled result is an array preserving the input order.
Promise.allSettled waits until every supplied Promise has settled, whether fulfilled or rejected. It returns an array of result objects containing a status and either a value or reason.
Promise.race settles as soon as the first input Promise settles, whether that first result is fulfillment or rejection. Promise.any fulfills as soon as any input fulfills and ignores earlier rejections while a possible fulfillment remains.
fetch starts an HTTP request and returns a Promise that fulfills with a Response object when an HTTP response is received. The response body can then be read with methods such as json, text, blob, or arrayBuffer.
Pass an options object containing method, headers, and body. When sending JSON, set Content-Type to application/json and serialize the JavaScript value with JSON.stringify.
Use AbortController. Pass the controller's signal to fetch, then call controller.abort when the request should be canceled.
JSON is a text data format commonly used for API communication and storage. JSON.stringify converts supported JavaScript values into JSON text, while JSON.parse converts valid JSON text into a JavaScript value.
Optional chaining safely accesses a property, element, or method when the value to the left may be null or undefined. If that value is nullish, evaluation stops and the expression returns undefined instead of throwing a property-access error.
The nullish coalescing operator returns its right-hand operand only when the left-hand operand is null or undefined. Values such as 0, false, and an empty string are preserved.
The logical OR operator returns the right operand when the left operand is falsy. Nullish coalescing returns the right operand only when the left operand is null or undefined.
ES modules are the standardized JavaScript module system based on export and import syntax. Modules let applications split code into reusable files with explicit dependencies.
A module can have multiple named exports, which are imported using their exported names unless aliases are used. A module can also have one default export, which the importing module may bind to a locally chosen name.
Dynamic import() loads a module asynchronously and returns a Promise for the module namespace object. Unlike a static import declaration, it can be invoked conditionally at runtime.
Strict mode enables a stricter set of JavaScript runtime rules that convert some silent mistakes into errors and change certain legacy behaviors. It can be enabled for classic scripts or individual functions with "use strict".
Prefer Promises and async/await for asynchronous control flow, and use try/catch or explicit Promise rejection handling at appropriate boundaries. Run independent I/O concurrently when it improves latency, but do not start uncontrolled amounts of work without considering resource limits.