为什么这个“案例”是必须的？

Question

object Test1 {
    def main(args: Array[String]) {
        val list = List("a", "b")
        list map { x ⇒ println(x) }
        list map { case x ⇒ println(x) }

        val list2 = List(("aa", "11"))
        list2 map {
            case (key, value) ⇒ println("key: "+key+", value: "+value)
        }
    }

}

请注意最后一行，为什么必须使用关键字 case，但 list map { x ⇒ println(x) } 可以去掉它？

Answer 1

您无法在函数文字中打开元组。这就是为什么你必须使用大小写来匹配它们。另一种方法是使用 tupled 使具有两个参数的函数适合：

import Function.tupled 
list2 map tupled {
  (key, value) => println("key: "+key+", value: "+value)
}

Answer 2

{ case (key, value) => f }

与第一个不同的是

{ (key, value) => f }

，模式匹配将 Tuple2 分解为其组件，并将它们的值分配给 key 和 value。在这种情况下，仅传递一个参数（元组）。 <代码>{ x => println(x) } 之所以有效，是因为 x 被分配了元组，并且 println 打印它。

第二个是一个带有两个参数的函数，并且不进行模式匹配。由于 map 需要一个采用单个参数的函数，因此第二种情况与 map 不兼容。

Answer 3

list2 具有 Tuple2[Int, Int] 类型的元素，因此您必须传递 map 的函数签名（在本例中... foreach 是一个更自然的选择）是 Tuple2[Int, Int] =>单位。也就是说，它需要一个 Tuple2[Int, Int] 类型的参数。

由于 Tuple2 支持 unapply，因此您可以使用模式匹配在函数中分解该元组，就像您所做的那样：

{
  case (key, value) ⇒ println("key: "+key+", value: "+value)
}

该函数的签名仍然是 Tuple2[Int, Int] => Unit

它与 Scala 相同，并且可能编译为相同的字节码，如下所示：

{
  x: Tuple2[Int, Int] => println("key: "+x._1+", value: "+x._2)
}

这是 Scala 以非常令人愉快的方式组合正交概念的众多示例之一。

Answer 4

list2 地图 { x => println(x) } 对我来说没有问题。如果您想要进行模式匹配（根据其结构将您的参数分成几个部分），您始终需要 case。或者，您可以这样写：

list2 map { x => println("key: "+x._1+", value: "+x._2) }

顺便说一句，map 应该用于转换另一个列表中的列表。如果您只想遍历列表中的所有元素，请使用 foreach 或进行理解。

Answer 5

我仍在学习 Scala，但我相信发生的情况是您定义了一个带有一个参数的部分函数。当调用仅需要一个参数的方法（例如 List.map 或 List.foreach）时，您可以省略下划线或命名 val。

在闭包中省略 val 名称的示例：

val v = List("HEY!", "BYE!")
v.foreach { Console.println } // Pass partial function, automatically

这与以下内容相同：

val v = List("HEY!", "BYE!")
v.foreach { Console.println _ } // Pass partial function, explicitly

使用匿名 val：

val v = List("HEY!", "BYE!")
v.foreach { Console.println(_) } // Refer to anonymous param, explicitly

或使用命名 val：

val v = List("HEY!", "BYE!")
v.foreach { x => Console.println(x) } // Refer to val, explicitly

在闭包中，您使用一个部分函数（case 语句），该函数接受匿名变量并立即将其转换为元组绑定到两个单独的变量。

我想我搞砸了上面的一个片段。当我到达工作计算机时，我将在 REPL 中进行验证。

另外，请查看 Scala 中的函数柯里化 了解更多信息信息。