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


540

Я взглянул на список опросов, проведенных на scala-lang.org, и заметил интересный вопрос: « Можете ли вы назвать все случаи использования« _ »? ». Ты можешь? Если да, пожалуйста, сделайте это здесь. Пояснительные примеры приветствуются.


15
Я прочитал этот приличный набор слайдов не так давно: Scala Dreaded Underscore
Дэн Бертон

5
Смотрите также презентацию The Dreaded _ на Slideshare
Mifeet,

Ответы:


576

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

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

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) => ?(Existential _не является типом).

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

Это может быть самая хитрая ошибка в Scala, с которой я когда-либо сталкивался.

Обратите внимание, что этот пример компилируется в 2.13. Проигнорируйте это, как это было назначено, чтобы подчеркнуть.


4
Я думаю, что есть два или три, которые все подходят для подчеркивания при сопоставлении с образцом, но +1 для объединения букв в пунктуацию! :-)
Даниэль С. Собрал

22
val x: Any = _
Джованни Ботта

2
@ Я не думаю, что println _ - это частично примененная функция. Это еще один пример синтаксиса заполнителя правильно? Значение карты (_ + 2) расширяется до чего-то похожего на карту (x => x + 2) так же, как pritnln (_) расширяется до чего-то похожего на карту (x => println (x))
Эндрю Кэссиди

7
@AndrewCassidy На самом деле println _и println(_)разные. Вы можете видеть это, например, в том, что они обрабатывают экзистенциальный и полиморфный типы немного по-разному. Придумаем пример чуть позже.
Оуэн

3
@AndrewCassidy Хорошо, я добавил пример.
Оуэн

179

Из (моей записи) в 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+)

Это тоже часть этого вопроса .


2
Может быть, вы можете добавить var i: Int = _или особый случай сопоставления с образцом val (a, _) = (1, 2)или особый случай отбрасывания valfor (_ <- 1 to 10) doIt()
huynhjl

1
И def f: T; def f_=(t: T)комбо для создания изменяемого члена f.
huynhjl

Сопоставление с образцом уже рассмотрено, а _имена методов - обман. Но, хорошо, хорошо. Я просто надеюсь, что кто-то еще обновит FAQ ... :-)
Даниэль С. Собрал

1
Может быть, вы скучаете по этому. vertx.newHttpServer.websocketHandler (_. writeXml (html))
ангелох,

@angelokh Это параметр-заполнитель анонимной функции, пятый в списке.
Даниэль С. Собрал,

84

Отличным объяснением использования подчеркивания является Scala _ [underscore] magic .

Примеры:

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

2
Это хорошее объяснение, но даже не все из них. В нем отсутствуют игнорируемые параметры / переменные, объединяющие буквы и знаки пунктуации, экзистенциальные типы, типы с более высоким родом
Оуэн,

по-вашему, List(1,2,3,4,5).foreach(print(_))это гораздо удобнее для чтения List(1,2,3,4,5).foreach(print), вам даже не нужно подчеркивание, но я думаю, это просто вопрос стиля
Electric Coffee

1
как насчет "_" в качестве заполнителя в коллекциях с функцией .map, .flatten, .toList ...... Иногда это вызывает недопонимание. :(
m0z4rt

34

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

Вместо того, чтобы делать это:

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

Вы можете просто сделать это:

List("foo", "bar", "baz").map(_.toUpperCase())

так _ здесь действует как пространство имен всех доступных функций?
Crt

2
@Crt нет, это действует как сокращение дляn => n
Электрический Кофе

2
разве это не синтаксис заполнителя, упомянутый в двух верхних ответах?
Джоэлб

13

Вот еще несколько примеров, где _используется:

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)

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


11

Помимо использований , что Хайро упомянул, мне нравится это:

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

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

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

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

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

0

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

  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»


чувствую, что пример каждого является элементом итерации, я думаю, что это больше похоже на сахар синтаксиса низкого уровня, - говорит ламбда-лаконичное преобразование
Ke.Steve
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.