Scala中下划线的所有用途是什么？


What are all the uses of an underscore in Scala?

我看了一下scala-lang.org上的调查列表，发现了一个奇怪的问题："你能说出"的所有用法吗？你能吗？如果是，请在这里这样做。请举例说明。

相关讨论

我能想到的是

存在主义类型

1
def foo(l: List[Option[_]]) = ...

更高类型参数

1
case class A[K[_],T](a: K[T])

忽略的变量

1
val _ = 5

忽略的参数

1
List(1, 2, 3) foreach { _ => println("Hi") }

忽略自身类型的名称

1
trait MySeq { _: Seq[_] => }

通配符模式

1
Some(5) match { case Some(_) => println("Yes") }

插值中的通配符模式

1
"abc" match { case s"a$_c" => }

模式中的序列通配符

1
C(1, 2, 3) match { case C(vs @ _*) => vs.foreach(f(_)) }

通配符导入

1
import java.util._

隐藏进口

1
import java.util.{ArrayList => _, _}

将信件加入操作员

1
def bang_!(x: Int) = 5

分配运算符

1
def foo_=(x: Int) { ... }

占位符语法

1
List(1, 2, 3) map (_ + 2)

方法值

1
List(1, 2, 3) foreach println _

将按名称的调用参数转换为函数

1
def toFunction(callByName: => Int): () => Int = callByName _

默认初始值设定项

1
var x: String = _   // unloved syntax may be eliminated

我可能忘记了其他人！

举例说明为什么foo(_)和foo _不同：

此示例来自0_uuuu：

1
2
3
4
5
6
7
8
trait PlaceholderExample {
  def process[A](f: A => Unit)

  val set: Set[_ => Unit]

  set.foreach(process _) // Error
  set.foreach(process(_)) // No Error
}

在第一种情况下，process _表示一种方法；scala采用多态方法，并试图通过填充类型参数使其同构，但意识到没有可以为A填充的类型可以给出(_ => Unit) => ?类型(存在的_不是一种类型)。

在第二种情况下，process(_)是lambda；在编写没有显式参数类型的lambda时，scala根据foreach预期的参数推断类型，_ => Unit是类型(而普通_不是)，因此可以替换和推断它。

这可能是我遇到过的斯卡拉最棘手的问题。

请注意，此示例在2.13中编译。忽略它，就像它被分配给下划线一样。

相关讨论

从常见问题解答中(我的条目)，我当然不能保证是完整的(我在两天前添加了两个条目)：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import scala._    // Wild card -- all of Scala is imported
import scala.{ Predef => _, _ } // Exception, everything except Predef
def f[M[_]]       // Higher kinded type parameter
def f(m: M[_])    // Existential type
_ + _             // Anonymous function placeholder parameter
m _               // Eta expansion of method into method value
m(_)              // Partial function application
_ => 5            // Discarded parameter
case _ =>         // Wild card pattern -- matches anything
val (a, _) = (1, 2) // same thing
for (_ <- 1 to 10)  // same thing
f(xs: _*)         // Sequence xs is passed as multiple parameters to f(ys: T*)
case Seq(xs @ _*) // Identifier xs is bound to the whole matched sequence
var i: Int = _    // Initialization to the default value
def abc_<>!       // An underscore must separate alphanumerics from symbols on identifiers
t._2              // Part of a method name, such as tuple getters
1_000_000         // Numeric literal separator (Scala 2.13+)

这也是这个问题的一部分。

相关讨论

对下划线的用法的一个很好的解释是scala uuuuu[下划线]魔力。

实例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 def matchTest(x: Int): String = x match {
     case 1 =>"one"
     case 2 =>"two"
     case _ =>"anything other than one and two"
 }

 expr match {
     case List(1,_,_) =>" a list with three element and the first element is 1"
     case List(_*)  =>" a list with zero or more elements"
     case Map[_,_] =>" matches a map with any key type and any value type"
     case _ =>
 }

 List(1,2,3,4,5).foreach(print(_))
 // Doing the same without underscore:
 List(1,2,3,4,5).foreach( a => print(a))

在斯卡拉中，EDCOX1×0在导入包时与Java中的EDCOX1(1)类似。

1
2
3
4
5
6
7
8
9
10
11
// Imports all the classes in the package matching
import scala.util.matching._

// Imports all the members of the object Fun (static import in Java).
import com.test.Fun._

// Imports all the members of the object Fun but renames Foo to Bar
import com.test.Fun.{ Foo => Bar , _ }

// Imports all the members except Foo. To exclude a member rename it to _
import com.test.Fun.{ Foo => _ , _ }

在scala中，将为对象中的所有非私有var隐式定义getter和setter。getter名称与变量名相同，setter名称增加了_=。

1
2
3
4
5
6
7
8
class Test {
    private var a = 0
    def age = a
    def age_=(n:Int) = {
            require(n>0)
            a = n
    }
}

用途：

1
2
3
val t = new Test
t.age = 5
println(t.age)

如果您试图将一个函数赋给一个新的变量，该函数将被调用，结果将被赋给该变量。这种混淆是由于方法调用的可选大括号造成的。我们应该在函数名后使用u将其分配给另一个变量。

1
2
3
4
5
6
class Test {
    def fun = {
        // Some code
    }
    val funLike = fun _
}
相关讨论

有一个用法我可以看到这里的每个人似乎都忘了列出…

而不是这样做：

1
List("foo","bar","baz").map(n => n.toUpperCase())

您可以简单地执行以下操作：

1
List("foo","bar","baz").map(_.toUpperCase())
相关讨论

以下是使用_的更多示例：

1
2
3
4
5
6
7
8
9
val nums = List(1,2,3,4,5,6,7,8,9,10)

nums filter (_ % 2 == 0)

nums reduce (_ + _)

nums.exists(_ > 5)

nums.takeWhile(_ < 8)

在上述所有示例中，一个下划线表示列表中的一个元素(对于reduce，第一个下划线表示累加器)

除了杰罗提到的用法外，我还喜欢这个：

1
2
3
def getConnectionProps = {
    ( Config.getHost, Config.getPort, Config.getSommElse, Config.getSommElsePartTwo )
}

如果有人需要所有连接属性，他可以执行以下操作：

1
val ( host, port, sommEsle, someElsePartTwo ) = getConnectionProps

如果只需要主机和端口，可以执行以下操作：

1
val ( host, port, _, _ ) = getConnectionProps

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
import scala._    // Wild card -- all of Scala is imported

import scala.{ Predef => _, _ } // Exclusion, everything except Predef

def f[M[_]]       // Higher kinded type parameter

def f(m: M[_])    // Existential type

_ + _             // Anonymous function placeholder parameter

m _               // Eta expansion of method into method value

m(_)              // Partial function application

_ => 5            // Discarded parameter

case _ =>         // Wild card pattern -- matches anything

f(xs: _*)         // Sequence xs is passed as multiple parameters to f(ys: T*)

case Seq(xs @ _*) // Identifier xs is bound to the whole matched sequence

Please check the below link for more details

[https://docs.scala-lang.org/tutorials/FAQ/finding-symbols.html][1]

有一个特定的例子可以用"uu"来表示：

1
2
3
  type StringMatcher = String => (String => Boolean)

  def starts: StringMatcher = (prefix:String) => _ startsWith prefix

可能等于：

1
  def starts: StringMatcher = (prefix:String) => (s)=>s startsWith prefix

在某些情况下应用"u"将自动转换为"(x$n)=>x$n"

相关讨论