在 ES6 中，Promise 为异步编程提供了一种更优雅、更可控的方式来处理异步操作及其结果。然而，在使用 Promise 时，正确地处理异常是至关重要的，它能够确保程序的稳定性和可靠性。
使用 catch 方法
- 基本用法：Promise 的 catch 方法用于捕获 Promise 链中任何一个 Promise 产生的错误。当 Promise 被 reject 时，控制权会立即转移到最近的 catch 块中。例如：
const promise = new Promise((resolve, reject) => {
setTimeout(() => {
reject(new Error('Something went wrong'));
}, 1000);
});
promise.then(result => {
console.log(result);
}).catch(error => {
console.error('Caught an error:', error);
});
在上述代码中，当定时器中的异步操作 reject 时，错误会被 catch 块捕获并打印出来。
- 链式调用中的 catch：在 Promise 链式调用中，catch 方法可以捕获链中前面任何一个 then 方法中抛出的异常。例如：
const promise1 = new Promise((resolve, reject) => {
resolve('First promise resolved');
});
promise1.then(result => {
throw new Error('Error in the first then block');
}).then(result => {
console.log('This will not be executed');
}).catch(error => {
console.error('Caught an error in the chain:', error);
});
这里，第一个 then 块中抛出的错误会被最后的 catch 块捕获，而第二个 then 块中的代码不会执行。
在 then 方法中处理错误
- 第二个参数作为错误处理函数：then 方法可以接受两个参数，第一个参数是 Promise 成功时的回调函数，第二个参数是 Promise 失败时的回调函数。例如：
const promise2 = new Promise((resolve, reject) => {
reject('Promise rejected');
});
promise2.then(result => {
console.log(result);
}, error => {
console.error('Error handled in then:', error);
});
这种方式在一些简单的场景下可以直接处理特定 Promise 的错误，但在复杂的 Promise 链中，使用 catch 方法会更加清晰和易于维护。
避免未捕获的异常
- 全局错误处理：如果在 Promise 链中没有使用 catch 方法来捕获错误，未被捕获的异常可能会导致程序出现未定义的行为。为了避免这种情况，可以在全局范围内设置一个未捕获异常的处理函数，例如在浏览器环境中使用
window.onerror，在 Node.js 环境中使用process.on('uncaughtException')。但这种方式应该谨慎使用，因为全局捕获可能会隐藏一些深层次的问题，并且难以确定错误的具体来源。 - 确保所有 Promise 都有适当的错误处理：在编写代码时，应该养成良好的习惯，确保每个 Promise 链都有相应的 catch 方法来处理可能出现的错误，以避免未捕获的异常导致程序崩溃。
错误冒泡与传递
- 错误在 Promise 链中的传播：当一个 Promise 被 reject 时，错误会沿着 Promise 链向后传播，直到被 catch 方法捕获。这使得我们可以在合适的位置统一处理多个异步操作中的错误。例如：
const promise3 = new Promise((resolve, reject) => {
resolve('Initial value');
});
promise3.then(result => {
return new Promise((resolve, reject) => {
reject('Error in the second promise');
});
}).then(result => {
console.log('This will not be executed');
}).catch(error => {
console.error('Caught error from the chain:', error);
});
在这个例子中，第二个 Promise 中的错误会冒泡到最后的 catch 块中被捕获。
异步函数中的 Promise 异常处理
- async/await 与 try/catch：当使用 async/await 语法来处理 Promise 时，可以使用 try/catch 块来捕获异步函数中可能出现的错误。例如：
async function getData() {
try {
const response = await fetch('https://example.com/api/data');
const data = await response.json();
return data;
} catch (error) {
console.error('Error in async function:', error);
}
}
getData();
在上述代码中，fetch 操作和 JSON 解析过程中的错误都会被 try/catch 块捕获并处理。
自定义错误类型
- 提高错误的可辨识度：为了更好地处理和区分不同类型的错误，可以自定义错误类型。通过继承 Error 类或创建具有特定属性和方法的错误对象，可以在 catch 块中更精确地识别和处理不同类型的错误。例如：
class APIError extends Error {
constructor(message, statusCode) {
super(message);
this.statusCode = statusCode;
}
}
const apiCall = () => {
return new Promise((resolve, reject) => {
// 模拟 API 调用失败
reject(new APIError('API request failed', 500));
});
};
apiCall().then(result => {
console.log(result);
}).catch(error => {
if (error instanceof APIError) {
console.error(`API Error: ${
error.message}, Status Code: ${
error.statusCode}`);
} else {
console.error('An unknown error occurred:', error);
}
});
这样，根据不同的自定义错误类型，可以采取不同的处理策略。
处理 Promise 中的异常需要综合运用 catch 方法、在 then 方法中正确处理错误、避免未捕获的异常以及合理使用 async/await 与 try/catch 等方式。通过良好的异常处理机制，可以提高 Promise 异步操作的可靠性和程序的稳定性，为用户提供更优质的体验。
