Scala中用于map和filter的下划线表达式符号

Question

假设我有如下代码：

val a: List[(Int, String)] = List((1,"A"),(2,"B"),(3,"C"))
val b: List[String] = List("A","C","E")

我能做到：

a.map{case (fst,snd) => (fst,snd + "a")}
a.filter{case (_,snd) => b.contains(snd)}

但为什么我不能这样做：

a.map((_._1,_._2 + "a"))
a.filter(b.contains(_._2))

有没有使用下划线表示法完成这个任务的方法，还是我只能强行这样做？

- user3685285

---

val b: List[Int] = List("A","C","E") 应该是 val b: List[String] = List("A","C","E")，否则会出现编译错误。 - Ramesh Maharjan

只有在定义了隐式参数时，val b: List[Int] = List("A","C","E") 才能正常工作。 - Ramesh Maharjan

Ping - 以下哪个回复回答了您的问题？ - Daniel Rosenwasser

好的，谢谢。我标记为答案了。 - user3685285

Answer 1

例如：

a.map((_._1,_._2 + "a"))

每个占位符（即每个下划线/_）在参数表达式中引入了一个新的参数。

引用Scala规范

An expression (of syntactic category Expr) may contain embedded underscore symbols _ at places where identifiers are legal. Such an expression represents an anonymous function where subsequent occurrences of underscores denote successive parameters.

[...]

The anonymous functions in the left column use placeholder syntax. Each of these is equivalent to the anonymous function on its right.

|---------------------------|----------------------------|
|`_ + 1`                    | `x => x + 1`               |
|`_ * _`                    | `(x1, x2) => x1 * x2`      |
|`(_: Int) * 2`             | `(x: Int) => (x: Int) * 2` |
|`if (_) x else y`          | `z => if (z) x else y`     |
|`_.map(f)`                 | `x => x.map(f)`            |
|`_.map(_ + 1)`             | `x => x.map(y => y + 1)`   |

当您需要多次使用给定参数时，必须使用扩展形式。因此，您的示例必须重写为：

a.map(x => (x._1, x._2 + "a"))

---

例如

a.filter(b.contains(_._2))

问题在于你实际上是向 contains 传递了一个匿名函数，而不是向 filter 传递，所以你也无法在这里使用下划线符号。相反，你需要编写如下代码：

a.filter(x => b.contains(x._2))

- Daniel Rosenwasser

Answer 2

您无法执行

a.map((_._1,_._2 + "a"))

因为_将在每次迭代中匹配可迭代元素的元素。第一个_将与第一个可迭代对象的元素匹配，第二个_将与第二个可迭代对象的元素匹配，以此类推。_._1将匹配第一个可迭代对象的元组元素的第一个元素，但_._2将尝试获取第二个可迭代对象的元组元素的第二个元素。由于没有第二个可迭代对象，Scala编译器会抛出编译错误 在你的第二行代码中

a.filter(b.contains(_._2))

_._2 试图获取 b 的元组可迭代对象的第二个元素，但 b 不是元组可迭代对象。 b 只是一个字符串可迭代对象。

要使其正常工作，您可以执行以下操作：

a.map(x => (x._1, x._2 + "a"))
a.filter(x => b.contains(x._2))

- Ramesh Maharjan