Question 20

Question

How would you handle asynchronous errors in an application without using promises or async/await?

Answer

While Promises and async/await offer a more structured approach to handling asynchronous operations, it's possible to manage asynchronous errors in JavaScript without them. Here's how:

1. Callback Functions:

• This is the traditional method predating Promises. When making an asynchronous call (e.g., network request), you pass a callback function as an argument.

• This function will be executed when the operation completes, receiving either the result or an error object.

function fetchData(url, callback) {
  // Simulate a network request with setTimeout
  setTimeout(() => {
    if (Math.random() < 0.8) { // 80% chance of success
      callback(null, "Data fetched successfully!");
    } else {
      callback("Network error occurred");
    }
  }, 1000);
}

fetchData('https://example.com/api', (error, data) => {
  if (error) {
    console.error("Error:", error);
  } else {
    console.log("Data:", data);
  }
});

2. Error Handling with try...catch Blocks:

• While try...catch is primarily used for synchronous errors, it can be incorporated within callback functions to handle potential asynchronous errors more explicitly.

function fetchData(url) {
  return new Promise((resolve, reject) => {
    // ... Network request logic ...
    if (error) {
      reject(error); // Reject the promise with an error
    } else {
      resolve(data); // Resolve the promise with data
    }
  });
}

fetchData('https://example.com/api')
  .then((data) => {
    console.log("Data:", data); 
  })
  .catch((error) => {
    console.error("Error:", error);
  });

Key Considerations:

• Callback Hell: Deeply nested callbacks can lead to "callback hell," making code difficult to read and maintain. This is where Promises and async/await shine, providing a cleaner structure for handling asynchronous operations.

• Error Propagation: Ensure errors are properly propagated through your application's call stack. In callback functions, this often involves passing an error object as the first argument to the nested callbacks.