Promise链中的错误传递机制

// 示例：一个简单的Promise链错误传递
function step1() {
    return new Promise((resolve, reject) => {
        console.log('Step 1: 开始');
        // 模拟一个异步操作成功
        resolve('数据A');
    });
}

function step2(data) {
    return new Promise((resolve, reject) => {
        console.log('Step 2: 接收到', data, '，现在模拟一个错误');
        // 模拟一个错误
        reject(new Error('Step 2 出了点问题！'));
    });
}

function step3(data) {
    return new Promise((resolve, reject) => {
        console.log('Step 3: 接收到', data, '，这行代码不会被执行到');
        resolve('数据C');
    });
}

step1()
    .then(result => {
        console.log('then 1: 成功处理', result);
        return step2(result);
    })
    .then(result => {
        // 这块代码不会被执行，因为step2拒绝了
        console.log('then 2: 成功处理', result);
        return step3(result);
    })
    .then(result => {
        // 这块代码也不会被执行
        console.log('then 3: 最终成功', result);
    })
    .catch(error => {
        // 错误在这里被捕获
        console.error('全局捕获到错误:', error.message);
        // 如果这里返回一个值，链条会从这里恢复
        // return '从错误中恢复的默认值';
    })
    .then(finalResult => {
        // 如果catch返回了值，这里会执行
        // console.log('链条恢复后的最终结果:', finalResult);
    })
    .finally(() => {
        console.log('无论成功或失败，最后都会执行');
    });

// 运行结果会是：
// Step 1: 开始
// then 1: 成功处理 数据A
// Step 2: 接收到 数据A ，现在模拟一个错误
// 全局捕获到错误: Step 2 出了点问题！
// 无论成功或失败，最后都会执行

// 场景一：then(onFulfilled, onRejected) 只捕获前一个Promise的错误
new Promise((resolve, reject) => {
    reject(new Error('错误A'));
})
.then(
    result => console.log('成功A:', result),
    error => {
        console.error('捕获到错误A:', error.message);
        throw new Error('新的错误C'); // 抛出一个新的错误
    }
)
.then(
    result => console.log('成功B:', result),
    error => console.error('捕获到错误B:', error.message) // 捕获到错误C
);

// 运行结果：
// 捕获到错误A: 错误A
// 捕获到错误B: 新的错误C

// 场景二：catch() 捕获链中任何位置的错误
new Promise((resolve, reject) => {
    reject(new Error('错误X'));
})
.then(result => {
    console.log('成功X:', result);
    return new Promise((res, rej) => rej(new Error('错误Y')));
})
.then(result => {
    console.log('成功Y:', result);
})
.catch(error => {
    // 无论是错误X还是错误Y，都会被这个catch捕获
    console.error('统一捕获到错误:', error.message);
});

// 运行结果：
// 统一捕获到错误: 错误X

function fetchData(url) {
    return new Promise((resolve, reject) => {
        console.log(`尝试从 ${url} 获取数据...`);
        // 模拟网络请求失败
        if (url === 'bad-url') {
            setTimeout(() => reject(new Error(`网络请求失败: ${url}`)), 500);
        } else {
            setTimeout(() => resolve(`从 ${url} 获取到的数据`), 500);
        }
    });
}

function processData(data) {
    console.log('处理数据:', data);
    return Promise.resolve(`处理后的数据: [${data}]`);
}

function useFallbackData() {
    console.log('使用备用数据...');
    return Promise.resolve('本地缓存的默认数据');
}

fetchData('bad-url') // 故意触发一个错误
    .then(data => processData(data))
    .catch(error => {
        console.warn('捕获到错误，尝试恢复:', error.message);
        // 在这里进行错误恢复，比如使用备用数据
        return useFallbackData(); // 返回一个Promise，其结果将作为下一个then的输入
    })
    .then(finalData => {
        console.log('最终结果（可能已恢复）:', finalData);
        // 这里的finalData可能是从 fetchData 来的，也可能是从 useFallbackData 来的
    })
    .finally(() => {
        console.log('数据流处理完毕。');
    });

// 运行结果：
// 尝试从 bad-url 获取数据...
// 捕获到错误，尝试恢复: 网络请求失败: bad-url
// 使用备用数据...
// 最终结果（可能已恢复）: 本地缓存的默认数据
// 数据流处理完毕。