Scala for Backend Engineering & Functional Programming · Pelajaran

Mendefinisikan Instance

Instance implisit.

Pelajaran 2 dari 413 langkah

Mendefinisikan Instance adalah pelajaran Scala for Backend Engineering & Functional Programming gratis di CoddyKit. Ini adalah pelajaran 2 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.

Mendefinisikan Instans

Sebuah instans memberi tahu kompilator cara kerja kelas tipe untuk tipe tertentu. Di Scala, instans biasanya ditandai dengan implicit (Scala 2) atau dideklarasikan dengan given (Scala 3) agar dapat ditemukan secara otomatis.

Instans val Implisit

Untuk kelas tipe sederhana, implicit val sudah memadai. Kompilator akan menemukannya ketika sebuah fungsi memerlukan Show[Int].

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

object Main {
  implicit val intShow: Show[Int] = (a: Int) => s"Int=$a"

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

  def main(args: Array[String]): Unit = {
    println(display(123))
  }
}

implicitly: Memanggil Instans

implicitly[Show[Int]] meminta kompilator mengambil instans yang berada dalam lingkup. Ini berguna untuk menguji keberadaan instans atau mengaksesnya secara langsung.

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

object Main {
  implicit val intShow: Show[Int] = (a: Int) => s"<$a>"

  def main(args: Array[String]): Unit = {
    val s = implicitly[Show[Int]]
    println(s.show(8))
  }
}

Instans untuk Tipe Kustom

Definisikan instans untuk kelas case Anda sendiri. Kelas data tetap rapi; pemformatan berada di dalam instans.

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

case class Point(x: Int, y: Int)

object Main {
  implicit val pointShow: Show[Point] = (p: Point) => s"(${p.x}, ${p.y})"

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

  def main(args: Array[String]): Unit = {
    println(display(Point(3, 4)))
  }
}

implicit def untuk Instans Generik

Ketika sebuah instans bergantung pada instans lain, gunakan implicit def. Di sini, Show[List[A]] dibangun dari Show[A].

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

object Main {
  implicit val intShow: Show[Int] = (a: Int) => a.toString

  implicit def listShow[A](implicit s: Show[A]): Show[List[A]] =
    (xs: List[A]) => xs.map(s.show).mkString("[", ", ", "]")

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

  def main(args: Array[String]): Unit = {
    println(display(List(1, 2, 3)))
  }
}

Instans dalam Objek Pendamping

Menempatkan instans di dalam objek pendamping kelas tipe membuatnya ditemukan secara otomatis tanpa import apa pun. Inilah tempat yang disarankan untuk instans bawaan.

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

object Show {
  implicit val intShow: Show[Int] = (a: Int) => s"i:$a"
  implicit val strShow: Show[String] = (a: String) => s"s:$a"
}

object Main {
  def display[A](a: A)(implicit s: Show[A]): String = s.show(a)

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

Lingkup dan Prioritas Implisit

Kompilator mencari instans di beberapa tempat: pertama di lingkup lokal atau yang diimpor, lalu di objek pendamping tipe-tipe yang terlibat. Jika dua instans sama-sama spesifik, Anda akan mendapatkan kesalahan implisit ambigu.

Singkatan Batas Konteks

Sintaks def f[A: Show](a: A) adalah batas konteks: artinya harus ada Show[A] implisit dalam lingkup. Di dalam fungsi, ambil instans tersebut dengan implicitly.

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

object Main {
  implicit val intShow: Show[Int] = (a: Int) => s"n=$a"

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

  def main(args: Array[String]): Unit = {
    println(display(77))
  }
}

Pembantu Pemanggil Instans

Pustaka menambahkan metode apply ke objek pendamping sebagai pemanggil instans yang praktis: Show[Int] mengembalikan instans tersebut. Cara ini lebih rapi daripada implicitly.

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

object Show {
  def apply[A](implicit s: Show[A]): Show[A] = s
  implicit val intShow: Show[Int] = (a: Int) => s"=$a"
}

object Main {
  def main(args: Array[String]): Unit = {
    println(Show[Int].show(10))
  }
}

Menghindari Instans Orphan

Instans orphan adalah instans yang didefinisikan bukan bersama kelas tipe maupun tipenya. Instans seperti ini sah, tetapi dapat menyebabkan perilaku yang tidak konsisten di antara berbagai import. Sebaiknya gunakan instans dalam objek pendamping agar tetap konsisten.

Menggabungkan Semuanya

Program lengkap: instans dalam objek pendamping, instans daftar turunan, dan pemanggil instans.

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

object Show {
  def apply[A](implicit s: Show[A]): Show[A] = s
  implicit val intShow: Show[Int] = _.toString
  implicit def listShow[A](implicit s: Show[A]): Show[List[A]] =
    (xs: List[A]) => xs.map(s.show).mkString(", ")
}

object Main {
  def main(args: Array[String]): Unit = {
    println(Show[List[Int]].show(List(4, 5, 6)))
  }
}

Pemeriksaan Singkat

Uji pengetahuan Anda tentang pendefinisian instans.

Jawab di pelajaran interaktif

Rangkuman

Anda telah mempelajari cara mendefinisikan instans:

implicit val untuk instans sederhana, implicit def untuk instans turunan.
Panggil dengan implicitly atau apply pada objek pendamping.
Gunakan batas konteks [A: Show] sebagai singkatan.
Letakkan instans dalam objek pendamping untuk menghindari instans orphan.

Gratis untuk memulai

Belajar Scala dengan tutor AI — gratis

Tulis dan jalankan kode asli di browser kamu, dapatkan bantuan instan dari tutor AI 24/7, dan lanjutkan di mana kamu tinggalkan di web atau aplikasi.

Kursus: 39
Pelajaran: 143

Mulai belajar gratis Lihat kursus lengkapnya

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Mendefinisikan Instance” gratis?

Ya — teks lengkap “Mendefinisikan Instance” 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 “Mendefinisikan Instance”?

Instance implisit. 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 2 dari 4.

Berapa lama pelajaran “Mendefinisikan Instance” 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