Scala：遍历Seq时如何调用返回Future的函数？

当然可以！这在Scala异步编程里是非常典型的场景，咱直接上解决方案，再给你拆解细节：

基础实现（并行调用） #

最直接的方式就是先遍历每个ID调用异步方法，得到一个Seq[Future[Something]]，再用Future.sequence把这个Future序列转换成包含结果序列的Future。代码如下：

import scala.concurrent.Future
import scala.concurrent.ExecutionContext.Implicits.global // 或者传入你自定义的ExecutionContext

// 假设你的getSomethingById已经定义好
def getSomethingById(id: String): Future[Something] = ???

def getSomethings(ids: Seq[String]): Future[Seq[Something]] = {
  // 遍历每个ID，发起异步请求，得到Future的集合
  val individualFutures: Seq[Future[Something]] = ids.map(getSomethingById)
  // 把Future的集合"翻转"成包含集合的Future，等待所有请求完成
  Future.sequence(individualFutures)
}

关键细节解释 #

• Future.sequence是这个实现的核心：它接收一个Seq[Future[A]]，返回Future[Seq[A]]。它会等待所有异步任务完成，然后把结果按原ID的顺序收集成序列返回。
• 并行性：因为Future在创建时就会开始执行，所以这个实现里所有的getSomethingById调用是并行发起的，能充分利用资源。
• 错误传播：如果任何一个getSomethingById调用失败（返回失败的Future），整个getSomethings返回的Future也会直接失败。

进阶场景：串行调用（速率控制） #

如果你的场景不允许并行调用（比如API有请求频率限制），可以用foldLeft来实现串行执行：

def getSomethingsSerial(ids: Seq[String]): Future[Seq[Something]] = {
  // 从一个成功的空序列Future开始，逐个处理每个ID
  ids.foldLeft(Future.successful(Seq.empty[Something])) { (accumulatorFuture, currentId) =>
    accumulatorFuture.flatMap { accumulatedResults =>
      // 等之前的所有请求完成，再发起下一个请求，然后把结果追加到序列里
      getSomethingById(currentId).map(newSomething => accumulatedResults :+ newSomething)
    }
  }
}

这个版本会严格按照ID的顺序，等前一个请求完成后再发起下一个，避免并发过高的问题。

进阶场景：容错处理 #

如果希望某个ID的调用失败不影响整体结果，可以给每个Future添加容错逻辑：

def getSomethingsWithFallback(ids: Seq[String], fallbackValue: Something): Future[Seq[Something]] = {
  val safeFutures = ids.map { id =>
    // 若调用失败，用fallbackValue替代失败的结果
    getSomethingById(id).recover { case _: Exception => fallbackValue }
  }
  Future.sequence(safeFutures)
}

这样即使个别ID的请求失败，整个Future依然会成功返回，失败的位置会用你指定的兜底值填充。

注意事项 #

• ExecutionContext：必须确保有可用的ExecutionContext（比如示例里的全局上下文，或者你自己注入的上下文），否则Future无法执行异步任务。
• 空序列处理：如果传入的ids是空序列，Future.sequence会直接返回一个包含空序列的成功Future，无需额外处理。

内容的提问来源于stack exchange，提问作者Tv-Wonders