Lära Robust Async Error Handling Patterns | Error Handling and Advanced Narrowing


              12345678910111213141516171819202122232425262728293031323334
            
async function processBatch(tasks: (() => Promise<any>)[]): Promise<{ results: any[]; errors: Error[] }> {
  const results: any[] = [];
  const errors: Error[] = [];

  await Promise.all(
    tasks.map(async (task, i) => {
      try {
        const result = await task();
        results[i] = result;
      } catch (err) {
        if (err instanceof Error) {
          errors[i] = err;
        } else {
          errors[i] = new Error("Unknown error");
        }
      }
    })
  );

  return { results, errors };
}

// Example usage:
const tasks = [
  async () => "Task 1 complete",
  async () => { throw new Error("Task 2 failed"); },
  async () => "Task 3 complete",
  async () => { throw "Non-Error thrown"; },
];

processBatch(tasks).then(({ results, errors }) => {
  console.log("Results:", results);
  console.log("Errors:", errors.map(e => e.message));
});

When you run a batch of asynchronous operations, a single unhandled error can cause the entire process to fail, leading to cascading failures and a poor user experience. By handling errors individually, you ensure that one failure does not prevent other operations from completing successfully. This pattern is especially important in applications where partial results are valuable, such as processing multiple user uploads or fetching data from several sources.

Robust error handling in asynchronous contexts improves reliability and user confidence. By collecting errors and results separately, you can provide users with detailed feedback on which operations succeeded or failed, rather than a generic error message. This approach also makes troubleshooting and recovery easier, since you can distinguish between recoverable and irrecoverable failures.

Narrowing errors in a catch block using instanceof Error is safer than assuming all thrown values are Error objects. JavaScript allows throwing any value—including strings, numbers, or even objects that do not inherit from Error. If you attempt to access properties like message on a non-Error value, you risk runtime exceptions that can mask the original problem. Using instanceof Error ensures that you only handle true error objects as expected, and you can wrap unknown values in a new Error to maintain consistency in your error reporting.

Var allt tydligt?

Tack för dina kommentarer!

Avsnitt 3. Kapitel 5

Fråga AI

Fråga vad du vill eller prova någon av de föreslagna frågorna för att starta vårt samtal

Awesome!

Completion rate improved to 5.88

Svep för att visa menyn


              12345678910111213141516171819202122232425262728293031323334
            
async function processBatch(tasks: (() => Promise<any>)[]): Promise<{ results: any[]; errors: Error[] }> {
  const results: any[] = [];
  const errors: Error[] = [];

  await Promise.all(
    tasks.map(async (task, i) => {
      try {
        const result = await task();
        results[i] = result;
      } catch (err) {
        if (err instanceof Error) {
          errors[i] = err;
        } else {
          errors[i] = new Error("Unknown error");
        }
      }
    })
  );

  return { results, errors };
}

// Example usage:
const tasks = [
  async () => "Task 1 complete",
  async () => { throw new Error("Task 2 failed"); },
  async () => "Task 3 complete",
  async () => { throw "Non-Error thrown"; },
];

processBatch(tasks).then(({ results, errors }) => {
  console.log("Results:", results);
  console.log("Errors:", errors.map(e => e.message));
});

Var allt tydligt?

Tack för dina kommentarer!

Avsnitt 3. Kapitel 5