스칼라에서 밑줄의 모든 용도는 무엇입니까?

나는 한 번 봐 찍은 목록 에 찍은 설문 조사의 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 _에는 방법을 나타냅니다. 스칼라는 다형성 방법을 취하여 type 매개 변수를 채워서 다형성으로 만들려고 시도하지만 유형 을 A제공하기 위해 채울 수있는 유형 이 없음을 알고 있습니다 (_ => Unit) => ?(기존 유형 _이 아님).

두 번째 경우 process(_)는 람다입니다. 명시적인 인수 유형 람다를 작성할 때, 스칼라 인자에서 그 형태를 추론 foreach이 기대를하고 _ => Unit 있다 (반면 평범한 타입 _아님)는 치환 및 추론 될 수 있도록.

이것은 내가 경험 한 스칼라에서 가장 까다로운 문제 일 수 있습니다.

이 예제는 2.13에서 컴파일됩니다. 밑줄에 지정된 것처럼 무시하십시오.

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+)

이것 또한 이 질문의 일부입니다 .

밑줄 사용에 대한 훌륭한 설명은 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))

스칼라에서는 패키지를 가져 오는 동안 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 => _ , _ }

스칼라에서 getter와 setter는 객체의 모든 비 개인 var에 대해 암시 적으로 정의됩니다. 게터 이름은 변수 이름과 동일 _=하며 세터 이름에 추가됩니다.

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)

위의 모든 예에서 하나의 밑줄은 목록의 요소를 나타냅니다 (첫 번째 밑줄은 축약기를 나타냅니다)

JAiro가 언급 한 사용법 외에 , 나는 이것을 좋아합니다.

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

누군가가 모든 연결 속성이 필요한 경우 다음을 수행 할 수 있습니다.

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

호스트와 포트만 필요한 경우 다음을 수행 할 수 있습니다.

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

"_"가 사용되는 특정 예가 있습니다.

  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"으로 변환됩니다.