Asynchronous JavaScript

Question 1

What is a callback in JavaScript?

Answer 1

A callback is a function passed as an argument to another function and invoked after the parent function completes.

Question 2

What is a Promise in JavaScript?

Answer 2

A Promise represents a value that may be available now, later, or never, and handles asynchronous operations with then() and catch().

Question 3

What is async/await in JavaScript?

Answer 3

Async/await is syntactic sugar over Promises that allows writing asynchronous code in a synchronous style using the ‘async’ and ‘await’ keywords.

Question 4

What are the advantages of callbacks?

Answer 4

They are simple and foundational for asynchronous programming.

Question 5

What are the disadvantages of callbacks?

Answer 5

They can lead to ‘callback hell’, difficult debugging, and poor error handling.

Question 6

What are the advantages of Promises?

Answer 6

They improve readability, support chaining, and provide cleaner error handling.

Question 7

What are the disadvantages of Promises?

Answer 7

They can become hard to manage in deeply nested or conditional async flows.

Question 8

What are the advantages of async/await?

Answer 8

They simplify asynchronous code, avoid chaining, and are easier to read and debug.

Question 9

What are the disadvantages of async/await?

Answer 9

They require Promises under the hood and can cause blocking if misused.

Question 10

What is a best practice with callbacks?

Answer 10

Avoid deep nesting by breaking code into separate named functions.

Question 11

What is a best practice with Promises?

Answer 11

Always return Promises and handle both resolve and reject cases with then() and catch().

Question 12

What is a best practice with async/await?

Answer 12

Use try/catch blocks for error handling and avoid mixing with then()/catch().

Question 13

What is a use case for callbacks?

Answer 13

Used in older APIs like fs.readFile or event listeners in Node.js.

Question 14

What is a use case for Promises?

Answer 14

API calls, database queries, and file operations where sequencing and chaining are needed.

Question 15

What is a use case for async/await?

Answer 15

Handling complex flows with multiple asynchronous steps like HTTP requests inside loops.

Question 16

How do callbacks impact system design?

Answer 16

Can make codebase harder to scale and maintain due to nested structures and error propagation.

Question 17

How do Promises affect system design?

Answer 17

Encourage modular, predictable async workflows and help build more maintainable APIs.

Question 18

How does async/await affect system design?

Answer 18

Promotes clean, linear asynchronous flows but can lead to blocking if not handled carefully.

Question 19

Provide an example of a callback.

Answer 19

fs.readFile(‘file.txt’, (err, data) => { if (err) throw err; console.log(data); });

Question 20

Provide an example of a Promise.

Answer 20

fetch(‘url’).then(response => response.json()).then(data => console.log(data)).catch(err => console.error(err));

Question 21

Provide an example of async/await.

Answer 21

async function loadData() { try { const res = await fetch(‘url’); const data = await res.json(); console.log(data); } catch (err) { console.error(err); } }

Question 22

What are architectural implications of callbacks?

Answer 22

Callback-heavy codebases are hard to debug, test, and extend without introducing bugs or race conditions.

Question 23

What are architectural implications of Promises?

Answer 23

Allow separation of concerns and scalable abstraction of asynchronous logic.

Question 24

What are architectural implications of async/await?

Answer 24

Encourages synchronous-style structure for asynchronous logic, improving modularity and readability.

Question 25

How do callbacks perform under load?

Answer 25

They perform well but are harder to trace and debug, leading to more runtime errors.

Question 26

Are Promises fault-tolerant?

Answer 26

Yes, if implemented with proper catch blocks, Promises can isolate and propagate errors cleanly.

Question 27

Is async/await fault-tolerant?

Answer 27

Yes, when used with try/catch blocks, it provides clear and manageable error handling.

Question 28

How do you debug callbacks?

Answer 28

Use console logs, breakpoints, and name all functions to improve stack trace readability.

Question 29

How to monitor Promise-based flows?

Answer 29

Use async hooks, log Promise states, and track uncaught rejections with global handlers.

Question 30

What is a real-world tradeoff with callbacks?

Answer 30

Performance is high, but maintenance and scalability suffer.

Question 31

What is a real-world tradeoff with Promises?

Answer 31

Improves readability and flow control, but requires careful chaining to avoid nesting.

Question 32

What is a real-world tradeoff with async/await?

Answer 32

Improves clarity but may hide asynchronous behavior, causing unintentional blocking.

Question 33

Interview Question: What is callback hell and how do you avoid it?

Answer 33

Callback hell is deeply nested callbacks; it can be avoided with named functions, Promises, or async/await.

Question 34

Interview Question: What are the Promise states?

Answer 34

Pending, Fulfilled, and Rejected.

Question 35

Interview Question: What happens if you await a non-Promise value?

Answer 35

It gets implicitly wrapped in a resolved Promise.

Question 36

Interview Question: How do you handle errors in async/await?

Answer 36

Wrap the await call in a try/catch block.

Question 37

What is a common gotcha with callbacks?

Answer 37

Forgetting to handle errors or calling the callback multiple times.

Question 38

What is a gotcha with Promises?

Answer 38

Not returning from a .then() can break the Promise chain.

Question 39

What is a gotcha with async/await?

Answer 39

Forgetting to use 'await' can lead to unhandled Promise objects and bugs.