Scala初学指南之类型 Option

x33g5p2x  于2021-03-14 发布在 Scala  
字(7.2k)|赞(0)|评价(0)|浏览(308)

前几章,我们讨论了许多相当先进的技术,尤其是模式匹配和提取器。是时候来看一看 Scala 另一个基本特性了: Option 类型。

可能你已经见过它在 Map API 中的使用;在实现自己的提取器时,我们也用过它,然而,它还需要更多的解释。你可能会想知道它到底解决什么问题,为什么用它来处理缺失值要比其他方法好,而且可能你还不知道该怎么在你的代码中使用它。这一章的目的就是消除这些问号,并教授你作为一个新手所应该了解的 Option 知识。

基本概念

Java 开发者一般都知道 NullPointerException(其他语言也有类似的东西),通常这是由于某个方法返回了 null ,但这并不是开发者所希望发生的,代码也不好去处理这种异常。

null 通常被滥用来表征一个可能会缺失的值。不过,某些语言以一种特殊的方法对待 null 值,或者允许你安全的使用可能是 null 的值。比如说,Groovy 有 安全运算符(Safe Navigation Operator) 用于访问属性,这样 foo?.bar?.baz 不会在 foobarnull 时而引发异常,而是直接返回 null,然而,Groovy 中没有什么机制来强制你使用此运算符,所以如果你忘记使用它,那就完蛋了!

Clojure 对待 nil 基本上就像对待空字符串一样。也可以把它当作列表或者映射表一样去访问,这意味着, nil 在调用层级中向上冒泡。很多时候这样是可行的,但有时会导致异常出现在更高的调用层级中,而那里的代码没有对 nil 加以考虑。

Scala 试图通过摆脱 null 来解决这个问题,并提供自己的类型用来表示一个值是可选的(有值或无值),这就是 Option[A] 特质。

Option[A] 是一个类型为 A 的可选值的容器:如果值存在, Option[A] 就是一个 Some[A] ,如果不存在, Option[A] 就是对象 None

在类型层面上指出一个值是否存在,使用你的代码的开发者(也包括你自己)就会被编译器强制去处理这种可能性,而不能依赖值存在的偶然性。

Option 是强制的!不要使用 null 来表示一个值是缺失的。

创建 Option

通常,你可以直接实例化 Some 样例类来创建一个 Option 。

val greeting: Option[String] = Some("Hello world")

或者,在知道值缺失的情况下,直接使用 None 对象:

val greeting: Option[String] = None

然而,在实际工作中,你不可避免的要去操作一些 Java 库,或者是其他将 null 作为缺失值的JVM 语言的代码。为此, Option 伴生对象提供了一个工厂方法,可以根据给定的参数创建相应的 Option

val absentGreeting: Option[String] = Option(null) // absentGreeting will be None
val presentGreeting: Option[String] = Option("Hello!") // presentGreeting will be Some("Hello!")

使用 Option

目前为止,所有的这些都很简洁,不过该怎么使用 Option 呢?是时候开始举些无聊的例子了。

想象一下,你正在为某个创业公司工作,要做的第一件事情就是实现一个用户的存储库,要求能够通过唯一的用户 ID 来查找他们。有时候请求会带来假的 ID,这种情况,查找方法就需要返回 Option[User] 类型的数据。一个假想的实现可能是:

  case class User(
    id: Int,
    firstName: String,
    lastName: String,
    age: Int,
    gender: Option[String]
  )

  object UserRepository {
    private val users = Map(1 -> User(1, "John", "Doe", 32, Some("male")),
                            2 -> User(2, "Johanna", "Doe", 30, None))
    def findById(id: Int): Option[User] = users.get(id)
    def findAll = users.values
  }

现在,假设从 UserRepository 接收到一个 Option[User] 实例,并需要拿它做点什么,该怎么办呢?

一个办法就是通过 isDefined 方法来检查它是否有值。如果有,你就可以用 get 方法来获取该值:

  val user1 = UserRepository.findById(1)
  if (user1.isDefined) {
    println(user1.get.firstName)
  } // will print "John"

这和 Guava 库 中的 Optional 使用方法类似。不过这种使用方式太过笨重,更重要的是,使用 get 之前,你可能会忘记用 isDefined 做检查,这会导致运行期出现异常。这样一来,相对于 null ,使用 Option 并没有什么优势。

你应该尽可能远离这种访问方式!

提供一个默认值

