Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian · Pelajaran

given/using Scala 3

Sintaks moden

Pelajaran 2 daripada 413 langkah

given/using Scala 3 ialah pelajaran Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian percuma di CoddyKit. Ini ialah pelajaran 2 daripada 4. Anda boleh membaca keseluruhan pelajaran di bawah secara percuma — kemudian berlatih secara praktikal dalam pelayar menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian merangkumi sejumlah 4 pelajaran.

Implisit moden dalam Scala 3

Scala 3 menggantikan kata kunci implicit yang mempunyai pelbagai fungsi dengan sintaks yang lebih jelas: given mentakrifkan nilai implisit, manakala using mengisytiharkan parameter implisit. Tujuannya jauh lebih mudah dibaca.

object Main:
  given greeting: String = "Hello"
  def greet(name: String)(using g: String): String = s"$g, $name!"
  def main(args: Array[String]): Unit =
    println(greet("Ann"))

given menggantikan implicit val

Apabila Scala 2 menulis implicit val x: T = ..., Scala 3 menulis given x: T = .... Ini mengisytiharkan nilai yang tersedia untuk penyelesaian implisit.

object Main:
  given factor: Int = 10
  def scale(x: Int)(using f: Int): Int = x * f
  def main(args: Array[String]): Unit =
    println(scale(5))

using menggantikan parameter implisit

Klausa using menandakan senarai parameter sebagai implisit. Pengompil mengisinya daripada given yang sepadan dalam skop.

object Main:
  given unit: String = "kg"
  def label(n: Int)(using u: String): String = s"$n$u"
  def main(args: Array[String]): Unit =
    println(label(75))

given tanpa nama

Anda boleh mengabaikan nama given apabila Anda tidak akan merujuknya secara terus. Pengompil masih mencarinya mengikut jenis.

object Main:
  given Int = 3
  def triple(x: Int)(using f: Int): Int = x * f
  def main(args: Array[String]): Unit =
    println(triple(7))

Mendapatkan dengan summon

summon[T] dalam Scala 3 menggantikan implicitly[T]. Ia mendapatkan nilai given berjenis T secara terus.

object Main:
  given name: String = "Scala 3"
  def main(args: Array[String]): Unit =
    val n = summon[String]
    println(n)

Parameter using tanpa nama

Jika Anda hanya perlu meneruskan parameter using, Anda boleh membiarkannya tanpa nama dalam klausa: (using Int). Dapatkannya di dalam dengan summon.

object Main:
  given Int = 100
  def boosted(x: Int)(using Int): Int = x + summon[Int]
  def main(args: Array[String]): Unit =
    println(boosted(5))

given untuk kelas jenis

Penggunaan given/using yang paling mengikut kebiasaan ialah untuk kelas jenis. Takrifkan trait, sediakan tika given dan minta tika itu dengan using.

trait Show[A]:
  def show(a: A): String

object Main:
  given Show[Int] with
    def show(a: Int): String = s"Int($a)"

  def display[A](a: A)(using s: Show[A]): String = s.show(a)

  def main(args: Array[String]): Unit =
    println(display(42))

Ikatan konteks masih berfungsi

Ikatan konteks [A: Show] masih tersedia dan dikembangkan menjadi parameter using. Gabungkannya dengan summon untuk mengakses tika tersebut.

trait Show[A]:
  def show(a: A): String

object Main:
  given Show[String] with
    def show(a: String): String = s"Str($a)"

  def display[A: Show](a: A): String = summon[Show[A]].show(a)

  def main(args: Array[String]): Unit =
    println(display("hi"))

Menghantar argumen using secara eksplisit

Anda boleh membekalkan parameter using secara eksplisit dengan kata kunci using di tapak panggilan, lalu mengatasi given yang berada dalam skop.

object Main:
  given Int = 10
  def scale(x: Int)(using f: Int): Int = x * f
  def main(args: Array[String]): Unit =
    println(scale(5))
    println(scale(5)(using 2))

Import given

Scala 3 mempunyai sintaks khusus untuk mengimport given: import pkg.given atau import pkg.{given Show[Int]}. Ini menjadikan import implisit jelas dan disengajakan.

object Instances:
  given Int = 5

object Main:
  import Instances.given
  def addBase(x: Int)(using b: Int): Int = x + b
  def main(args: Array[String]): Unit =
    println(addBase(10))

Sebab sintaks baharu

Dalam Scala 2, kata kunci tunggal implicit membawa beberapa maksud yang berbeza. Scala 3 memisahkan konsep itu: given = menyediakan, using = memerlukan. Kod menjadi lebih jelas dan ralat lebih mudah difahami.

object Main:
  given pi: Double = 3.14159
  def area(r: Double)(using p: Double): Double = p * r * r
  def main(args: Array[String]): Unit =
    println(area(2.0))

Semakan Pantas

Dalam Scala 3, kata kunci apakah yang menggantikan implicit untuk menyediakan dan memerlukan nilai?

Jawab dalam pelajaran interaktif

Imbas Kembali

Anda telah mempelajari given/using Scala 3:

given menyediakan nilai implisit (menggantikan implicit val)
using mengisytiharkan parameter implisit
summon[T] menggantikan implicitly[T]
Given boleh tanpa nama dan sesuai untuk kelas jenis
import pkg.given mengimportnya secara eksplisit

Percuma untuk bermula

Pelajari Scala dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 39
Pelajaran: 143

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “given/using Scala 3” percuma?

Ya — teks penuh “given/using Scala 3” boleh dibaca secara percuma di web ini. Untuk berlatih secara interaktif menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7, serta membuka kunci baki kursus Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian, tingkat taraf kepada CoddyKit PRO. Kursus Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “given/using Scala 3”?

Sintaks moden Anda berlatih Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 2 daripada 4.

Berapa lamakah pelajaran “given/using Scala 3” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian ini?

Ya. Setiap pelajaran Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

← Kembali ke Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian