Scala中下划线的所有用法是什么？
我看了一下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") }
通配符导入
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 _
可能有其他的我已经忘记了！
举例说明为什么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中最棘手的问题。
从常见问题中的（我的输入），我当然不保证它是完整的（前两天我添加了两个条目）：
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
这也是这个问题的一部分。
下划线的用法的一个很好的解释是Scala _ [下划线]魔术。
例子：
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))
在Scala中，在导入包时， _在Java中与*类似。
// 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中，对于对象中的所有非私有变量，隐式定义了一个getter和setter。 获取者名称与变量名称相同，并且为设置者名称添加_= 。
class Test {
private var a = 0
def age = a
def age_=(n:Int) = {
require(n>0)
a = n
}
}
用法：
val t = new Test
t.age = 5
println(t.age)
如果您尝试将函数分配给新变量，则会调用该函数，并将结果分配给该变量。 由于方法调用的可选花括号，所以会出现这种混淆。 我们应该在函数名称后面使用_来将它分配给另一个变量。
class Test {
def fun = {
// Some code
}
val funLike = fun _
}