很多时候,在值不存在时,需要进行回退,或者提供一个默认值。Scala 为 Option 提供了 getOrElse 方法,以应对这种情况:

  val user = User(2, "Johanna", "Doe", 30, None)
  println("Gender: " + user.gender.getOrElse("not specified")) // will print "not specified"

请注意,作为 getOrElse 参数的默认值是一个 传名参数 ,这意味着,只有当这个 Option 确实是 None 时,传名参数才会被求值。因此,没必要担心创建默认值的代价,它只有在需要时才会发生。

模式匹配

Some 是一个样例类,可以出现在模式匹配表达式或者其他允许模式出现的地方。上面的例子可以用模式匹配来重写:

  val user = User(2, "Johanna", "Doe", 30, None)
  user.gender match {
    case Some(gender) => println("Gender: " + gender)
    case None => println("Gender: not specified")
  }

或者,你想删除重复的 println 语句,并重点突出模式匹配表达式的使用:

  val user = User(2, "Johanna", "Doe", 30, None)
  val gender = user.gender match {
    case Some(gender) => gender
    case None => "not specified"
  }
  println("Gender: " + gender)

你可能已经发现用模式匹配处理 Option 实例是非常啰嗦的,这也是它非惯用法的原因。所以,即使你很喜欢模式匹配,也尽量用其他方法吧。

不过在 Option 上使用模式确实是有一个相当优雅的方式,在下面的 for 语句一节中,你就会学到。

作为集合的 Option

到目前为止,你还没有看见过优雅使用 Option 的方式吧。下面这个就是了。

前文我提到过, Option 是类型 A 的容器,更确切地说,你可以把它看作是某种集合,这个特殊的集合要么只包含一个元素,要么就什么元素都没有。

虽然在类型层次上, Option 并不是 Scala 的集合类型,但,凡是你觉得 Scala 集合好用的方法, Option 也有,你甚至可以将其转换成一个集合,比如说 List

那么这又能让你做什么呢?

执行一个副作用

如果想在 Option 值存在的时候执行某个副作用,foreach 方法就派上用场了:

 UserRepository.findById(2).foreach(user => println(user.firstName)) // prints "Johanna"

如果这个 Option 是一个 Some ,传递给 foreach 的函数就会被调用一次,且只有一次;如果是 None ,那它就不会被调用。

执行映射

Option 表现的像集合,最棒的一点是,你可以用它来进行函数式编程,就像处理列表、集合那样。

正如你可以将 List[A] 映射到 List[B] 一样,你也可以映射 Option[A]Option[B]:如果 Option[A] 实例是 Some[A] 类型,那映射结果就是 Some[B] 类型;否则,就是 None

如果将 OptionList 做对比 ,那 None 就相当于一个空列表:当你映射一个空的 List[A] ,会得到一个空的 List[B] ,而映射一个是 NoneOption[A] 时,得到的 Option[B] 也是 None

让我们得到一个可能不存在的用户的年龄:

val age = UserRepository.findById(1).map(_.age) // age is Some(32)

Option 与 flatMap

也可以在 gender 上做 map 操作:

val gender = UserRepository.findById(1).map(_.gender) // gender is an Option[Option[String]]

所生成的 gender 类型是 Option[Option[String]] 。这是为什么呢?

这样想:你有一个装有 UserOption 容器,在容器里面,你将 User 映射到 Option[String]User 类上的属性 genderOption[String] 类型的)。得到的必然是嵌套的 Option。

既然可以 flatMap 一个 List[List[A]]List[B] ,也可以 flatMap 一个 Option[Option[A]]Option[B] ,这没有任何问题:Option 提供了 flatMap 方法。

val gender1 = UserRepository.findById(1).flatMap(_.gender) // gender is Some("male")
val gender2 = UserRepository.findById(2).flatMap(_.gender) // gender is None
val gender3 = UserRepository.findById(3).flatMap(_.gender) // gender is None

现在结果就变成了 Option[String] 类型,如果 usergender 都有值,那结果就会是 Some 类型,反之,就得到一个 None

