JavaScript Promise.any获取首个成功结果方法

有志者，事竟成！如果你在学习文章，那么本文《JavaScript Promise.any获取首个成功结果方法》，就很适合你！文章讲解的知识点主要包括，若是你对本文感兴趣，或者是想搞懂其中某个知识点，就请你继续往下看吧~

Promise.any的核心作用是从一组Promise中找到第一个成功解决的Promise并返回其结果，若全部失败则抛出AggregateError。它接收一个Promise可迭代对象，返回一个新Promise，该Promise在任意输入Promise成功时立即以该值解决；若所有Promise均失败，则捕获包含所有拒绝原因的AggregateError。与Promise.race不同，race关注最快完成（无论成功或失败），而any只关心是否有成功的结果。适用场景包括多源数据获取、资源加载优化、服务发现及容错处理等。

JavaScript中的Promise.any方法，它的核心作用就是从你给它的一组Promise中，找出第一个成功解决（fulfilled）的Promise，并返回其结果。如果所有的Promise都失败（rejected）了，那么它会抛出一个AggregateError，这个错误对象会包含所有失败的原因。

解决方案

Promise.any()接收一个Promise的可迭代对象（比如一个数组），并返回一个新的Promise。这个新的Promise会在输入的可迭代对象中的任何一个Promise成功时，立即以该Promise的值解决。

举个例子，想象一下你要从几个不同的服务器或API接口获取数据，你只关心哪个最快返回正确的结果，而不是所有都返回。

const fetchFromSourceA = new Promise((resolve, reject) => {
    setTimeout(() => {
        // 假设这里模拟网络请求成功
        resolve('数据来自源A');
    }, 500); // 500毫秒后成功
});

const fetchFromSourceB = new Promise((resolve, reject) => {
    setTimeout(() => {
        // 模拟网络请求失败
        reject('源B请求超时');
    }, 200); // 200毫秒后失败
});

const fetchFromSourceC = new Promise((resolve, reject) => {
    setTimeout(() => {
        // 模拟网络请求成功
        resolve('数据来自源C');
    }, 100); // 100毫秒后成功
});

Promise.any([fetchFromSourceA, fetchFromSourceB, fetchFromSourceC])
    .then(result => {
        console.log('首个成功结果:', result); // 应该会输出 '数据来自源C'
    })
    .catch(error => {
        console.error('所有Promise都失败了:', error);
        // 如果所有都失败，这里会捕获 AggregateError
    });

// 另一个例子：所有都失败的情况
const p1 = new Promise((resolve, reject) => setTimeout(() => reject('Error 1'), 100));
const p2 = new Promise((resolve, reject) => setTimeout(() => reject('Error 2'), 200));

Promise.any([p1, p2])
    .then(result => {
        console.log('成功结果:', result);
    })
    .catch(error => {
        console.error('所有Promise都失败了:', error);
        console.error('具体错误列表:', error.errors); // error.errors 是一个包含所有拒绝原因的数组
    });

在我看来，Promise.any的设计哲学就是“乐观主义”——它总是期待至少有一个能成功。这种心态在很多异步操作中确实很实用，尤其是在有冗余机制的时候。

Promise.any与Promise.race有什么区别？

说实话，刚接触Promise.any时，我脑子里首先跳出来的就是Promise.race，它们俩确实有点像，但骨子里完全不同。Promise.race是“竞速”，它关心的是哪一个Promise“最快”达到终点，无论是成功（fulfilled）还是失败（rejected），只要有一个Promise的状态率先改变（settled），Promise.race就会立即采纳那个Promise的结果或错误。

而Promise.any则更像一个“求生欲”很强的团队领导，它不在乎谁跑得最快，它只在乎团队里有没有人能成功完成任务。只要有一个Promise成功了，它就满足了。如果所有Promise都失败了，那它才不得不承认失败，并且把所有失败的原因都打包告诉你。所以，核心区别在于：race看“速度”，any看“成功”。

举个简单对比：

const slowSuccess = new Promise(res => setTimeout(() => res('慢成功'), 500));
const fastFail = new Promise((_, rej) => setTimeout(() => rej('快失败'), 100));

// Promise.race会取 fastFail 的结果
Promise.race([slowSuccess, fastFail])
    .then(val => console.log('Race结果:', val))
    .catch(err => console.error('Race错误:', err)); // 输出: Race错误: 快失败

// Promise.any会等待 slowSuccess 的结果
Promise.any([slowSuccess, fastFail])
    .then(val => console.log('Any结果:', val))
    .catch(err => console.error('Any错误:', err)); // 输出: Any结果: 慢成功

