การใช้ขีดเส้นใต้ในสกาลาคืออะไร

ฉันเอาดูที่รายการของการสำรวจดำเนินการใน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 _

การแปลงพารามิเตอร์ call-by-name เป็นฟังก์ชัน

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 ใช้วิธี polymorphic และพยายามทำให้ monomorphic โดยการกรอกพารามิเตอร์ประเภท แต่ตระหนักว่าไม่มีประเภทที่สามารถเติมลงในAที่จะให้ประเภท(_ => Unit) => ?(Existential _ไม่ใช่ประเภท)

ในกรณีที่สองprocess(_)คือแลมบ์ดา เมื่อเขียนแลมบ์ดาที่ไม่มีประเภทอาร์กิวเมนต์ที่ชัดเจน Scala infers ประเภทจากการโต้แย้งที่foreachคาดหวังและ_ => Unit เป็นประเภท (ในขณะที่เพียงแค่ไม่ธรรมดา_) ดังนั้นมันสามารถทดแทนและอนุมาน

นี่อาจเป็น gotcha ที่ยากที่สุดใน Scala ที่ฉันเคยพบมา

โปรดทราบว่าตัวอย่างนี้รวบรวมใน 2.13 ไม่ต้องสนใจมันเหมือนถูกมอบหมายให้ขีดเส้นใต้

จาก (รายการของฉัน) ในคำถามที่พบบ่อยซึ่งแน่นอนว่าฉันไม่รับประกันว่าจะเสร็จสมบูรณ์ (ฉันเพิ่มสองรายการเมื่อสองวันก่อน):

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

นี่เป็นส่วนหนึ่งของคำถามนี้

คำอธิบายที่ดีของการใช้ประโยชน์จากการขีดล่างคือสกาล่า _ [ขีด] มายากล

ตัวอย่าง:

 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 จะถูกกำหนดโดยปริยายสำหรับ vars ที่ไม่ใช่แบบส่วนตัวทั้งหมดในวัตถุ ชื่อ 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 _
}

มีการใช้หนึ่งครั้งที่ฉันเห็นทุกคนที่นี่ดูเหมือนจะลืมรายการ ...

แทนที่จะทำสิ่งนี้:

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

มีตัวอย่างเฉพาะที่ใช้ "_":

  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” โดยอัตโนมัติ