Scala for Backend Engineering & Functional Programming · Pelajaran

Parameter Implisit

Meneruskan konteks.

Parameter Implisit adalah pelajaran Scala for Backend Engineering & Functional Programming gratis di CoddyKit. Ini adalah pelajaran 1 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Scala for Backend Engineering & Functional Programming, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Scala for Backend Engineering & Functional Programming mencakup 4 pelajaran total.

Meneruskan konteks secara otomatis

Parameter implisit memungkinkan kompiler menyediakan argumen untuk Anda, yang diambil dari nilai yang ditandai implicit dalam lingkup. Parameter ini sangat cocok untuk meneruskan konteks "lingkungan" seperti konfigurasi atau aturan pemformatan.

object Main {
  def greet(name: String)(implicit greeting: String): String =
    s"$greeting, $name!"
  implicit val defaultGreeting: String = "Hello"
  def main(args: Array[String]): Unit = {
    println(greet("Ann"))
  }
}

Daftar parameter implisit

Tandai daftar parameter terakhir dengan kata kunci implicit. Ketika Anda menghilangkannya di lokasi pemanggilan, kompiler mencari nilai implisit yang cocok.

object Main {
  def multiply(x: Int)(implicit factor: Int): Int = x * factor
  implicit val f: Int = 10
  def main(args: Array[String]): Unit = {
    println(multiply(5))
  }
}

Menyediakan implisit secara eksplisit

Anda selalu dapat meneruskan parameter implisit secara eksplisit, sehingga menimpa parameter yang ada dalam lingkup. Ini berguna untuk kasus-kasus tertentu.

object Main {
  def multiply(x: Int)(implicit factor: Int): Int = x * factor
  implicit val f: Int = 10
  def main(args: Array[String]): Unit = {
    println(multiply(5))
    println(multiply(5)(2))
  }
}

Resolusi implisit berdasarkan tipe

Kompiler mencocokkan implisit berdasarkan tipe, bukan nama. Harus ada tepat satu nilai implisit yang cocok dalam lingkup; jika tidak, kompilasi gagal karena nilai ambigu atau tidak ditemukan.

object Main {
  case class Config(env: String)
  def run()(implicit cfg: Config): String = s"running in ${cfg.env}"
  implicit val cfg: Config = Config("prod")
  def main(args: Array[String]): Unit = {
    println(run())
  }
}

implicitly untuk mengambil nilai

Pembantu implicitly[T] mengambil nilai implisit bertipe T langsung dari lingkup, tanpa menamai parameter.

object Main {
  implicit val name: String = "Scala"
  def main(args: Array[String]): Unit = {
    val n = implicitly[String]
    println(n)
  }
}

Singkatan batas konteks

Batas konteks [T: Ordering] adalah sintaks singkat untuk parameter implisit bertipe Ordering[T]. Ini umum digunakan bersama kelas tipe.

object Main {
  def max[T: Ordering](a: T, b: T): T = {
    val ord = implicitly[Ordering[T]]
    if (ord.gt(a, b)) a else b
  }
  def main(args: Array[String]): Unit = {
    println(max(3, 7))
    println(max("apple", "pear"))
  }
}

Meneruskan konteks melalui pemanggilan

Parameter implisit sangat berguna ketika banyak fungsi memerlukan konteks yang sama. Tandai konteks tersebut sebagai implisit sekali, lalu konteks itu mengalir melalui pemanggilan bertingkat secara otomatis.

object Main {
  case class User(name: String)
  def log(msg: String)(implicit u: User): Unit =
    println(s"[${u.name}] $msg")
  def doWork()(implicit u: User): Unit = {
    log("started")
    log("finished")
  }
  implicit val current: User = User("admin")
  def main(args: Array[String]): Unit = {
    doWork()
  }
}

Tempat implisit dicari

Kompiler mencari implisit di lingkup lokal, dalam impor, dan di objek pendamping dari tipe-tipe yang terkait. Objek pendamping merupakan tempat yang rapi untuk menyediakan nilai bawaan.

object Main {
  case class Currency(symbol: String)
  object Currency {
    implicit val default: Currency = Currency("$")
  }
  def price(amount: Int)(implicit c: Currency): String = s"${c.symbol}$amount"
  def main(args: Array[String]): Unit = {
    println(price(50))
  }
}

Kesalahan ambiguitas

Jika terdapat dua implisit bertipe sama dalam lingkup, kompiler melaporkan kesalahan implisit ambigu. Pertahankan paling banyak satu implisit untuk setiap tipe, atau teruskan secara eksplisit.

object Main {
  def label(x: Int)(implicit unit: String): String = s"$x$unit"
  implicit val unit: String = "px"
  def main(args: Array[String]): Unit = {
    // Only one implicit String in scope -> no ambiguity
    println(label(12))
  }
}

Perilaku seperti nilai bawaan

Parameter implisit memberikan bentuk nilai bawaan yang sadar konteks: pemanggilan fungsi yang sama menghasilkan hasil berbeda, bergantung pada implisit yang ada dalam lingkup.

object Main {
  def format(n: Double)(implicit decimals: Int): String =
    f"$n%.${decimals}f"
  implicit val d: Int = 2
  def main(args: Array[String]): Unit = {
    println(format(3.14159))
    println(format(3.14159)(4))
  }
}

Gunakan implisit secukupnya

Parameter implisit memang kuat, tetapi dapat membuat kode lebih sulit dipahami jika digunakan berlebihan. Gunakan untuk konteks lintas-aspek yang benar-benar diperlukan, seperti konteks eksekusi, konfigurasi, dan instans kelas tipe.

object Main {
  case class Locale(code: String)
  def hello()(implicit loc: Locale): String =
    if (loc.code == "tr") "Merhaba" else "Hello"
  implicit val loc: Locale = Locale("tr")
  def main(args: Array[String]): Unit = {
    println(hello())
  }
}

Pemeriksaan singkat

Bagaimana kompiler menentukan nilai yang harus disediakan untuk parameter implisit?

Rangkuman

Anda telah mempelajari parameter implisit (gaya Scala 2):

Tandai daftar parameter dengan implicit agar diisi secara otomatis
Resolusi dilakukan berdasarkan tipe, yang harus unik dalam lingkup
implicitly[T] mengambil sebuah nilai; batas konteks [T: TC] adalah sintaks singkat
Pencarian mencakup lingkup lokal, impor, dan objek pendamping
Gunakan untuk konteks lintas-aspek, bukan untuk segala hal

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Parameter Implisit” gratis?

Ya — teks lengkap “Parameter Implisit” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Scala for Backend Engineering & Functional Programming, upgrade ke CoddyKit PRO. Kursus Scala for Backend Engineering & Functional Programming mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Parameter Implisit”?

Meneruskan konteks. Kamu berlatih Scala for Backend Engineering & Functional Programming dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Scala for Backend Engineering & Functional Programming?

Tidak diperlukan pengalaman sebelumnya. Scala for Backend Engineering & Functional Programming di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 1 dari 4.

Berapa lama pelajaran “Parameter Implisit” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Scala for Backend Engineering & Functional Programming ini?

Ya. Setiap pelajaran Scala for Backend Engineering & Functional Programming menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

← Kembali ke Scala for Backend Engineering & Functional Programming