我看了一下scala-lang.org上的调查列表，注意到一个奇怪的问题:“你能说出“_”的所有用法吗?”你能吗?如果有，请在这里填写。解释性的例子是赞赏的。
当前回答
我能想到的是
存在的类型
def foo(l: List[Option[_]]) = ...
更高类型的类型参数
case class A[K[_],T](a: K[T])
忽略的变量
val _ = 5
忽略参数
List(1, 2, 3) foreach { _ => println("Hi") }
忽略了自我类型的名称
trait MySeq { _: Seq[_] => }
通配符模式
Some(5) match { case Some(_) => println("Yes") }
插值中的通配符模式
"abc" match { case s"a$_c" => }
模式中的序列通配符
C(1, 2, 3) match { case C(vs @ _*) => vs.foreach(f(_)) }
通配符进口
import java.util._
隐藏的进口
import java.util.{ArrayList => _, _}
致运营商的联名信
def bang_!(x: Int) = 5
赋值操作符
def foo_=(x: Int) { ... }
占位符的语法
List(1, 2, 3) map (_ + 2)
值方法
List(1, 2, 3) foreach println _
将名称调用参数转换为函数
def toFunction(callByName: => Int): () => Int = callByName _
默认初始化
var x: String = _ // unloved syntax may be eliminated
也许还有其他人我已经忘记了!
示例说明foo(_)和foo _的不同之处:
这个例子来自0__:
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是一个类型(而普通的_不是)，所以它可以被替换和推断。
这可能是我在Scala中遇到的最棘手的问题。
注意，这个示例在2.13中编译。忽略它，就像它被指定为下划线一样。
其他回答
这里有一个使用“_”的具体例子:
type StringMatcher = String => (String => Boolean)
def starts: StringMatcher = (prefix:String) => _ startsWith prefix
可能等于:
def starts: StringMatcher = (prefix:String) => (s)=>s startsWith prefix
在某些情况下应用" _ "将自动转换为" (x$n) => x$n "
我能想到的是
存在的类型
def foo(l: List[Option[_]]) = ...
更高类型的类型参数
case class A[K[_],T](a: K[T])
忽略的变量
val _ = 5
忽略参数
List(1, 2, 3) foreach { _ => println("Hi") }
忽略了自我类型的名称
trait MySeq { _: Seq[_] => }
通配符模式
Some(5) match { case Some(_) => println("Yes") }
插值中的通配符模式
"abc" match { case s"a$_c" => }
模式中的序列通配符
C(1, 2, 3) match { case C(vs @ _*) => vs.foreach(f(_)) }
通配符进口
import java.util._
隐藏的进口
import java.util.{ArrayList => _, _}
致运营商的联名信
def bang_!(x: Int) = 5
赋值操作符
def foo_=(x: Int) { ... }
占位符的语法
List(1, 2, 3) map (_ + 2)
值方法
List(1, 2, 3) foreach println _
将名称调用参数转换为函数
def toFunction(callByName: => Int): () => Int = callByName _
默认初始化
var x: String = _ // unloved syntax may be eliminated
也许还有其他人我已经忘记了!
示例说明foo(_)和foo _的不同之处:
这个例子来自0__:
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是一个类型(而普通的_不是)，所以它可以被替换和推断。
这可能是我在Scala中遇到的最棘手的问题。
注意，这个示例在2.13中编译。忽略它，就像它被指定为下划线一样。
除了JAiro提到的用法，我还喜欢这个用法:
def getConnectionProps = {
( Config.getHost, Config.getPort, Config.getSommElse, Config.getSommElsePartTwo )
}
如果有人需要所有的连接属性，他可以这样做:
val ( host, port, sommEsle, someElsePartTwo ) = getConnectionProps
如果你只需要一个主机和一个端口，你可以做:
val ( host, port, _, _ ) = getConnectionProps
从FAQ中的(我的条目)，我当然不保证是完整的(我两天前添加了两个条目):
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+)
这也是这个问题的一部分。
有一种用法我发现在座的每个人似乎都忘了列出…
而不是这样做:
List("foo", "bar", "baz").map(n => n.toUpperCase())
你可以简单地这样做:
List("foo", "bar", "baz").map(_.toUpperCase())
