Scala for Backend Engineering & Functional Programming · 课时

类型之间的转换

Option、Either、Try

类型之间的转换 是 CoddyKit 上的免费 Scala for Backend Engineering & Functional Programming 课时。这是第 4 节课，共 4 节。你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。这是 Scala for Backend Engineering & Functional Programming 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 Scala for Backend Engineering & Functional Programming 课程共包含 4 节课。

三种错误模型

Scala 提供了三种互为补充的类型，用于表示缺失和失败：

Option — 存在或缺失（不包含原因）。
Either — 成功或带有类型的错误。
Try — 成功或抛出的异常。

了解如何在它们之间转换，可以让您将一种接口适配到另一种接口。

将 Option 转换为 Either

toRight 会将 Option 转换为 Either，并为 None 情况提供一个 Left 错误。toLeft 则执行相反的映射。

@main def run(): Unit = {
  val some: Option[Int] = Some(5)
  val none: Option[Int] = None
  println(some.toRight("missing"))
  println(none.toRight("missing"))
}

Either 转 Option

toOption 会丢弃错误：Right(x) 变为 Some(x)，Left(_) 变为 None。当失败原因不再重要时，可以使用它。

@main def run(): Unit = {
  val r: Either[String, Int] = Right(42)
  val l: Either[String, Int] = Left("err")
  println(r.toOption)
  println(l.toOption)
}

Try 转 Option

Try.toOption 会将 Success 转为 Some，将 Failure 转为 None，并吞掉异常。

import scala.util.Try

@main def run(): Unit = {
  println(Try("7".toInt).toOption)
  println(Try("x".toInt).toOption)
}

Try 转 Either

Try.toEither 会生成一个 Either[Throwable, T]：Success 变为 Right，Failure 变为 Left(throwable)。这样可以将异常保留为带类型的左值。

import scala.util.Try

@main def run(): Unit = {
  val ok = Try("7".toInt).toEither
  val no = Try("x".toInt).toEither
  println(ok)
  println(no.left.map(_.getMessage))
}

Either 转 Try

没有内置的直接方法可以将带有普通错误的 Either 转为 Try，但您可以自行构建：将 Right 包装在 Success 中，并将 Left 包装在携带异常的 Failure 中。

import scala.util.{Try, Success, Failure}

object Main {
  def toTry(e: Either[String, Int]): Try[Int] = e match {
    case Right(v) => Success(v)
    case Left(m)  => Failure(new RuntimeException(m))
  }

  def main(args: Array[String]): Unit = {
    println(toTry(Right(1)))
    println(toTry(Left("bad")))
  }
}

Option 转 Try

将 Option 转为 Try 时，需要为为空的情况选择一个异常。当某个应用程序接口要求使用 Try 时，这种转换很有用。

import scala.util.{Try, Success, Failure}

object Main {
  def toTry[A](o: Option[A]): Try[A] = o match {
    case Some(v) => Success(v)
    case None    => Failure(new NoSuchElementException("empty"))
  }

  def main(args: Array[String]): Unit = {
    println(toTry(Some(9)))
    println(toTry(None))
  }
}

规范化处理流程

混用不同类型会带来诸多不便。常见做法是在处理流程早期将所有内容转换为使用统一错误类型的 Either，之后就可以自由组合。

import scala.util.Try

object Main {
  def parse(s: String): Either[String, Int] =
    Try(s.toInt).toEither.left.map(_ => s"invalid: $s")

  def lookup(n: Int): Either[String, String] =
    Map(1 -> "one", 2 -> "two").get(n).toRight(s"no entry for $n")

  def main(args: Array[String]): Unit = {
    val result = for {
      n <- parse("2")
      w <- lookup(n)
    } yield w
    println(result)
  }
}

在不同类型中使用 getOrElse

这三种类型都支持使用 getOrElse 提取值，或提供一个默认值。这通常是离开错误处理流程的最后一步。

import scala.util.Try

@main def run(): Unit = {
  val a = Some(1).getOrElse(0)
  val b = (Right(2): Either[String, Int]).getOrElse(0)
  val c = Try("x".toInt).getOrElse(0)
  println(s"$a $b $c")
}

选择合适的类型

指导原则：

当缺少值无需解释时，使用 Option。
需要使用特定于领域的错误值时，使用 Either。
与会抛出异常的 Java 或库代码交界时，使用 Try。

端到端示例

使用 Try 读取会抛出异常的代码，转换为用于表示领域错误的 Either，最后再转换为只关心是否存在值的调用方所需的 Option。

import scala.util.Try

object Main {
  def safeDiv(a: Int, b: Int): Option[Int] =
    Try(a / b).toEither.left.map(_ => "math error").toOption

  def main(args: Array[String]): Unit = {
    println(safeDiv(10, 2))
    println(safeDiv(10, 0))
  }
}

快速检查

测试您对类型转换的掌握程度。

回顾

您已经学会了在 Option、Either 和 Try 之间进行转换：

Option.toRight → Either；Either.toOption → Option。
Try.toOption 和 Try.toEither 可以将异常转换为值。
尽早将处理流程规范化为一种错误类型。
根据所需的错误详细程度选择合适的类型。

常见问题解答

「类型之间的转换」课时是免费的吗？

是的 — 「类型之间的转换」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 Scala for Backend Engineering & Functional Programming 课程的其余内容，请升级到 CoddyKit PRO。 Scala for Backend Engineering & Functional Programming 课程共包含 4 节课。

「类型之间的转换」这节课中我会学到什么？

Option、Either、Try 你通过在浏览器中直接运行的动手代码来练习 Scala for Backend Engineering & Functional Programming，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

学习 Scala for Backend Engineering & Functional Programming 需要有经验吗？

无需任何先前经验。CoddyKit 上的 Scala for Backend Engineering & Functional Programming 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。这是第 4 节课，共 4 节。

「类型之间的转换」课时需要多长时间？

大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。

我能在这节 Scala for Backend Engineering & Functional Programming 课中编写并运行代码吗？

能。每节 Scala for Backend Engineering & Functional Programming 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。

此课程中的所有课时

← 返回 Scala for Backend Engineering & Functional Programming