异步方法抛出的错误无法捕获，forEach中async与await冲突问题求解

Hey there, let's break down why your error isn't being caught and fix it step by step.

Why the error slips through your try/catch #

1. forEach doesn't handle async callbacks properly
   When you pass an async function to forEach, each callback runs as an independent asynchronous task. forEach doesn't wait for these async callbacks to finish, and it ignores the Promises they return. That means any error thrown in method3 (which turns the async callback's Promise into a rejected state) never propagates up to your try/catch in method1—it becomes an unhandled Promise rejection instead.

2. Redundant new Promise wrapper in method1
   Your method1 is already marked as async, which means it automatically returns a Promise. Wrapping it in another new Promise(async (...) => { ... }) is unnecessary and can muddle error handling, since you're mixing two separate ways of managing Promise states.

Fix 1: Use for...of for sequential async execution #

for...of plays nicely with async/await, waiting for each iteration to complete before moving to the next. This lets errors bubble up to your outer try/catch as expected.

Here's the revised code:

class A { 
  async method1(A, B) { 
    try { 
      await this.method2(A, B); 
    } catch (error) { 
      console.log(error, "error"); 
    }
  } 

  async method2(A, B, C) { 
    await somethingelsecalled(); 
    // Replace forEach with for...of (use your actual array variable instead of 'Array')
    for (const [index, segment] of yourArray.entries()) { 
      const result = await somethingcalled(); 
      this.method3(result); // Sync errors here will bubble up to the outer try/catch
    } 
  } 

  method3(result) { 
    throw "error"; 
  } 
}

Fix 2: Use Promise.all for parallel async execution #

If you want all the async tasks in method2 to run in parallel (instead of one after another), use map to collect all the Promises from the callbacks, then Promise.all to wait for them all. Any rejected Promise will trigger the outer catch.

class A { 
  async method1(A, B) { 
    try { 
      await this.method2(A, B); 
    } catch (error) { 
      console.log(error, "error"); 
    }
  } 

  async method2(A, B, C) { 
    await somethingelsecalled(); 
    // Collect all async operations into Promises
    const asyncTasks = yourArray.map(async (segment, index) => { 
      const result = await somethingcalled(); 
      this.method3(result); 
    }); 
    // Wait for all tasks to complete (or catch any rejection)
    await Promise.all(asyncTasks); 
  } 

  method3(result) { 
    throw "error"; 
  } 
}

Key Takeaways #

• Ditch the redundant new Promise in method1: Async functions automatically return Promises, so your try/catch will handle errors and convert them to rejected Promises correctly.
• Avoid forEach for async work: Use for...of for sequential async tasks, or Promise.all + map for parallel tasks to ensure errors are propagated and caught.
• Sync errors in async contexts: When you throw a sync error inside an async function (like calling method3 in your async callback), it gets automatically wrapped into a rejected Promise, which can be caught by your outer try/catch.

内容的提问来源于stack exchange，提问作者Srikanth Doddi