要理解这是什么原理,让我们看看当 flatMap 一个 List[List[A] 时,会发生什么?(要记得, Option 就像一个集合,比如列表)

val names: List[List[String]] =
 List(List("John", "Johanna", "Daniel"), List(), List("Doe", "Westheide"))
names.map(_.map(_.toUpperCase))
// results in List(List("JOHN", "JOHANNA", "DANIEL"), List(), List("DOE", "WESTHEIDE"))
names.flatMap(_.map(_.toUpperCase))
// results in List("JOHN", "JOHANNA", "DANIEL", "DOE", "WESTHEIDE")

如果我们使用 flatMap ,内部列表中的所有元素会被转换成一个扁平的字符串列表。显然,如果内部列表是空的,则不会有任何东西留下。

现在回到 Option 类型,如果映射一个由 Option 组成的列表呢?

val names: List[Option[String]] = List(Some("Johanna"), None, Some("Daniel"))
names.map(_.map(_.toUpperCase)) // List(Some("JOHANNA"), None, Some("DANIEL"))
names.flatMap(xs => xs.map(_.toUpperCase)) // List("JOHANNA", "DANIEL")

如果只是 map ,那结果类型还是 List[Option[String]] 。而使用 flatMap 时,内部集合的元素就会被放到一个扁平的列表里:任何一个 Some[String] 里的元素都会被解包,放入结果集中;而原列表中的 None 值由于不包含任何元素,就直接被过滤出去了。

记住这一点,然后再去看看 faltMapOption 身上做了什么。

过滤 Option

也可以像过滤列表那样过滤 Option:如果选项包含有值,而且传递给 filter 的谓词函数返回真, filter 会返回 Some 实例。否则(即选项没有值,或者谓词函数返回假值),返回值为 None

UserRepository.findById(1).filter(_.age > 30) // None, because age is <= 30
UserRepository.findById(2).filter(_.age > 30) // Some(user), because age is > 30
UserRepository.findById(3).filter(_.age > 30) // None, because user is already None

for 语句

现在,你已经知道 Option 可以被当作集合来看待,并且有 mapflatMapfilter 这样的方法。可能你也在想 Option 是否能够用在 for 语句中,答案是肯定的。而且,用 for 语句来处理 Option 是可读性最好的方式,尤其是当你有多个 mapflatMapfilter 调用的时候。如果只是一个简单的 map 调用,那 for 语句可能有点繁琐。

假如我们想得到一个用户的性别,可以这样使用 for 语句:

for {
  user <- UserRepository.findById(1)
  gender <- user.gender
} yield gender // results in Some("male")

可能你已经知道,这样的 for 语句等同于嵌套的 flatMap 调用。如果 UserRepository.findById 返回 None,或者 genderNone ,那这个 for 语句的结果就是 None 。不过这个例子里, gender 含有值,所以返回结果是 Some 类型的。

如果我们想返回所有用户的性别(当然,如果用户设置了性别),可以遍历用户,yield 其性别:

for {
  user <- UserRepository.findAll
  gender <- user.gender
} yield gender
// result in List("male")

在生成器左侧使用

也许你还记得,前一章曾经提到过, for 语句中生成器的左侧也是一个模式。这意味着也可以在 for 语句中使用包含选项的模式。

重写之前的例子:

 for {
   User(_, _, _, _, Some(gender)) <- UserRepository.findAll
 } yield gender

在生成器左侧使用 Some 模式就可以在结果集中排除掉值为 None 的元素。

链接 Option

Option 还可以被链接使用,这有点像偏函数的链接:在 Option 实例上调用 orElse 方法,并将另一个 Option 实例作为传名参数传递给它。如果一个 Option 是 NoneorElse 方法会返回传名参数的值,否则,就直接返回这个 Option。

一个很好的使用案例是资源查找:对多个不同的地方按优先级进行搜索。下面的例子中,我们首先搜索 config 文件夹,并调用 orElse 方法,以传递备用目录:

case class Resource(content: String)
val resourceFromConfigDir: Option[Resource] = None
val resourceFromClasspath: Option[Resource] = Some(Resource("I was found on the classpath"))
val resource = resourceFromConfigDir orElse resourceFromClasspath

如果想链接多个选项,而不仅仅是两个,使用 orElse 会非常合适。不过,如果只是想在值缺失的情况下提供一个默认值,那还是使用 getOrElse 吧。

总结

在这一章里,你学到了有关 Option 的所有知识,这有利于你理解别人的代码,也有利于你写出更可读,更函数式的代码。

这一章最重要的一点是:列表、集合、映射、Option,以及之后你会见到的其他数据类型,它们都有一个非常统一的使用方式,这种使用方式既强大又优雅。

下一章,你将学习 Scala 错误处理的惯用法。

相关文章