斯卡拉下划线的所有用法是什么？
我看了一下scala-lang.org上的调查列表 ，注意到一个奇怪的问题：“ 你能 说出 ”_“的所有用法吗？ ” 你可以吗？ 如果是的话，请在这里这样做。 解释性的例子表示赞赏。
我能想到的是
存在types
def foo(l: List[Option[_]]) = ... 更高的亲属types参数
case class A[K[_],T](a: K[T])
忽略variables
val _ = 5
忽略参数
List(1, 2, 3) foreach { _ => println("Hi") }
忽略自我types的名称
trait MySeq { _: Seq[_] => }
通配符模式
Some(5) match { case Some(_) => println("Yes") }
通配符导入
import java.util._
隐藏import
import java.util.{ArrayList => _, _}
将信件join标点符号
def bang_!(x: Int) = 5
赋值运算符
def foo_=(x: Int) { ... }
占位符语法
List(1, 2, 3) map (_ + 2)
部分应用function
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采用了多态方法，并尝试通过填充types参数来使其成为单态，但是意识到没有可以填充的types(_ => Unit) => ? A (_ => Unit) => ? （存在_不是一种types）。
在第二种情况下， process(_)是lambda; 当写一个没有明确的参数types的lambda时，Scala从foreach期望的参数中推断出types，而_ => Unit 是一个types（而普通的_不是），所以它可以被replace和推断。
这可能是我遇到过的Scala中最棘手的问题。
从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
这也是这个问题的一部分。
下划线的用法的一个很好的解释是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将被隐式定义为一个对象中的所有非私有variables。 getter名称与variables名称相同，为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)
如果您尝试将函数分配给新variables，则将调用该函数，并将结果分配给该variables。 由于方法调用的可选花括号而出现这种混淆。 我们应该在函数名称之后使用_来将它分配给另一个variables。
class Test { def fun = { // Some code } val funLike = fun _ }
有一个用法，我可以看到这里的每个人似乎已经忘记列出…
而不是这样做：
List("foo", "bar", "baz").map(n => n.toUpperCase())
你可以简单地做到这一点：
List("foo", "bar", "baz").map(_.toUpperCase())
以下是一些使用_例子：
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)
在上面所有例子中，一个下划线表示列表中的一个元素（为了减less第一个下划线表示累加器）
除了JAiro提到的用法 ，我喜欢这个：
def getConnectionProps = { ( Config.getHost, Config.getPort, Config.getSommElse, Config.getSommElsePartTwo ) }
如果有人需要所有连接属性，他可以这样做：
val ( host, port, sommEsle, someElsePartTwo ) = getConnectionProps
如果你只需要一个主机和一个端口，你可以这样做：
val ( host, port, _, _ ) = getConnectionProps
