在 javascript 异步错误处理中，`catch` 捕获 promise 链深层错误的核心做法是将其放置在链的末尾。由于 promise 具有错误冒泡机制，任何前置 `.then()` 或 `await` 抛出的异常都会沿着链向后传递，直到遇到第一个 `.catch()` 处理器。只要确保 `.catch()` 位于所有业务逻辑之后，它就能统一拦截并处理整个链中发生的任何未捕获异常。
.then() 链中 throw 如何传递给后续 catch
当在 .then() 的回调函数中显式抛出错误时，该错误会立即终止当前 Promise 的状态变为 rejected，并跳过后续所有的 .then()，直接流向最近的 .catch()。这种机制允许我们在中间步骤进行错误隔离，而不必为每个步骤编写单独的 try-catch 块。
const fetchUser = () => {
return new Promise((resolve) => {
resolve({ id: 1, name: 'Alice' });
})
.then(user => {
if (!user.id) {
throw new Error('User ID is missing');
}
return user;
})
.then(user => {
// 如果上面抛出了错误，这里不会执行
console.log('Processing user:', user.name);
return { ...user, status: 'active' };
})
.catch(err => {
// 捕获来自前面任意步骤的错误
console.error('Caught error:', err.message);
return null;
});
};
fetchUser().then(result => {
console.log('Final result:', result);
});
运行上述代码，控制台将输出：
Caught error: User ID is missing
Final result: null
async/await 中 try...catch 如何包裹深层调用
在 async/await 语法中，try...catch 块的行为类似于 Promise 链中的 .catch()。它将包裹其内部所有的 await 表达式。如果任何一个被等待的 Promise 被拒绝（rejected），程序控制流会立即跳转到 catch 块，跳过 try 块中剩余的代码。这使得我们可以用同步代码的风格来处理异步错误，同时保持对深层调用的集中捕获。
你是 TypeScript 项目架构专家，专注于脚手架搭建生产就绪的 Node.js 和前端应用。生成包含现代工具链（pnpm、Vite、Next.js）、类型
async function processOrder() {
try {
const order = await getOrder(); // Step 1
const inventory = await checkStock(); // Step 2
if (inventory <p>假设 <code>getOrder()</code> 成功，但 <code>checkStock()</code> 返回库存为 0，则触发 <code>throw</code>。此时 <code>chargeCard()</code> 不会被调用，控制流直接进入 <code>catch</code> 块，输出 Transaction failed: Out of stock。</p><h2>当 <code>catch</code> 内部再次抛出错误会发生什么</h2><p>如果在 <code>.catch()</code> 处理器或 <code>async/await</code> 的 <code>catch</code> 块中再次抛出错误，这个新错误会继续向上传播。在 Promise 链中，它会寻找下一个 <code>.catch()</code>；在 <code>async/await</code> 中，如果该函数没有被外层的 <code>try...catch</code> 包裹，错误将导致未处理的 Promise 拒绝（Unhandled Promise Rejection）。这意味着 <code>catch</code> 并不是错误的终点，除非它明确返回一个值或解析一个新的 Promise。</p><pre class="brush:php;toolbar:false;">// Promise Chain Example
new Promise((resolve) => resolve(1))
.then(val => {
throw new Error('First Error');
})
.catch(err => {
console.log('Caught first:', err.message); // Output: Caught first: First Error
throw new Error('Second Error'); // Re-throwing
})
.catch(err => {
console.log('Caught second:', err.message); // Output: Caught second: Second Error
return 'Recovered';
})
.then(val => console.log('Final:', val)); // Output: Final: Recovered
// Async/Await Example
async function riskyOperation() {
try {
await Promise.reject(new Error('Deep Error'));
} catch (e) {
console.log('Inner Catch:', e.message);
throw new Error('Propagated Error'); // Propagate to outer
}
}
riskyOperation().catch(e => console.log('Outer Catch:', e.message));
在 Promise 链示例中，第一个 catch 捕获了初始错误，然后抛出新错误，第二个 catch 捕获了这个新错误并返回恢复值。在 async 示例中，内部 catch 重新抛出错误，由外部调用者通过 .catch() 或外层 try...catch 处理。这展示了错误处理链的连续性。
Java免费学习笔记：立即使用
解锁 Java 大师之旅：从入门到精通的终极指南
