ในงานสกาล่าโดยปริยายเป็น :
แปลง
หัวฉีดค่าพารามิเตอร์
การใช้งานโดยนัยมี 3 ประเภท
การแปลงประเภทโดยนัย : แปลงข้อผิดพลาดที่ทำให้การกำหนดเป็นประเภทที่ต้องการ
val x: String = "1"
val y: Int = x
Stringไม่ได้เป็นชนิดย่อยของ Intดังนั้นข้อผิดพลาดที่เกิดขึ้นในสาย 2. ในการแก้ไขข้อผิดพลาดคอมไพเลอร์จะมองหาวิธีการดังกล่าวอยู่ในขอบเขตที่มีคำหลักโดยปริยายและใช้เวลาเป็นสตริงเป็นอาร์กิวเมนต์และส่งกลับInt
ดังนั้น
implicit def z(a:String):Int = 2
val x :String = "1"
val y:Int = x // compiler will use z here like val y:Int=z(x)
println(y) // result 2 & no error!
การแปลงตัวรับโดยปริยาย : โดยทั่วไปแล้วเราจะใช้คุณสมบัติของวัตถุที่รับสัญญาณเช่น วิธีการหรือตัวแปร ดังนั้นการเรียกคุณสมบัติใด ๆ โดยผู้รับคุณสมบัติต้องเป็นสมาชิกของคลาส / วัตถุของผู้รับนั้น
class Mahadi{
val haveCar:String ="BMW"
}
class Johnny{
val haveTv:String = "Sony"
}
val mahadi = new Mahadi
mahadi.haveTv // Error happening
ที่นี่mahadi.haveTvจะสร้างข้อผิดพลาด เพราะสกาล่าคอมไพเลอร์แรกจะมองหาhaveTvคุณสมบัติการMahadiรับ มันจะไม่พบ ประการที่สองก็จะมองหาวิธีการที่อยู่ในขอบเขตที่มีคำหลักโดยปริยายซึ่งใช้วัตถุ Mahadiเป็นอาร์กิวเมนต์และส่งกลับวัตถุจอห์นนี่ แต่มันไม่มีที่นี่ ดังนั้นมันจะสร้างข้อผิดพลาด แต่ต่อไปนี้ก็โอเค
class Mahadi{
val haveCar:String ="BMW"
}
class Johnny{
val haveTv:String = "Sony"
}
val mahadi = new Mahadi
implicit def z(a:Mahadi):Johnny = new Johnny
mahadi.haveTv // compiler will use z here like new Johnny().haveTv
println(mahadi.haveTv)// result Sony & no error
การฉีดพารามิเตอร์โดยปริยาย : ถ้าเราเรียกใช้เมธอดและไม่ผ่านค่าพารามิเตอร์มันจะทำให้เกิดข้อผิดพลาด คอมไพเลอร์สกาล่าทำงานเช่นนี้ - ก่อนจะพยายามส่งผ่านค่า แต่จะไม่ได้รับค่าโดยตรงสำหรับพารามิเตอร์
def x(a:Int)= a
x // ERROR happening
ประการที่สองถ้าพารามิเตอร์มีคำหลักนัยใด ๆ ก็จะมองหาใด ๆValในขอบเขตที่มีชนิดเดียวกันของมูลค่า หากไม่ได้รับจะทำให้เกิดข้อผิดพลาด
def x(implicit a:Int)= a
x // error happening here
เพื่อ slove เรียบเรียงปัญหานี้จะมองหาVal นัยมีประเภทของ Intเพราะพารามิเตอร์มีคำหลักโดยปริยาย
def x(implicit a:Int)=a
implicit val z:Int =10
x // compiler will use implicit like this x(z)
println(x) // will result 10 & no error.
ตัวอย่างอื่น:
def l(implicit b:Int)
def x(implicit a:Int)= l(a)
เรายังสามารถเขียนมันเหมือน -
def x(implicit a:Int)= l
เพราะลิตรมีพารามิเตอร์โดยปริยายและอยู่ในขอบเขตของร่างกายวิธีการของ Xจะมีตัวแปรท้องถิ่นโดยปริยาย ( พารามิเตอร์ตัวแปรท้องถิ่น ) ซึ่งเป็นพารามิเตอร์ของxดังนั้นในร่างกายของ x วิธีวิธีลายเซ็นค่าอาร์กิวเมนต์ l's นัยคือ ยื่นฟ้องโดยตัวแปรนัย x วิธีการของท้องถิ่น (พารามิเตอร์)โดยปริยาย a
ดังนั้น
def x(implicit a:Int)= l
จะอยู่ในคอมไพเลอร์แบบนี้
def x(implicit a:Int)= l(a)
ตัวอย่างอื่น:
def c(implicit k:Int):String = k.toString
def x(a:Int => String):String =a
x{
x => c
}
ก็จะทำให้เกิดข้อผิดพลาดเพราะคในx {x => C}ความต้องการในการโต้เถียงหรือ Val นัยผ่านอย่างชัดเจนมูลค่าอยู่ในขอบเขต
ดังนั้นเราจึงสามารถทำให้ตัวอักษรของฟังก์ชันพารามิเตอร์อย่างชัดเจนโดยปริยายเมื่อเราเรียกวิธีการ x
x{
implicit x => c // the compiler will set the parameter of c like this c(x)
}
สิ่งนี้ถูกใช้ในวิธีการทำงานของ Play-Framework
in view folder of app the template is declared like
@()(implicit requestHreader:RequestHeader)
in controller action is like
def index = Action{
implicit request =>
Ok(views.html.formpage())
}
ถ้าคุณไม่พูดถึงพารามิเตอร์คำขอโดยปริยายอย่างชัดเจนคุณจะต้องเขียน -
def index = Action{
request =>
Ok(views.html.formpage()(request))
}