这种差异决定了它们各自适用的场景，理解这一点非常关键。

当所有Promise都失败时，Promise.any会如何表现？

这是一个非常重要的点，也是Promise.any区别于其他Promise组合方法的地方。当传入Promise.any的所有Promise都拒绝（rejected）时，它不会简单地抛出第一个拒绝的错误，而是会抛出一个特殊的错误类型：AggregateError。

AggregateError是一个新的错误类型，它继承自Error，并且有一个额外的属性errors，这个errors属性是一个数组，里面包含了所有导致Promise.any失败的Promise的拒绝原因。这对于调试和错误处理来说非常有用，因为它让你能够一次性地审查所有失败的细节，而不是只看到其中一个。

const apiCall1 = new Promise((resolve, reject) => {
    setTimeout(() => reject(new Error('API 1 挂了')), 300);
});

const apiCall2 = new Promise((resolve, reject) => {
    setTimeout(() => reject(new Error('API 2 超时')), 100);
});

const apiCall3 = new Promise((resolve, reject) => {
    setTimeout(() => reject(new Error('API 3 认证失败')), 200);
});

Promise.any([apiCall1, apiCall2, apiCall3])
    .then(result => {
        console.log('竟然成功了:', result); // 这段代码不会执行
    })
    .catch(error => {
        console.error('所有API都失败了！');
        if (error instanceof AggregateError) {
            console.error('错误类型:', error.name); // 输出: AggregateError
            console.error('所有错误详情:');
            error.errors.forEach((err, index) => {
                console.error(`- 错误 ${index + 1}: ${err.message}`);
            });
        } else {
            console.error('未知错误:', error);
        }
    });

这种机制让我觉得它很“体贴”，因为它不仅仅告诉你“出错了”，还把“为什么出错”的每一个细节都摆在你面前，这对于我们开发者去定位问题，或者给用户更具体的错误提示，都是极大的帮助。

在实际开发中，哪些场景适合使用Promise.any？

在实际的软件开发过程中，Promise.any的应用场景比你想象的要多，尤其是在需要冗余或弹性处理的场景下。

1. 多源数据获取与容错：这是最经典的场景。比如，你的前端应用需要从多个CDN节点加载同一个资源文件（图片、JavaScript库），或者从多个后端服务获取相同的数据。你只需要其中一个成功即可。Promise.any可以让你同时向所有源发起请求，并使用第一个返回成功结果的源，大大提高了加载速度和系统的健壮性。如果某个源挂了或者响应慢，只要有其他源能及时响应，用户体验就不会受影响。

2. A/B测试或灰度发布：有时候，你可能想测试两个不同版本的API接口，或者在灰度发布阶段，让一部分用户尝试新的接口，另一部分继续使用旧接口。你可以用Promise.any同时调用新旧接口，并根据某种策略（例如，哪个先成功，或者哪个返回了特定标识）来决定采纳哪个结果。当然，这通常还需要配合其他逻辑来筛选，但any提供了一个基础的“谁先成功”的机制。

3. 资源加载优化：在一些富媒体应用中，你可能需要加载多种格式的视频或音频文件，或者不同分辨率的图片。你可以将所有加载Promise传入Promise.any，一旦其中一个加载成功，就立即播放或显示，而不需要等待所有格式都尝试完毕。这能显著提升用户感知到的加载速度。

4. 服务发现或健康检查：在一个微服务架构中，你可能有多个实例提供相同的服务。当客户端需要调用某个服务时，可以使用Promise.any去尝试连接这些服务实例，只要有一个实例响应正常，就可以认为该服务可用，并进行后续操作。

5. 用户操作的“兜底”机制：设想一个场景，用户点击了一个按钮，可能触发多个异步操作，但你只关心其中一个操作能成功完成，以表示用户意图已达成。例如，同时尝试本地缓存、IndexedDB和网络请求来获取数据，只要其中任何一个成功获取到数据，就视为成功。

我个人觉得，Promise.any最吸引人的地方在于它的“韧性”。它不像all那样要求所有人都成功，也不像race那样只看谁跑得快（哪怕是摔倒），它只求一个结果，一个成功的结果。这种特性在构建高可用、高弹性的系统时，是非常有价值的。

今天带大家了解了的相关知识，希望对你有所帮助；关于文章的技术知识我们会一点点深入介绍，欢迎大家关注golang学习网公众号，一起学习编程~