В чем смысл использования подчеркивания в Scala?

Те, о которых я могу думать, – это

Экзистенциальные типы

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 принимает полиморфный метод и пытается сделать его monoморфным, заполнив параметр типа, но понимает, что нет типа, который может быть заполнен для A , который даст тип (_ => Unit) => ? (Экзистенциальный _ не является типом).

Во втором случае process(_) является лямбдой; при написании lambda без явного типа аргумента Scala выводит тип из аргумента, который ожидает foreach , а _ => Unit – это тип (тогда как простой – нет), поэтому его можно заменить и вывести.

Это может быть самая сложная добыча в 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 _ [underscore] .

Примеры:

  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 геттер и сеттер будут неявно определены для всех неличных варов в объекте. Имя получателя совпадает с именем переменной и _= добавляется для имени сеттера.

 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 _ } 

Есть одно использование, которое я вижу, все здесь, похоже, забыли перечислить …

Вместо этого:

 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) 

Во всех вышеприведенных примерах один знак подчеркивания представляет собой элемент в списке (для уменьшения первого подчеркивания представляет собой аккумулятор)

Кроме того, что Джэйро упомянул, мне нравится этот:

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

Если кому-то нужны все свойства соединения, он может:

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

Если вам нужен только хост и порт, вы можете сделать:

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

 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 

Существует конкретный пример использования «_»:

  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”